1 files changed, 56 insertions, 24 deletions

diff --git a/src/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedEuclideanDistanceFunction.java b/src/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedEuclideanDistanceFunction.java
index 4fb4e6a2..a8236663 100644
--- a/src/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedEuclideanDistanceFunction.java
+++ b/src/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedEuclideanDistanceFunction.java
@@ -4,7 +4,7 @@ package de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski;
  This file is part of ELKI:
  Environment for Developing KDD-Applications Supported by Index-Structures
 
- Copyright (C) 2013
+ Copyright (C) 2014
  Ludwig-Maximilians-Universität München
  Lehr- und Forschungseinheit für Datenbanksysteme
  ELKI Development Team
@@ -27,9 +27,13 @@ import java.util.Arrays;
 
 import de.lmu.ifi.dbs.elki.data.NumberVector;
 import de.lmu.ifi.dbs.elki.data.spatial.SpatialComparable;
+import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.ArrayLikeUtil;
+import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer;
+import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization;
+import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleListParameter;
 
 /**
- * Provides the Euclidean distance for FeatureVectors.
+ * Weighted Euclidean distance for {@link NumberVector}s.
  * 
  * @author Erich Schubert
  */
@@ -43,7 +47,7 @@ public class WeightedEuclideanDistanceFunction extends WeightedLPNormDistanceFun
     super(2.0, weights);
   }
 
-  private final double doublePreDistance(NumberVector<?> v1, NumberVector<?> v2, final int start, final int end, double agg) {
+  private final double preDistance(NumberVector v1, NumberVector v2, final int start, final int end, double agg) {
     for(int d = start; d < end; d++) {
       final double xd = v1.doubleValue(d), yd = v2.doubleValue(d);
       final double delta = xd - yd;
@@ -52,7 +56,7 @@ public class WeightedEuclideanDistanceFunction extends WeightedLPNormDistanceFun
     return agg;
   }
 
-  private final double doublePreDistanceVM(NumberVector<?> v, SpatialComparable mbr, final int start, final int end, double agg) {
+  private final double preDistanceVM(NumberVector v, SpatialComparable mbr, final int start, final int end, double agg) {
     for(int d = start; d < end; d++) {
       final double value = v.doubleValue(d), min = mbr.getMin(d);
       double delta = min - value;
@@ -66,7 +70,7 @@ public class WeightedEuclideanDistanceFunction extends WeightedLPNormDistanceFun
     return agg;
   }
 
-  private final double doublePreDistanceMBR(SpatialComparable mbr1, SpatialComparable mbr2, final int start, final int end, double agg) {
+  private final double preDistanceMBR(SpatialComparable mbr1, SpatialComparable mbr2, final int start, final int end, double agg) {
     for(int d = start; d < end; d++) {
       double delta = mbr2.getMin(d) - mbr1.getMax(d);
       if(delta < 0.) {
@@ -79,7 +83,7 @@ public class WeightedEuclideanDistanceFunction extends WeightedLPNormDistanceFun
     return agg;
   }
 
-  private final double doublePreNorm(NumberVector<?> v, final int start, final int end, double agg) {
+  private final double preNorm(NumberVector v, final int start, final int end, double agg) {
     for(int d = start; d < end; d++) {
       final double xd = v.doubleValue(d);
       agg += xd * xd * weights[d];
@@ -87,7 +91,7 @@ public class WeightedEuclideanDistanceFunction extends WeightedLPNormDistanceFun
     return agg;
   }
 
-  private final double doublePreNormMBR(SpatialComparable mbr, final int start, final int end, double agg) {
+  private final double preNormMBR(SpatialComparable mbr, final int start, final int end, double agg) {
     for(int d = start; d < end; d++) {
       double delta = mbr.getMin(d);
       if(delta < 0.) {
@@ -101,65 +105,65 @@ public class WeightedEuclideanDistanceFunction extends WeightedLPNormDistanceFun
   }
 
   @Override
-  public double doubleDistance(NumberVector<?> v1, NumberVector<?> v2) {
+  public double distance(NumberVector v1, NumberVector v2) {
     final int dim1 = v1.getDimensionality(), dim2 = v2.getDimensionality();
     final int mindim = (dim1 < dim2) ? dim1 : dim2;
-    double agg = doublePreDistance(v1, v2, 0, mindim, 0.);
+    double agg = preDistance(v1, v2, 0, mindim, 0.);
     if(dim1 > mindim) {
-      agg = doublePreNorm(v1, mindim, dim1, agg);
+      agg = preNorm(v1, mindim, dim1, agg);
     }
     else if(dim2 > mindim) {
-      agg = doublePreNorm(v2, mindim, dim2, agg);
+      agg = preNorm(v2, mindim, dim2, agg);
     }
     return Math.sqrt(agg);
   }
 
   @Override
-  public double doubleNorm(NumberVector<?> v) {
-    return Math.sqrt(doublePreNorm(v, 0, v.getDimensionality(), 0.));
+  public double norm(NumberVector v) {
+    return Math.sqrt(preNorm(v, 0, v.getDimensionality(), 0.));
   }
 
   @Override
-  public double doubleMinDist(SpatialComparable mbr1, SpatialComparable mbr2) {
+  public double minDist(SpatialComparable mbr1, SpatialComparable mbr2) {
     final int dim1 = mbr1.getDimensionality(), dim2 = mbr2.getDimensionality();
     final int mindim = (dim1 < dim2) ? dim1 : dim2;
 
-    final NumberVector<?> v1 = (mbr1 instanceof NumberVector) ? (NumberVector<?>) mbr1 : null;
-    final NumberVector<?> v2 = (mbr2 instanceof NumberVector) ? (NumberVector<?>) mbr2 : null;
+    final NumberVector v1 = (mbr1 instanceof NumberVector) ? (NumberVector) mbr1 : null;
+    final NumberVector v2 = (mbr2 instanceof NumberVector) ? (NumberVector) mbr2 : null;
 
     double agg = 0.;
     if(v1 != null) {
       if(v2 != null) {
-        agg = doublePreDistance(v1, v2, 0, mindim, agg);
+        agg = preDistance(v1, v2, 0, mindim, agg);
       }
       else {
-        agg = doublePreDistanceVM(v1, mbr2, 0, mindim, agg);
+        agg = preDistanceVM(v1, mbr2, 0, mindim, agg);
       }
     }
     else {
       if(v2 != null) {
-        agg = doublePreDistanceVM(v2, mbr1, 0, mindim, agg);
+        agg = preDistanceVM(v2, mbr1, 0, mindim, agg);
       }
       else {
-        agg = doublePreDistanceMBR(mbr1, mbr2, 0, mindim, agg);
+        agg = preDistanceMBR(mbr1, mbr2, 0, mindim, agg);
       }
     }
     // first object has more dimensions.
     if(dim1 > mindim) {
       if(v1 != null) {
-        agg = doublePreNorm(v1, mindim, dim1, agg);
+        agg = preNorm(v1, mindim, dim1, agg);
       }
       else {
-        agg = doublePreNormMBR(v1, mindim, dim1, agg);
+        agg = preNormMBR(v1, mindim, dim1, agg);
       }
     }
     // second object has more dimensions.
     if(dim2 > mindim) {
       if(v2 != null) {
-        agg = doublePreNorm(v2, mindim, dim2, agg);
+        agg = preNorm(v2, mindim, dim2, agg);
       }
       else {
-        agg = doublePreNormMBR(mbr2, mindim, dim2, agg);
+        agg = preNormMBR(mbr2, mindim, dim2, agg);
       }
     }
     return Math.sqrt(agg);
@@ -190,4 +194,32 @@ public class WeightedEuclideanDistanceFunction extends WeightedLPNormDistanceFun
     WeightedEuclideanDistanceFunction other = (WeightedEuclideanDistanceFunction) obj;
     return Arrays.equals(this.weights, other.weights);
   }
+
+  /**
+   * Parameterization class.
+   * 
+   * @author Erich Schubert
+   * 
+   * @apiviz.exclude
+   */
+  public static class Parameterizer extends AbstractParameterizer {
+    /**
+     * Weight array
+     */
+    protected double[] weights;
+
+    @Override
+    protected void makeOptions(Parameterization config) {
+      super.makeOptions(config);
+      DoubleListParameter weightsP = new DoubleListParameter(WEIGHTS_ID);
+      if(config.grab(weightsP)) {
+        weights = ArrayLikeUtil.toPrimitiveDoubleArray(weightsP.getValue());
+      }
+    }
+
+    @Override
+    protected WeightedEuclideanDistanceFunction makeInstance() {
+      return new WeightedEuclideanDistanceFunction(weights);
+    }
+  }
 }