Index: trunk/CrossPare/src/de/ugoe/cs/cpdp/wekaclassifier/LogisticEnsemble.java
===================================================================
--- trunk/CrossPare/src/de/ugoe/cs/cpdp/wekaclassifier/LogisticEnsemble.java	(revision 53)
+++ trunk/CrossPare/src/de/ugoe/cs/cpdp/wekaclassifier/LogisticEnsemble.java	(revision 53)
@@ -0,0 +1,106 @@
+// Copyright 2015 Georg-August-Universität Göttingen, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package de.ugoe.cs.cpdp.wekaclassifier;
+
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import weka.classifiers.AbstractClassifier;
+import weka.classifiers.Classifier;
+import weka.classifiers.functions.Logistic;
+import weka.core.DenseInstance;
+import weka.core.Instance;
+import weka.core.Instances;
+
+/**
+ * Logistic Ensemble Classifier after Uchigaki et al. 
+ *
+ * TODO comment class
+ * @author Steffen Herbold
+ */
+public class LogisticEnsemble extends AbstractClassifier {
+
+    private static final long serialVersionUID = 1L;
+
+    private List<Instances> trainingData = null;
+
+    private List<Classifier> classifiers = null;
+    
+    private String[] options; 
+
+    @Override
+    public void setOptions(String[] options) throws Exception {
+        this.options = options;
+    }
+    
+    @Override
+    public double classifyInstance(Instance instance) {
+        if (classifiers == null) {
+            return 0.0;
+        }
+
+        double classification = 0.0;
+        for (int i = 0; i < classifiers.size(); i++) {
+            Classifier classifier = classifiers.get(i);
+            Instances traindata = trainingData.get(i);
+
+            Set<String> attributeNames = new HashSet<>();
+            for (int j = 0; j < traindata.numAttributes(); j++) {
+                attributeNames.add(traindata.attribute(j).name());
+            }
+
+            double[] values = new double[traindata.numAttributes()];
+            int index = 0;
+            for (int j = 0; j < instance.numAttributes(); j++) {
+                if (attributeNames.contains(instance.attribute(j).name())) {
+                    values[index] = instance.value(j);
+                    index++;
+                }
+            }
+
+            Instances tmp = new Instances(traindata);
+            tmp.clear();
+            Instance instCopy = new DenseInstance(instance.weight(), values);
+            instCopy.setDataset(tmp);
+            try {
+                classification += classifier.classifyInstance(instCopy);
+            }
+            catch (Exception e) {
+                throw new RuntimeException("bagging classifier could not classify an instance", e);
+            }
+        }
+        classification /= classifiers.size();
+        return (classification >= 0.5) ? 1.0 : 0.0;
+    }
+
+    @Override
+    public void buildClassifier(Instances traindata) throws Exception {
+        classifiers = new LinkedList<>();
+        for( int j=0 ; j<traindata.numAttributes() ; j++) {
+            final Logistic classifier = new Logistic();
+            classifier.setOptions(options);
+            final Instances copy = new Instances(traindata);
+            for( int k=traindata.numAttributes()-1; k>=0 ; k-- ) {
+                if( j!=k && traindata.classIndex()!=k ) {
+                    copy.deleteAttributeAt(k);
+                }
+            }
+            classifier.buildClassifier(copy);
+            classifiers.add(classifier);
+        }
+    }
+}