Import Debian changes 0.5.5-1

elki (0.5.5-1) unstable; urgency=low

  * New upstream release: 0.5.5 interim release.

1 files changed, 99 insertions, 117 deletions

diff --git a/src/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPTree.java b/src/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPTree.java
index 26ae17db..562f7f4a 100644
--- a/src/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPTree.java
+++ b/src/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPTree.java
@@ -24,21 +24,20 @@ package de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.mktrees.mkcop;
  */
 
 import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Map.Entry;
 
 import de.lmu.ifi.dbs.elki.database.ids.DBID;
 import de.lmu.ifi.dbs.elki.database.ids.DBIDIter;
 import de.lmu.ifi.dbs.elki.database.ids.DBIDRef;
 import de.lmu.ifi.dbs.elki.database.ids.DBIDUtil;
 import de.lmu.ifi.dbs.elki.database.ids.ModifiableDBIDs;
-import de.lmu.ifi.dbs.elki.database.query.DistanceResultPair;
-import de.lmu.ifi.dbs.elki.database.query.GenericDistanceResultPair;
 import de.lmu.ifi.dbs.elki.database.query.distance.DistanceQuery;
 import de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction;
+import de.lmu.ifi.dbs.elki.distance.distanceresultlist.DistanceDBIDResult;
+import de.lmu.ifi.dbs.elki.distance.distanceresultlist.DistanceDBIDResultIter;
+import de.lmu.ifi.dbs.elki.distance.distanceresultlist.GenericDistanceDBIDList;
+import de.lmu.ifi.dbs.elki.distance.distanceresultlist.KNNResult;
 import de.lmu.ifi.dbs.elki.distance.distancevalue.NumberDistance;
 import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.mktrees.AbstractMkTree;
 import de.lmu.ifi.dbs.elki.index.tree.query.GenericMTreeDistanceSearchCandidate;
@@ -47,9 +46,6 @@ import de.lmu.ifi.dbs.elki.persistent.PageFile;
 import de.lmu.ifi.dbs.elki.utilities.FormatUtil;
 import de.lmu.ifi.dbs.elki.utilities.QueryStatistic;
 import de.lmu.ifi.dbs.elki.utilities.datastructures.heap.Heap;
-import de.lmu.ifi.dbs.elki.utilities.datastructures.heap.KNNHeap;
-import de.lmu.ifi.dbs.elki.utilities.datastructures.heap.KNNList;
-import de.lmu.ifi.dbs.elki.utilities.datastructures.heap.UpdatableHeap;
 
 /**
  * MkCopTree is a metrical index structure based on the concepts of the M-Tree
@@ -68,7 +64,7 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
   /**
    * The logger for this class.
    */
-  private static final Logging logger = Logging.getLogger(MkCoPTree.class);
+  private static final Logging LOG = Logging.getLogger(MkCoPTree.class);
 
   /**
    * Parameter k.
@@ -125,41 +121,30 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
       return;
     }
 
-    if(logger.isDebugging()) {
-      logger.debugFine("insert " + entries + "\n");
+    if(LOG.isDebugging()) {
+      LOG.debugFine("insert " + entries + "\n");
     }
 
     if(!initialized) {
       initialize(entries.get(0));
     }
 
-    Map<DBID, KNNHeap<D>> knnHeaps = new HashMap<DBID, KNNHeap<D>>(entries.size());
     ModifiableDBIDs ids = DBIDUtil.newArray(entries.size());
 
     // insert
     for(MkCoPEntry<D> entry : entries) {
-      DBID id = entry.getRoutingObjectID();
-      // create knnList for the object
-      knnHeaps.put(id, new KNNHeap<D>(k_max + 1, getDistanceQuery().infiniteDistance()));
-
-      ids.add(id);
+      ids.add(entry.getRoutingObjectID());
       // insert the object
       super.insert(entry, false);
     }
 
-    // do batch nn
-    batchNN(getRoot(), ids, knnHeaps);
-
-    // finish KNN lists (sort them completely)
-    Map<DBID, KNNList<D>> knnLists = new HashMap<DBID, KNNList<D>>();
-    for(Entry<DBID, KNNHeap<D>> ent : knnHeaps.entrySet()) {
-      knnLists.put(ent.getKey(), ent.getValue().toKNNList());
-    }
+    // perform nearest neighbor queries
+    Map<DBID, KNNResult<D>> knnLists = batchNN(getRoot(), ids, k_max);
 
     // adjust the knn distances
     adjustApproximatedKNNDistances(getRootEntry(), knnLists);
 
-    if(extraIntegrityChecks) {
+    if(EXTRA_INTEGRITY_CHECKS) {
       getRoot().integrityCheck(this, getRootEntry());
     }
   }
@@ -173,38 +158,35 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
    * @return a List of the query results
    */
   @Override
-  public List<DistanceResultPair<D>> reverseKNNQuery(DBIDRef id, int k) {
+  public DistanceDBIDResult<D> reverseKNNQuery(DBIDRef id, int k) {
     if(k > this.k_max) {
       throw new IllegalArgumentException("Parameter k has to be less or equal than " + "parameter kmax of the MCop-Tree!");
     }
 
-    List<DistanceResultPair<D>> result = new ArrayList<DistanceResultPair<D>>();
+    GenericDistanceDBIDList<D> result = new GenericDistanceDBIDList<D>();
     ModifiableDBIDs candidates = DBIDUtil.newArray();
     doReverseKNNQuery(k, id, result, candidates);
 
     // refinement of candidates
-    Map<DBID, KNNHeap<D>> knnLists = new HashMap<DBID, KNNHeap<D>>();
-    for (DBIDIter iter = candidates.iter(); iter.valid(); iter.advance()) {
-      knnLists.put(iter.getDBID(), new KNNHeap<D>(k, getDistanceQuery().infiniteDistance()));
-    }
-    batchNN(getRoot(), candidates, knnLists);
+    Map<DBID, KNNResult<D>> knnLists = batchNN(getRoot(), candidates, k);
 
-    Collections.sort(result);
+    result.sort();
     // Collections.sort(candidates);
 
     rkNNStatistics.addCandidates(candidates.size());
     rkNNStatistics.addTrueHits(result.size());
 
-    for (DBIDIter iter = candidates.iter(); iter.valid(); iter.advance()) {
-      DBID cid = iter.getDBID();
-      for(DistanceResultPair<D> qr : knnLists.get(id)) {
-        if(qr.getDBID().equals(id)) {
-          result.add(new GenericDistanceResultPair<D>(qr.getDistance(), cid));
+    for(DBIDIter iter = candidates.iter(); iter.valid(); iter.advance()) {
+      DBID cid = DBIDUtil.deref(iter);
+      KNNResult<D> cands = knnLists.get(cid);
+      for (DistanceDBIDResultIter<D> iter2 = cands.iter(); iter2.valid(); iter2.advance()) {
+        if(DBIDUtil.equal(id, iter2)) {
+          result.add(iter2.getDistance(), cid);
           break;
         }
       }
     }
-    Collections.sort(result);
+    result.sort();
 
     rkNNStatistics.addResults(result.size());
     return result;
@@ -257,10 +239,11 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
     }
 
     if(dirCapacity < 10) {
-      logger.warning("Page size is choosen too small! Maximum number of entries " + "in a directory node = " + (dirCapacity - 1));
+      LOG.warning("Page size is choosen too small! Maximum number of entries " + "in a directory node = " + (dirCapacity - 1));
     }
 
-    // leafCapacity = (file.getPageSize() - overhead) / (objectID + parentDistance +
+    // leafCapacity = (file.getPageSize() - overhead) / (objectID +
+    // parentDistance +
     // consApprox + progrApprox) + 1
     leafCapacity = (int) (getPageSize() - overhead) / (4 + distanceSize + 2 * 10) + 1;
 
@@ -269,13 +252,13 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
     }
 
     if(leafCapacity < 10) {
-      logger.warning("Page size is choosen too small! Maximum number of entries " + "in a leaf node = " + (leafCapacity - 1));
+      LOG.warning("Page size is choosen too small! Maximum number of entries " + "in a leaf node = " + (leafCapacity - 1));
     }
 
     initialized = true;
 
-    if(logger.isVerbose()) {
-      logger.verbose("Directory Capacity: " + (dirCapacity - 1) + "\nLeaf Capacity:    " + (leafCapacity - 1));
+    if(LOG.isVerbose()) {
+      LOG.verbose("Directory Capacity: " + (dirCapacity - 1) + "\nLeaf Capacity:    " + (leafCapacity - 1));
     }
   }
 
@@ -288,15 +271,16 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
    * @param candidates holds possible candidates for the result (they need a
    *        refinement)
    */
-  private void doReverseKNNQuery(int k, DBIDRef q, List<DistanceResultPair<D>> result, ModifiableDBIDs candidates) {
-    final Heap<GenericMTreeDistanceSearchCandidate<D>> pq = new UpdatableHeap<GenericMTreeDistanceSearchCandidate<D>>();
+  private void doReverseKNNQuery(int k, DBIDRef q, GenericDistanceDBIDList<D> result, ModifiableDBIDs candidates) {
+    final Heap<GenericMTreeDistanceSearchCandidate<D>> pq = new Heap<GenericMTreeDistanceSearchCandidate<D>>();
 
     // push root
-    pq.add(new GenericMTreeDistanceSearchCandidate<D>(getDistanceQuery().nullDistance(), getRootID(), null));
+    pq.add(new GenericMTreeDistanceSearchCandidate<D>(getDistanceQuery().nullDistance(), getRootID(), null, null));
 
     // search in tree
     while(!pq.isEmpty()) {
       GenericMTreeDistanceSearchCandidate<D> pqNode = pq.poll();
+      // FIXME: cache the distance to the routing object in the queue node!
 
       MkCoPTreeNode<O, D> node = getNode(pqNode.nodeID);
 
@@ -309,7 +293,7 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
           D approximatedKnnDist_cons = entry.approximateConservativeKnnDistance(k, getDistanceQuery());
 
           if(minDist.compareTo(approximatedKnnDist_cons) <= 0) {
-            pq.add(new GenericMTreeDistanceSearchCandidate<D>(minDist, getPageID(entry), entry.getRoutingObjectID()));
+            pq.add(new GenericMTreeDistanceSearchCandidate<D>(minDist, getPageID(entry), entry.getRoutingObjectID(), null));
           }
         }
       }
@@ -321,7 +305,7 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
           D approximatedKnnDist_prog = entry.approximateProgressiveKnnDistance(k, getDistanceQuery());
 
           if(distance.compareTo(approximatedKnnDist_prog) <= 0) {
-            result.add(new GenericDistanceResultPair<D>(distance, entry.getRoutingObjectID()));
+            result.add(distance, entry.getRoutingObjectID());
           }
           else {
             D approximatedKnnDist_cons = entry.approximateConservativeKnnDistance(k, getDistanceQuery());
@@ -341,7 +325,7 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
    * @param entry the root entry of the current subtree
    * @param knnLists a map of knn lists for each leaf entry
    */
-  private void adjustApproximatedKNNDistances(MkCoPEntry<D> entry, Map<DBID, KNNList<D>> knnLists) {
+  private void adjustApproximatedKNNDistances(MkCoPEntry<D> entry, Map<DBID, KNNResult<D>> knnLists) {
     MkCoPTreeNode<O, D> node = getNode(entry);
 
     if(node.isLeaf()) {
@@ -393,10 +377,10 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
    * @param knnDistances TODO: Spezialbehandlung fuer identische Punkte in DB
    *        (insbes. Distanz 0)
    */
-  private void approximateKnnDistances(MkCoPLeafEntry<D> entry, KNNList<D> knnDistances) {
-    StringBuffer msg = new StringBuffer();
-    if(logger.isDebugging()) {
-      msg.append("\nknnDistances " + knnDistances);
+  private void approximateKnnDistances(MkCoPLeafEntry<D> entry, KNNResult<D> knnDistances) {
+    StringBuilder msg = LOG.isDebugging() ? new StringBuilder() : null;
+    if(msg != null) {
+      msg.append("\nknnDistances ").append(knnDistances);
     }
 
     // count the zero distances
@@ -434,16 +418,16 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
       sum_log_k2 += (log_k[i] * log_k[i]);
     }
 
-    if(logger.isDebugging()) {
-      msg.append("\nk_0 " + k_0);
-      msg.append("\nk_max " + k_max);
-      msg.append("\nlog_k(" + log_k.length + ") " + FormatUtil.format(log_k));
-      msg.append("\nsum_log_k " + sum_log_k);
-      msg.append("\nsum_log_k^2 " + sum_log_k2);
-      msg.append("\nkDists " + knnDistances);
-      msg.append("\nlog_kDist(" + log_kDist.length + ") " + FormatUtil.format(log_kDist));
-      msg.append("\nsum_log_kDist " + sum_log_kDist);
-      msg.append("\nsum_log_k_kDist " + sum_log_k_kDist);
+    if(msg != null) {
+      msg.append("\nk_0 ").append(k_0);
+      msg.append("\nk_max ").append(k_max);
+      msg.append("\nlog_k(").append(log_k.length).append(") ").append(FormatUtil.format(log_k));
+      msg.append("\nsum_log_k ").append(sum_log_k);
+      msg.append("\nsum_log_k^2 ").append(sum_log_k2);
+      msg.append("\nkDists ").append(knnDistances);
+      msg.append("\nlog_kDist(").append(log_kDist.length).append(") ").append(FormatUtil.format(log_kDist));
+      msg.append("\nsum_log_kDist ").append(sum_log_kDist);
+      msg.append("\nsum_log_k_kDist ").append(sum_log_k_kDist);
     }
 
     // lower and upper hull
@@ -457,28 +441,28 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
     double err1 = ssqerr(k_0, k_max, log_k, log_kDist, conservative.getM(), conservative.getT());
     double err2 = ssqerr(k_0, k_max, log_k, log_kDist, c2.getM(), c2.getT());
 
-    if(logger.isDebugging()) {
-      msg.append("err1 " + err1);
-      msg.append("err2 " + err2);
+    if(msg != null) {
+      msg.append("err1 ").append(err1);
+      msg.append("err2 ").append(err2);
     }
 
     if(err1 > err2 && err1 - err2 > 0.000000001) {
       // if (err1 > err2) {
 
-      StringBuffer warning = new StringBuffer();
+      StringBuilder warning = new StringBuilder();
       int u = convexHull.getNumberOfPointsInUpperHull();
       int[] upperHull = convexHull.getUpperHull();
-      warning.append("\nentry " + entry.getRoutingObjectID());
-      warning.append("\nlower Hull " + convexHull.getNumberOfPointsInLowerHull() + " " + FormatUtil.format(convexHull.getLowerHull()));
-      warning.append("\nupper Hull " + convexHull.getNumberOfPointsInUpperHull() + " " + FormatUtil.format(convexHull.getUpperHull()));
-      warning.append("\nerr1 " + err1);
-      warning.append("\nerr2 " + err2);
-      warning.append("\nconservative1 " + conservative);
-      warning.append("\nconservative2 " + c2);
+      warning.append("\nentry ").append(entry.getRoutingObjectID());
+      warning.append("\nlower Hull ").append(convexHull.getNumberOfPointsInLowerHull()).append(" ").append(FormatUtil.format(convexHull.getLowerHull()));
+      warning.append("\nupper Hull ").append(convexHull.getNumberOfPointsInUpperHull()).append(" ").append(FormatUtil.format(convexHull.getUpperHull()));
+      warning.append("\nerr1 ").append(err1);
+      warning.append("\nerr2 ").append(err2);
+      warning.append("\nconservative1 ").append(conservative);
+      warning.append("\nconservative2 ").append(c2);
 
       for(int i = 0; i < u; i++) {
-        warning.append("\nlog_k[" + upperHull[i] + "] = " + log_k[upperHull[i]]);
-        warning.append("\nlog_kDist[" + upperHull[i] + "] = " + log_kDist[upperHull[i]]);
+        warning.append("\nlog_k[").append(upperHull[i]).append("] = ").append(log_k[upperHull[i]]);
+        warning.append("\nlog_kDist[").append(upperHull[i]).append("] = ").append(log_kDist[upperHull[i]]);
       }
       // warning(warning.toString());
     }
@@ -489,10 +473,9 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
     entry.setConservativeKnnDistanceApproximation(conservative);
     entry.setProgressiveKnnDistanceApproximation(progressive);
 
-    if(logger.isDebugging()) {
-      logger.debugFine(msg.toString());
+    if(msg != null) {
+      LOG.debugFine(msg.toString());
     }
-
   }
 
   /**
@@ -505,13 +488,13 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
    */
   private ApproximationLine approximateLowerHull(ConvexHull convexHull, double[] log_k, double sum_log_k, double sum_log_k2, double[] log_kDist, double sum_log_kDist, double sum_log_k_kDist) {
 
-    StringBuffer msg = new StringBuffer();
+    StringBuilder msg = new StringBuilder();
     int[] lowerHull = convexHull.getLowerHull();
     int l = convexHull.getNumberOfPointsInLowerHull();
     int k_0 = k_max - lowerHull.length + 1;
 
     // linear search on all line segments on the lower convex hull
-    msg.append("lower hull l = " + l + "\n");
+    msg.append("lower hull l = ").append(l).append("\n");
     double low_error = Double.MAX_VALUE;
     double low_m = 0.0;
     double low_t = 0.0;
@@ -520,7 +503,7 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
       double cur_m = (log_kDist[lowerHull[i]] - log_kDist[lowerHull[i - 1]]) / (log_k[lowerHull[i]] - log_k[lowerHull[i - 1]]);
       double cur_t = log_kDist[lowerHull[i]] - cur_m * log_k[lowerHull[i]];
       double cur_error = ssqerr(k_0, k_max, log_k, log_kDist, cur_m, cur_t);
-      msg.append("  Segment = " + i + " m = " + cur_m + " t = " + cur_t + " lowerror = " + cur_error + "\n");
+      msg.append("  Segment = ").append(i).append(" m = ").append(cur_m).append(" t = ").append(cur_t).append(" lowerror = ").append(cur_error).append("\n");
       if(cur_error < low_error) {
         low_error = cur_error;
         low_m = cur_m;
@@ -557,7 +540,7 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
   }
 
   private ApproximationLine approximateUpperHull(ConvexHull convexHull, double[] log_k, double[] log_kDist) {
-    StringBuffer msg = new StringBuffer();
+    StringBuilder msg = new StringBuilder();
 
     int[] upperHull = convexHull.getUpperHull();
     int u = convexHull.getNumberOfPointsInUpperHull();
@@ -572,13 +555,13 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
       double current_t = log_kDist[ii] - current_m * log_k[ii];
       ApproximationLine current_approx = new ApproximationLine(k_0, current_m, current_t);
 
-      if(logger.isDebugging()) {
-        msg.append("\nlog_kDist[" + jj + "] " + log_kDist[jj]);
-        msg.append("\nlog_kDist[" + ii + "] " + log_kDist[ii]);
-        msg.append("\nlog_k[" + jj + "] " + log_k[jj]);
-        msg.append("\nlog_k[" + ii + "] " + log_k[ii]);
-        msg.append("\n" + (log_kDist[jj] - log_kDist[ii]));
-        msg.append("\ncurrent_approx_" + i + " " + current_approx);
+      if(LOG.isDebugging()) {
+        msg.append("\nlog_kDist[").append(jj).append("] ").append(log_kDist[jj]);
+        msg.append("\nlog_kDist[").append(ii).append("] ").append(log_kDist[ii]);
+        msg.append("\nlog_k[").append(jj).append("] ").append(log_k[jj]);
+        msg.append("\nlog_k[").append(ii).append("] ").append(log_k[ii]);
+        msg.append("\n").append((log_kDist[jj] - log_kDist[ii]));
+        msg.append("\ncurrent_approx_").append(i).append(" ").append(current_approx);
       }
 
       boolean ok = true;
@@ -598,15 +581,15 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
       }
     }
 
-    if(logger.isDebugging()) {
-      msg.append("\nupper Approx " + approx);
-      logger.debugFine(msg.toString());
+    if(LOG.isDebugging()) {
+      msg.append("\nupper Approx ").append(approx);
+      LOG.debugFine(msg.toString());
     }
     return approx;
   }
 
   private ApproximationLine approximateUpperHull_PAPER(ConvexHull convexHull, double[] log_k, double sum_log_k, double sum_log_k2, double[] log_kDist, double sum_log_kDist, double sum_log_k_kDist) {
-    StringBuffer msg = new StringBuffer();
+    StringBuilder msg = LOG.isDebugging() ? new StringBuilder() : null;
 
     int[] upperHull = convexHull.getUpperHull();
     int u = convexHull.getNumberOfPointsInUpperHull();
@@ -624,9 +607,9 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
       double m_a = optimize(k_0, k_max, sum_log_k, sum_log_k2, x_a, y_a, sum_log_k_kDist, sum_log_kDist);
       double t_a = y_a - m_a * x_a;
 
-      if(logger.isDebugging()) {
-        msg.append("\na=" + a + " m_a=" + m_a + ", t_a=" + t_a);
-        msg.append("\n err " + ssqerr(k_0, k_max, log_k, log_kDist, m_a, m_a));
+      if(msg != null) {
+        msg.append("\na=").append(a).append(" m_a=").append(m_a).append(", t_a=").append(t_a);
+        msg.append("\n err ").append(ssqerr(k_0, k_max, log_k, log_kDist, m_a, m_a));
       }
 
       double x_p = a == 0 ? Double.NaN : log_k[upperHull[a - 1]];
@@ -639,13 +622,12 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
 
       if(lessThanPre && lessThanSuc) {
         ApproximationLine appr = new ApproximationLine(k_0, m_a, t_a);
-        if(logger.isDebugging()) {
-          msg.append("\n1 anchor = " + a);
-          logger.debugFine(msg.toString());
+        if(msg != null) {
+          msg.append("\n1 anchor = ").append(a);
+          LOG.debugFine(msg.toString());
         }
         return appr;
       }
-
       else if(!lessThanPre) {
         if(marked.contains(a - 1)) {
           m_a = (y_a - y_p) / (x_a - x_p);
@@ -655,14 +637,14 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
           t_a = y_a - m_a * x_a;
 
           ApproximationLine appr = new ApproximationLine(k_0, m_a, t_a);
-          if(logger.isDebugging()) {
-            msg.append("2 anchor = " + a);
-            msg.append(" appr1 " + appr);
-            msg.append(" x_a " + x_a + ", y_a " + y_a);
-            msg.append(" x_p " + x_p + ", y_p " + y_p);
-            msg.append(" a " + a);
-            msg.append(" upperHull " + FormatUtil.format(upperHull));
-            logger.debugFine(msg.toString());
+          if(msg != null) {
+            msg.append("2 anchor = ").append(a);
+            msg.append(" appr1 ").append(appr);
+            msg.append(" x_a ").append(x_a).append(", y_a ").append(y_a);
+            msg.append(" x_p ").append(x_p).append(", y_p ").append(y_p);
+            msg.append(" a ").append(a);
+            msg.append(" upperHull ").append(FormatUtil.format(upperHull));
+            LOG.debugFine(msg.toString());
           }
           return appr;
         }
@@ -679,10 +661,10 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
           t_a = y_a - m_a * x_a;
           ApproximationLine appr = new ApproximationLine(k_0, m_a, t_a);
 
-          if(logger.isDebugging()) {
-            msg.append("3 anchor = " + a + " -- " + (a + 1));
-            msg.append(" appr2 " + appr);
-            logger.debugFine(msg.toString());
+          if(msg != null) {
+            msg.append("3 anchor = ").append(a).append(" -- ").append((a + 1));
+            msg.append(" appr2 ").append(appr);
+            LOG.debugFine(msg.toString());
           }
           return appr;
         }
@@ -698,7 +680,7 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
 
   @SuppressWarnings("unused")
   private ApproximationLine approximateUpperHull_OLD(ConvexHull convexHull, double[] log_k, double sum_log_k, double sum_log_k2, double[] log_kDist, double sum_log_kDist, double sum_log_k_kDist) {
-    StringBuffer msg = new StringBuffer();
+    StringBuilder msg = new StringBuilder();
     int[] upperHull = convexHull.getUpperHull();
     int u = convexHull.getNumberOfPointsInUpperHull();
     int k_0 = k_max - upperHull.length + 1;
@@ -794,6 +776,6 @@ public class MkCoPTree<O, D extends NumberDistance<D, ?>> extends AbstractMkTree
 
   @Override
   protected Logging getLogger() {
-    return logger;
+    return LOG;
   }
 }
\ No newline at end of file