diff options
Diffstat (limited to 'elki/src/main/java/de')
1659 files changed, 6531 insertions, 1347 deletions
diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/KDDTask.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/KDDTask.java index 307387d0..1d58b3ba 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/KDDTask.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/KDDTask.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.workflow.OutputStep; * discovery task. * * @author Arthur Zimek + * @since 0.2 * * @apiviz.composedOf InputStep * @apiviz.composedOf AlgorithmStep diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/AbstractAlgorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/AbstractAlgorithm.java index 0851a898..8f721fdc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/AbstractAlgorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/AbstractAlgorithm.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Arthur Zimek + * @since 0.2 * * @apiviz.landmark * @apiviz.excludeSubtypes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/AbstractDistanceBasedAlgorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/AbstractDistanceBasedAlgorithm.java index 5729695c..bbf76f03 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/AbstractDistanceBasedAlgorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/AbstractDistanceBasedAlgorithm.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Abstract base class for distance-based algorithms. * * @author Arthur Zimek + * @since 0.2 * * @apiviz.landmark * @apiviz.has DistanceFunction diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/AbstractNumberVectorDistanceBasedAlgorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/AbstractNumberVectorDistanceBasedAlgorithm.java index 5c09d4a8..e0beaa36 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/AbstractNumberVectorDistanceBasedAlgorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/AbstractNumberVectorDistanceBasedAlgorithm.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * synthetic numerical vectors such as <b>mean</b> vectors. * * @author Erich Schubert + * @since 0.2 * * @apiviz.has NumberVectorDistanceFunction * @apiviz.excludeSubtypes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/AbstractPrimitiveDistanceBasedAlgorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/AbstractPrimitiveDistanceBasedAlgorithm.java index 06625263..21de6b59 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/AbstractPrimitiveDistanceBasedAlgorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/AbstractPrimitiveDistanceBasedAlgorithm.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * only database objects! * * @author Arthur Zimek + * @since 0.2 * * @apiviz.has PrimitiveDistanceFunction * @apiviz.excludeSubtypes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/Algorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/Algorithm.java index 1ca6ffa3..cea7f4b3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/Algorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/Algorithm.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.result.Result; * </p> * * @author Arthur Zimek + * @since 0.2 */ public interface Algorithm { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/DependencyDerivator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/DependencyDerivator.java index 3c6dbba6..b46fc6ac 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/DependencyDerivator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/DependencyDerivator.java @@ -71,6 +71,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Arthur Zimek + * @since 0.2 * @param <V> the type of FeatureVector handled by this Algorithm */ @Title("Dependency Derivator: Deriving numerical inter-dependencies on data") diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/DistanceBasedAlgorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/DistanceBasedAlgorithm.java index 5171de6d..5c4eaaf8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/DistanceBasedAlgorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/DistanceBasedAlgorithm.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; * Very broad interface for distance based algorithms. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/DummyAlgorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/DummyAlgorithm.java index 595de4bd..7aa28b70 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/DummyAlgorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/DummyAlgorithm.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * NullAlgorithm} instead. * * @author Erich Schubert + * @since 0.2 * @param <O> Vector type * * @apiviz.uses KNNQuery diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/KNNDistancesSampler.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/KNNDistancesSampler.java index 3e78ba77..a81823c1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/KNNDistancesSampler.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/KNNDistancesSampler.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; import de.lmu.ifi.dbs.elki.logging.progress.FiniteProgress; import de.lmu.ifi.dbs.elki.math.geometry.XYCurve; import de.lmu.ifi.dbs.elki.math.random.RandomFactory; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; import de.lmu.ifi.dbs.elki.utilities.documentation.Title; import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; @@ -59,11 +60,13 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * and look for a bend or knee in this plot. * * @author Arthur Zimek + * @since 0.7.0 * * @param <O> the type of objects handled by this Algorithm */ @Title("KNN-Distance-Order") @Description("Assesses the knn distances for a specified k and orders them.") +@Alias("de.lmu.ifi.dbs.elki.algorithm.KNNDistanceOrder") public class KNNDistancesSampler<O> extends AbstractDistanceBasedAlgorithm<O, KNNDistanceOrderResult> { /** * The logger for this class. @@ -115,7 +118,7 @@ public class KNNDistancesSampler<O> extends AbstractDistanceBasedAlgorithm<O, KN final int size = (int) ((sample <= 1.) ? Math.ceil(relation.size() * sample) : sample); DBIDs sample = DBIDUtil.randomSample(relation.getDBIDs(), size, rnd); - FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("Sampling kNN distances.", size, LOG) : null; + FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("Sampling kNN distances", size, LOG) : null; double[] knnDistances = new double[size]; int i = 0; for(DBIDIter iditer = sample.iter(); iditer.valid(); iditer.advance(), i++) { @@ -251,4 +254,4 @@ public class KNNDistancesSampler<O> extends AbstractDistanceBasedAlgorithm<O, KN return new KNNDistancesSampler<>(distanceFunction, k, percentage, rnd); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/KNNJoin.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/KNNJoin.java index 593582ed..ff1ae57f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/KNNJoin.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/KNNJoin.java @@ -71,6 +71,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * * @author Elke Achtert * @author Erich Schubert + * @since 0.2 * * @param <V> the type of FeatureVector handled by this Algorithm * @param <N> the type of node used in the spatial index structure diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/MaterializeDistances.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/MaterializeDistances.java index f9de15b0..ea061a71 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/MaterializeDistances.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/MaterializeDistances.java @@ -49,6 +49,9 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * MultipleFileInput to use cached distances. * * Symmetry is assumed. + * + * @author Erich Schubert + * @since 0.2 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/NullAlgorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/NullAlgorithm.java index 5e7cf151..57eb6910 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/NullAlgorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/NullAlgorithm.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * set. * * @author Erich Schubert + * @since 0.2 */ @Title("Null Algorithm") @Description("Algorithm which does nothing, just return a null object.") diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/benchmark/KNNBenchmarkAlgorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/benchmark/KNNBenchmarkAlgorithm.java index 611e0c41..1d20e9b2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/benchmark/KNNBenchmarkAlgorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/benchmark/KNNBenchmarkAlgorithm.java @@ -58,6 +58,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * the original database. * * @author Erich Schubert + * @since 0.5.5 * * @param <O> Object type * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/benchmark/RangeQueryBenchmarkAlgorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/benchmark/RangeQueryBenchmarkAlgorithm.java index 9a5532e3..98c66129 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/benchmark/RangeQueryBenchmarkAlgorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/benchmark/RangeQueryBenchmarkAlgorithm.java @@ -89,6 +89,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * TODO: alternatively, allow using a fixed radius? * * @author Erich Schubert + * @since 0.5.5 * * @param <O> Vector type * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/benchmark/ValidateApproximativeKNNIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/benchmark/ValidateApproximativeKNNIndex.java index 64e00abd..fc1098ff 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/benchmark/ValidateApproximativeKNNIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/benchmark/ValidateApproximativeKNNIndex.java @@ -65,6 +65,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * exact indexing (e.g. linear scanning). * * @author Erich Schubert + * @since 0.5.5 * * @param <O> Object type * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/classification/AbstractClassifier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/classification/AbstractClassifier.java index fe97c83e..c4db6887 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/classification/AbstractClassifier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/classification/AbstractClassifier.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * Abstract base class for algorithms. * * @author Erich Schubert + * @since 0.7.0 * * @param <O> Input type * @param <R> Result type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/classification/Classifier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/classification/Classifier.java index 429f016a..ebdb7fe5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/classification/Classifier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/classification/Classifier.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * classify a new instance of the same type. * * @author Arthur Zimek + * @since 0.7.0 * * @param <O> the type of DatabaseObjects handled by this Algorithm */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/classification/KNNClassifier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/classification/KNNClassifier.java index c506fa8b..84e40731 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/classification/KNNClassifier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/classification/KNNClassifier.java @@ -56,6 +56,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * k nearest neighbors in a database. * * @author Arthur Zimek + * @since 0.7.0 * @param <O> the type of DatabaseObjects handled by this Algorithm */ @Title("kNN-classifier") diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/classification/PriorProbabilityClassifier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/classification/PriorProbabilityClassifier.java index 0032e8ac..df1d0f86 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/classification/PriorProbabilityClassifier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/classification/PriorProbabilityClassifier.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * the database, without using the actual data values. * * @author Arthur Zimek + * @since 0.7.0 */ @Title("Prior Probability Classifier") @Description("Classifier to predict simply prior probabilities for all classes as defined by their relative abundance in a given database.") diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/AbstractProjectedClustering.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/AbstractProjectedClustering.java index c63df6c3..2b17380a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/AbstractProjectedClustering.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/AbstractProjectedClustering.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * and {@link de.lmu.ifi.dbs.elki.algorithm.clustering.correlation.ORCLUS}. * * @author Elke Achtert + * @since 0.2 * * @param <R> the result we return * @param <V> the type of FeatureVector handled by this Algorithm diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/CanopyPreClustering.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/CanopyPreClustering.java index c8e17b45..49d3586f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/CanopyPreClustering.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/CanopyPreClustering.java @@ -61,6 +61,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/ClusteringAlgorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/ClusteringAlgorithm.java index b0f3e2d3..a7957d1e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/ClusteringAlgorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/ClusteringAlgorithm.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.database.Database; * database complete or is in any other sense a relaxed clustering result. * * @author Arthur Zimek + * @since 0.2 * * @apiviz.has Clustering * @apiviz.has Model diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/ClusteringAlgorithmUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/ClusteringAlgorithmUtil.java index 8fead310..482eb40a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/ClusteringAlgorithmUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/ClusteringAlgorithmUtil.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDs; * Utility functionality for writing clustering algorithms. * * @author Erich Schubert + * @since 0.7.0 */ public class ClusteringAlgorithmUtil { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/DBSCAN.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/DBSCAN.java index 7d802fa4..ba6cf77d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/DBSCAN.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/DBSCAN.java @@ -34,12 +34,13 @@ import de.lmu.ifi.dbs.elki.data.model.Model; import de.lmu.ifi.dbs.elki.data.type.TypeInformation; import de.lmu.ifi.dbs.elki.data.type.TypeUtil; import de.lmu.ifi.dbs.elki.database.QueryUtil; +import de.lmu.ifi.dbs.elki.database.ids.ArrayModifiableDBIDs; 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.DBIDVar; import de.lmu.ifi.dbs.elki.database.ids.DoubleDBIDList; -import de.lmu.ifi.dbs.elki.database.ids.HashSetModifiableDBIDs; +import de.lmu.ifi.dbs.elki.database.ids.DoubleDBIDListIter; import de.lmu.ifi.dbs.elki.database.ids.ModifiableDBIDs; import de.lmu.ifi.dbs.elki.database.query.range.RangeQuery; import de.lmu.ifi.dbs.elki.database.relation.Relation; @@ -70,6 +71,8 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Arthur Zimek + * @author Erich Schubert + * @since 0.2 * @param <O> the type of Object the algorithm is applied to */ @Title("DBSCAN: Density-Based Clustering of Applications with Noise") @@ -172,9 +175,10 @@ public class DBSCAN<O> extends AbstractDistanceBasedAlgorithm<O, Clustering<Mode IndefiniteProgress clusprog = LOG.isVerbose() ? new IndefiniteProgress("Number of clusters", LOG) : null; processedIDs = DBIDUtil.newHashSet(size); + ArrayModifiableDBIDs seeds = DBIDUtil.newArray(); for(DBIDIter iditer = relation.iterDBIDs(); iditer.valid(); iditer.advance()) { if(!processedIDs.contains(iditer)) { - expandCluster(relation, rangeQuery, iditer, objprog, clusprog); + expandCluster(relation, rangeQuery, iditer, seeds, objprog, clusprog); } if(objprog != null && clusprog != null) { objprog.setProcessed(processedIDs.size(), LOG); @@ -197,9 +201,11 @@ public class DBSCAN<O> extends AbstractDistanceBasedAlgorithm<O, Clustering<Mode * @param relation Database relation to run on * @param rangeQuery Range query to use * @param startObjectID potential seed of a new potential cluster - * @param objprog the progress object for logging the current status + * @param seeds Array to store the current seeds + * @param objprog Number of objects processed (may be {@code null}) + * @param clusprog Number of clusters found (may be {@code null}) */ - protected void expandCluster(Relation<O> relation, RangeQuery<O> rangeQuery, DBIDRef startObjectID, FiniteProgress objprog, IndefiniteProgress clusprog) { + protected void expandCluster(Relation<O> relation, RangeQuery<O> rangeQuery, DBIDRef startObjectID, ArrayModifiableDBIDs seeds, FiniteProgress objprog, IndefiniteProgress clusprog) { DoubleDBIDList neighbors = rangeQuery.getRangeForDBID(startObjectID, epsilon); ncounter += neighbors.size(); @@ -218,13 +224,13 @@ public class DBSCAN<O> extends AbstractDistanceBasedAlgorithm<O, Clustering<Mode processedIDs.add(startObjectID); // try to expand the cluster - HashSetModifiableDBIDs seeds = DBIDUtil.newHashSet(); + assert(seeds.size() == 0); + seeds.clear(); processNeighbors(neighbors.iter(), currentCluster, seeds); DBIDVar o = DBIDUtil.newVar(); while(!seeds.isEmpty()) { - seeds.pop(o); - neighbors = rangeQuery.getRangeForDBID(o, epsilon); + neighbors = rangeQuery.getRangeForDBID(seeds.pop(o), epsilon); ncounter += neighbors.size(); if(neighbors.size() >= minpts) { @@ -248,10 +254,13 @@ public class DBSCAN<O> extends AbstractDistanceBasedAlgorithm<O, Clustering<Mode * @param currentCluster Current cluster * @param seeds Seed set */ - private void processNeighbors(DBIDIter neighbor, ModifiableDBIDs currentCluster, HashSetModifiableDBIDs seeds) { + private void processNeighbors(DoubleDBIDListIter neighbor, ModifiableDBIDs currentCluster, ArrayModifiableDBIDs seeds) { + final boolean ismetric = getDistanceFunction().isMetric(); for(; neighbor.valid(); neighbor.advance()) { if(processedIDs.add(neighbor)) { - seeds.add(neighbor); + if(!ismetric || neighbor.doubleValue() > 0.) { + seeds.add(neighbor); + } } else if(!noise.remove(neighbor)) { continue; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/GriDBSCAN.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/GriDBSCAN.java new file mode 100644 index 00000000..aecb7c30 --- /dev/null +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/GriDBSCAN.java @@ -0,0 +1,913 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2016 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import java.util.Arrays; + +import de.lmu.ifi.dbs.elki.algorithm.AbstractDistanceBasedAlgorithm; +import de.lmu.ifi.dbs.elki.data.Cluster; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.NumberVector; +import de.lmu.ifi.dbs.elki.data.model.ClusterModel; +import de.lmu.ifi.dbs.elki.data.model.Model; +import de.lmu.ifi.dbs.elki.data.type.CombinedTypeInformation; +import de.lmu.ifi.dbs.elki.data.type.TypeInformation; +import de.lmu.ifi.dbs.elki.data.type.TypeUtil; +import de.lmu.ifi.dbs.elki.database.datastore.DataStoreFactory; +import de.lmu.ifi.dbs.elki.database.datastore.DataStoreUtil; +import de.lmu.ifi.dbs.elki.database.datastore.WritableDataStore; +import de.lmu.ifi.dbs.elki.database.datastore.WritableIntegerDataStore; +import de.lmu.ifi.dbs.elki.database.ids.ArrayModifiableDBIDs; +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.DBIDVar; +import de.lmu.ifi.dbs.elki.database.ids.DBIDs; +import de.lmu.ifi.dbs.elki.database.ids.DoubleDBIDList; +import de.lmu.ifi.dbs.elki.database.ids.DoubleDBIDListIter; +import de.lmu.ifi.dbs.elki.database.ids.ModifiableDBIDs; +import de.lmu.ifi.dbs.elki.database.ids.ModifiableDoubleDBIDList; +import de.lmu.ifi.dbs.elki.database.query.range.RangeQuery; +import de.lmu.ifi.dbs.elki.database.relation.ProxyView; +import de.lmu.ifi.dbs.elki.database.relation.Relation; +import de.lmu.ifi.dbs.elki.database.relation.RelationUtil; +import de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction; +import de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction; +import de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.LPNormDistanceFunction; +import de.lmu.ifi.dbs.elki.logging.Logging; +import de.lmu.ifi.dbs.elki.logging.progress.FiniteProgress; +import de.lmu.ifi.dbs.elki.logging.statistics.DoubleStatistic; +import de.lmu.ifi.dbs.elki.logging.statistics.LongStatistic; +import de.lmu.ifi.dbs.elki.logging.statistics.StringStatistic; +import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; +import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.constraints.CommonConstraints; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.constraints.GreaterEqualConstraint; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; +import gnu.trove.iterator.TLongObjectIterator; +import gnu.trove.map.hash.TLongObjectHashMap; + +/** + * Using Grid for Accelerating Density-Based Clustering. + * + * An accelerated DBSCAN version for numerical data and Lp-norms only, by + * partitioning the data set into overlapping grid cells. For best efficiency, + * the overlap of the grid cells must be chosen well. The authors suggest a grid + * width of 10 times epsilon. + * + * Because of partitioning the data, this version does not make use of indexes. + * + * Reference: + * <p> + * S. Mahran and K. Mahar: <br /> + * Using grid for accelerating density-based clustering.<br /> + * In 8th IEEE Int. Conf. on Computer and Information Technology, 2008. + * </p> + * + * @author Erich Schubert + * @since 0.7.1 + * + * @apiviz.composedOf Instance + * + * @param <V> the type of vector the algorithm is applied to + */ +@Reference(authors = "S. Mahran and K. Mahar", // +title = "Using grid for accelerating density-based clustering", // +booktitle = "8th IEEE Int. Conf. on Computer and Information Technology", // +url = "http://dx.doi.org/10.1109/CIT.2008.4594646") +public class GriDBSCAN<V extends NumberVector> extends AbstractDistanceBasedAlgorithm<V, Clustering<Model>> implements ClusteringAlgorithm<Clustering<Model>> { + /** + * The logger for this class. + */ + private static final Logging LOG = Logging.getLogger(GriDBSCAN.class); + + /** + * Holds the epsilon radius threshold. + */ + protected double epsilon; + + /** + * Holds the minimum cluster size. + */ + protected int minpts; + + /** + * Width of the grid cells. Must be at least 2 epsilon! + */ + protected double gridwidth; + + /** + * Constructor with parameters. + * + * @param distanceFunction Distance function + * @param epsilon Epsilon value + * @param minpts Minpts parameter + * @param gridwidth Grid width + */ + public GriDBSCAN(DistanceFunction<? super V> distanceFunction, double epsilon, int minpts, double gridwidth) { + super(distanceFunction); + this.epsilon = epsilon; + this.minpts = minpts; + this.gridwidth = gridwidth; + } + + /** + * Performs the DBSCAN algorithm on the given database. + */ + public Clustering<Model> run(Relation<V> relation) { + final DBIDs ids = relation.getDBIDs(); + + // Degenerate result: + if(ids.size() < minpts) { + Clustering<Model> result = new Clustering<>("DBSCAN Clustering", "dbscan-clustering"); + result.addToplevelCluster(new Cluster<Model>(ids, true, ClusterModel.CLUSTER)); + return result; + } + + double gridwidth = this.gridwidth; // local copy. + if(gridwidth < 2. * epsilon) { + LOG.warning("Invalid grid width (less than 2*epsilon, recommended 10*epsilon). Increasing grid width automatically."); + gridwidth = 2. * epsilon; + } + return new Instance<V>(getDistanceFunction(), epsilon, minpts, gridwidth).run(relation); + } + + /** + * Instance, for a single run. + * + * @author Erich Schubert + * + * @param <V> Vector type + */ + protected static class Instance<V extends NumberVector> { + /** + * Unprocessed IDs. + */ + protected static final int UNPROCESSED = 0; + + /** + * Noise IDs. + */ + protected static final int NOISE = 1; + + /** + * Distance function used. + */ + protected DistanceFunction<? super V> distanceFunction; + + /** + * Holds the epsilon radius threshold. + */ + protected double epsilon; + + /** + * Holds the minimum cluster size. + */ + protected int minpts; + + /** + * Width of the grid cells. Must be at least 2 epsilon! + */ + protected double gridwidth; + + /** + * Value domain. + */ + protected double[][] domain; + + /** + * Dimensionality. + */ + protected int dim; + + /** + * Grid offset. + */ + protected double[] offset; + + /** + * Number of cells per dimension. + */ + protected int[] cells; + + /** + * Data grid partitioning. + */ + TLongObjectHashMap<ModifiableDBIDs> grid; + + /** + * Core identifier objects (shared to conserve memory). + */ + private Core[] cores; + + /** + * Border identifier objects (shared to conserve memory). + */ + private Border[] borders; + + /** + * Cluster assignments. + */ + private WritableDataStore<Assignment> clusterids; + + /** + * Temporary assignments of a single run. + */ + private WritableIntegerDataStore temporary; + + /** + * Indicates that the number of grid cells has overflown. + */ + private boolean overflown; + + /** + * Constructor. + * + * @param distanceFunction Distance function + * @param epsilon Epsilon + * @param minpts MinPts + * @param gridwidth Grid width + */ + public Instance(DistanceFunction<? super V> distanceFunction, double epsilon, int minpts, double gridwidth) { + this.distanceFunction = distanceFunction; + this.epsilon = epsilon; + this.minpts = minpts; + this.gridwidth = gridwidth; + } + + /** + * Performs the DBSCAN algorithm on the given database. + * + * @param relation Relation to process + */ + public Clustering<Model> run(Relation<V> relation) { + final DBIDs ids = relation.getDBIDs(); + final int size = ids.size(); + + // Domain of the database + this.domain = RelationUtil.computeMinMax(relation); + this.dim = domain[0].length; + this.offset = new double[dim]; + this.cells = new int[dim]; + // Compute the grid start, and the number of cells in each dimension. + long numcells = computeGridBaseOffsets(); + if(numcells > size) { + LOG.warning("The generated grid has more cells than data points. This may need excessive amounts of memory."); + } + else if(numcells == 1) { + LOG.warning("All data is in a single cell. This has degenerated to a non-indexed DBSCAN!"); + } + else if(numcells <= dim * dim) { + LOG.warning("There are only " + numcells + " cells. This will likely be slower than regular DBSCAN!"); + } + + // Build the data grid. + buildGrid(relation, (int) numcells, offset); + if(grid.size() <= dim) { + LOG.warning("There are only " + grid.size() + " occupied cells. This will likely be slower than regular DBSCAN!"); + } + + // Check grid cell counts: + int mincells = checkGridCellSizes(size, numcells); + + // (Temporary) store the cluster ID assigned. + clusterids = DataStoreUtil.makeStorage(ids, DataStoreFactory.HINT_TEMP, Assignment.class); + temporary = DataStoreUtil.makeIntegerStorage(ids, DataStoreFactory.HINT_TEMP, UNPROCESSED); + final ArrayModifiableDBIDs activeSet = DBIDUtil.newArray(); + // Reserve the first two cluster ids: + int clusterid = NOISE + 1; + this.cores = new Core[2]; + this.borders = new Border[2]; + + // Reused storage for neighbors: + ModifiableDoubleDBIDList neighbors = DBIDUtil.newDistanceDBIDList(minpts << 1); + // Run DBSCAN on each cell that has enough objects. + FiniteProgress cprog = LOG.isVerbose() ? new FiniteProgress("Processing grid cells", mincells, LOG) : null; + for(TLongObjectIterator<ModifiableDBIDs> it = grid.iterator(); it.hasNext();) { + it.advance(); + ModifiableDBIDs cellids = it.value(); + if(cellids.size() < minpts) { + continue; // Too few objects. + } + temporary.clear(); // Reset to "UNPROCESSED" + ProxyView<V> rel = new ProxyView<>(cellids, relation); + RangeQuery<V> rq = rel.getRangeQuery(distanceFunction, epsilon); + FiniteProgress pprog = LOG.isVerbose() ? new FiniteProgress("Running DBSCAN", cellids.size(), LOG) : null; + for(DBIDIter id = cellids.iter(); id.valid(); id.advance()) { + // Skip already processed ids. + if(temporary.intValue(id) != UNPROCESSED) { + continue; + } + neighbors.clear(); + rq.getRangeForDBID(id, epsilon, neighbors); + if(neighbors.size() >= minpts) { + expandCluster(id, clusterid, temporary, neighbors, activeSet, rq, pprog); + ++clusterid; + } + else { + temporary.putInt(id, NOISE); + LOG.incrementProcessed(pprog); + } + } + LOG.ensureCompleted(pprog); + // Post-process DBSCAN clustering result: + updateCoreBorderObjects(clusterid); + mergeClusterInformation(cellids, temporary, clusterids); + LOG.incrementProcessed(cprog); + } + LOG.ensureCompleted(cprog); + temporary.destroy(); + + FiniteProgress pprog = LOG.isVerbose() ? new FiniteProgress("Building final result", size, LOG) : null; + ModifiableDBIDs[] clusters = new ModifiableDBIDs[clusterid]; + ModifiableDBIDs noise = DBIDUtil.newArray(); + for(DBIDIter it = ids.iter(); it.valid(); it.advance()) { + Assignment cids = clusterids.get(it); + if(cids == null) { + noise.add(it); + } + else { + if(cids instanceof MultiBorder) { + cids = ((MultiBorder) cids).getCore(); + } + else if(cids instanceof Border) { + cids = ((Border) cids).core; + } + assert (cids instanceof Core); + Core co = (Core) cids; + while(cores[co.parent].parent != co.parent) { + co = cores[co.parent = cores[co.parent].parent]; + } + ModifiableDBIDs clu = clusters[co.parent]; + if(clu == null) { + clu = clusters[co.parent] = DBIDUtil.newArray(); + } + clu.add(it); + } + LOG.incrementProcessed(pprog); + } + LOG.ensureCompleted(pprog); + clusterids.destroy(); + + Clustering<Model> result = new Clustering<>("DBSCAN Clustering", "dbscan-clustering"); + for(int i = NOISE + 1; i < clusters.length; i++) { + if(clusters[i] != null) { + result.addToplevelCluster(new Cluster<Model>(clusters[i], ClusterModel.CLUSTER)); + } + } + if(noise.size() > 0) { + result.addToplevelCluster(new Cluster<Model>(noise, true, ClusterModel.CLUSTER)); + } + return result; + } + + /** + * Update the shared arrays for core points (to conserve memory) + * + * @param clusterid Number of clusters + */ + private void updateCoreBorderObjects(int clusterid) { + int i = cores.length; + cores = Arrays.copyOf(cores, clusterid); + borders = Arrays.copyOf(borders, clusterid); + while(i < clusterid) { + cores[i] = new Core(i); + borders[i] = new Border(cores[i]); + ++i; + } + } + + /** + * Compute the grid base offset. + * + * @return Total number of grid cells + */ + private long computeGridBaseOffsets() { + StringBuffer buf = LOG.isDebuggingFinest() ? new StringBuffer() : null; + double[] min = domain[0], max = domain[1]; + long total = 1; + for(int d = 0; d < dim; d++) { + final double mi = min[d], ma = max[d], wi = ma - mi; + if(mi == Double.NEGATIVE_INFINITY || ma == Double.POSITIVE_INFINITY || mi != mi || ma != ma) { + throw new AbortException("Dimension " + d + " contains non-finite values."); + } + int c = cells[d] = Math.max(1, (int) Math.ceil(wi / gridwidth)); + offset[d] = mi - (c * gridwidth - wi) * .5; + assert (offset[d] <= mi) : "Grid inconsistent."; + assert (offset[d] + c * gridwidth >= ma) : "Grid inconsistent."; + total *= c; + if(total < 0) { + LOG.warning("Excessive amount of grid cells (long overflow)! Use larger grid cells."); + if (total < 0) { + overflown = true; + total &= 0x7FFF_FFFF_FFFF_FFFFL; + } + } + if(buf != null) { + buf.append(d).append(": min=").append(mi).append(" max=").append(ma); + double s = offset[d]; + for(int i = 0; i <= c; i++) { + buf.append(' ').append(s); + s += gridwidth; + } + buf.append('\n'); + } + } + if(buf != null) { + LOG.debugFinest(buf); + } + return total; + } + + /** + * Build the data grid. + * + * @param relation Data relation + * @param numcells Total number of cells + * @param offset Offset + */ + protected void buildGrid(Relation<V> relation, int numcells, double[] offset) { + grid = new TLongObjectHashMap<ModifiableDBIDs>(numcells >>> 2); + for(DBIDIter it = relation.iterDBIDs(); it.valid(); it.advance()) { + V obj = relation.get(it); + insertIntoGrid(it, obj, 0, 0); + } + } + + /** + * Insert a single object into the grid; potentially into multiple cells (at + * most 2^d) via recursion. + * + * @param id Object ID + * @param obj Object + * @param d Current dimension + * @param v Current cell value + */ + private void insertIntoGrid(DBIDRef id, V obj, int d, int v) { + final int cn = cells[d]; // Number of cells in this dimension + final int nd = d + 1; // Next dimension + int mi = Math.max(0, (int) Math.floor((obj.doubleValue(d) - offset[d] - epsilon) / gridwidth)); + int ma = Math.min(cn - 1, (int) Math.floor((obj.doubleValue(d) - offset[d] + epsilon) / gridwidth)); + assert (mi <= ma) : "Grid inconsistent."; + for(int i = mi; i <= ma; i++) { + int c = v * cn + i; + if(nd == cells.length) { + ModifiableDBIDs ids = grid.get(c); + if(ids == null) { + grid.put(c, ids = DBIDUtil.newArray()); + } + ids.add(id); + } + else { + insertIntoGrid(id, obj, nd, c); + } + } + } + + /** + * Perform some sanity checks on the grid cells. + * + * @param numcell Number of cells + * @param size Relation size + * @return Number of cells with minPts points + */ + protected int checkGridCellSizes(int size, long numcell) { + int tcount = 0; + int hasmin = 0; + double sqcount = 0; + for(TLongObjectIterator<ModifiableDBIDs> it = grid.iterator(); it.hasNext();) { + it.advance(); + final int s = it.value().size(); + if(s >= size >> 1) { + LOG.warning("A single cell contains half of the database (" + s// + + " objects). This will not scale very well."); + } + tcount += s; + sqcount += s * (long) s; + if(s >= minpts) { + hasmin++; + } + } + double savings = sqcount / size / size; + if(savings >= 1) { + LOG.warning("Pairwise distances within each cells are more expensive than a full DBSCAN run due to overlap!"); + } + if (overflown) { + LOG.statistics(new StringStatistic(GriDBSCAN.class.getName() + ".all-cells", "overflow")); + } else { + LOG.statistics(new LongStatistic(GriDBSCAN.class.getName() + ".all-cells", numcell)); + } + LOG.statistics(new LongStatistic(GriDBSCAN.class.getName() + ".used-cells", grid.size())); + LOG.statistics(new LongStatistic(GriDBSCAN.class.getName() + ".minpts-cells", hasmin)); + LOG.statistics(new DoubleStatistic(GriDBSCAN.class.getName() + ".redundancy", tcount / (double) size)); + LOG.statistics(new DoubleStatistic(GriDBSCAN.class.getName() + ".relative-cost", savings)); + return hasmin; + } + + /** + * Set-based expand cluster implementation. + * + * @param clusterid ID of the current cluster. + * @param clusterids Current object to cluster mapping. + * @param neighbors Neighbors acquired by initial getNeighbors call. + * @param activeSet Set to manage active candidates. + * @param rq Range query + * @param pprog Object progress + * @return cluster size + */ + protected int expandCluster(final DBIDRef seed, final int clusterid, final WritableIntegerDataStore clusterids, final ModifiableDoubleDBIDList neighbors, ArrayModifiableDBIDs activeSet, RangeQuery<V> rq, FiniteProgress pprog) { + assert (activeSet.size() == 0); + int clustersize = 1 + processCorePoint(seed, neighbors, clusterid, clusterids, activeSet); + LOG.incrementProcessed(pprog); + // run expandCluster as long as there is another seed + final DBIDVar id = DBIDUtil.newVar(); + while(!activeSet.isEmpty()) { + activeSet.pop(id); + neighbors.clear(); + // Evaluate Neighborhood predicate + rq.getRangeForDBID(id, epsilon, neighbors); + // Evaluate Core-Point predicate + if(neighbors.size() >= minpts) { + clustersize += processCorePoint(id, neighbors, clusterid, clusterids, activeSet); + } + LOG.incrementProcessed(pprog); + } + return clustersize; + } + + /** + * Process a single core point. + * + * @param seed Point to process + * @param newneighbors New neighbors + * @param clusterid Cluster to add to + * @param clusterids Cluster assignment storage. + * @param activeSet Active set of cluster seeds + * @return Number of new points added to cluster + */ + protected int processCorePoint(final DBIDRef seed, DoubleDBIDList newneighbors, final int clusterid, final WritableIntegerDataStore clusterids, ArrayModifiableDBIDs activeSet) { + clusterids.putInt(seed, clusterid); // Core point now + int clustersize = 0; + // The recursion is unrolled into iteration over the active set. + for(DoubleDBIDListIter it = newneighbors.iter(); it.valid(); it.advance()) { + final int oldassign = clusterids.intValue(it); + if(oldassign == UNPROCESSED) { + if(it.doubleValue() > 0.) { // We can skip points at distance 0. + activeSet.add(it); + } + } + else if(oldassign != NOISE) { + continue; // Member of some cluster. + } + clustersize++; + clusterids.putInt(it, -clusterid); + } + return clustersize; + } + + /** + * Merge cluster information. + * + * @param cellids IDs in current cell + * @param temporary Temporary assignments + * @param clusterids Merged cluster assignment + */ + protected void mergeClusterInformation(ModifiableDBIDs cellids, WritableIntegerDataStore temporary, WritableDataStore<Assignment> clusterids) { + FiniteProgress mprog = LOG.isVerbose() ? new FiniteProgress("Collecting result", cellids.size(), LOG) : null; + for(DBIDIter id = cellids.iter(); id.valid(); id.advance()) { + int nclus = temporary.intValue(id); + if(nclus > NOISE) { // Core point + Core core = cores[nclus]; + assert (core.parent > NOISE); + Assignment oclus = clusterids.get(id); + if(oclus == null) { // No assignment yet (= NOISE) + clusterids.put(id, core); + } + else if(oclus instanceof Core) { // Core and core - merge! + core.mergeWith((Core) oclus); + } + else if(oclus instanceof Border) { // Core and border point, merge! + core.mergeWith(((Border) oclus).core); + clusterids.put(id, core); + } + else { // Point is border for multiple clusters + assert (oclus instanceof MultiBorder); + if(LOG.isDebuggingFinest()) { + LOG.debugFinest("Multi-Merge: " + nclus + " - " + oclus + " -> " + core); + } + // Find minimum: + int m = core.parent, m2 = ((MultiBorder) oclus).getCore().parent; + m = m < m2 ? m : m2; + assert (m > NOISE); + // Execute all merges: + for(Border b : ((MultiBorder) oclus).cs) { + cores[b.core.parent].parent = m; + } + core.parent = m; + clusterids.put(id, core); + } + } + else if(nclus < 0) { // Border point + Border border = borders[-nclus]; + Assignment oclus = clusterids.get(id); + if(oclus == null) { // No assignment yet. + clusterids.put(id, border); + } + else if(oclus instanceof Core) { // Border and core point - merge + ((Core) oclus).mergeWith(border.core); + } + else if(oclus instanceof Border) { // Border and border + if(((Border) oclus).core.parent != border.core.parent) { + clusterids.put(id, new MultiBorder((Border) oclus, border)); + } + } + else { + assert (oclus instanceof MultiBorder); + clusterids.put(id, ((MultiBorder) oclus).update(border)); + } + } + else { + assert (nclus == NOISE); // Ignore noise. + } + LOG.incrementProcessed(mprog); + } + LOG.ensureCompleted(mprog); + } + } + + /** + * Point assignment. + * + * @author Erich Schubert + * + * @apiviz.exclude + */ + protected static interface Assignment { + // Empty + } + + /** + * Core point assignment. + * + * @author Erich Schubert + * + * @apiviz.exclude + */ + protected static class Core implements Assignment { + /** + * Cluster number + */ + protected int parent; + + /** + * Constructor. + * + * @param parent Cluster number + */ + protected Core(int parent) { + assert (parent > GriDBSCAN.Instance.NOISE); + this.parent = parent; + } + + /** + * Merge two cores. + * + * @param o Other core + */ + public void mergeWith(Core o) { + o.parent = this.parent = (parent < o.parent ? parent : o.parent); + } + + @Override + public String toString() { + return "Core[" + parent + "]"; + } + } + + /** + * Border point assignment. + * + * @author Erich Schubert + * + * @apiviz.exclude + */ + protected static class Border implements Assignment, Comparable<Border> { + /** + * Cluster number + */ + protected Core core; + + /** + * Constructor. + * + * @param core Cluster number + */ + protected Border(Core core) { + this.core = core; + } + + @Override + public String toString() { + return "Border[" + core.parent + "]"; + } + + @Override + public int compareTo(Border o) { + return Integer.compare(o.core.parent, this.core.parent); + } + } + + /** + * Multiple border point assignment. + * + * @author Erich Schubert + * + * @apiviz.exclude + */ + protected static class MultiBorder implements Assignment { + /** + * Cluster numbers + */ + protected Border[] cs; + + /** + * Constructor. + * + * @param i First cluster border + * @param j Second cluster border + */ + protected MultiBorder(Border i, Border j) { + assert (i.core != j.core); + this.cs = new Border[] { i, j }; + } + + /** + * Add a new border to the existing borders. + * + * @param border New border. + */ + public Assignment update(Border border) { + Arrays.sort(cs); + int j = 1; + boolean found = (cs[0].core == border.core); + for(int i = 1; i < cs.length; i++) { + if(cs[i].core != cs[i - 1].core) { + cs[j++] = cs[i]; + } + found |= (cs[i].core == border.core); + } + if(found) { + if(j == 1) { + Border r = cs[0]; + cs = null; // Prevent further use + return r; + } + if(j < cs.length) { + cs = Arrays.copyOf(cs, j); + } + return this; + } + if(j + 1 != cs.length) { + cs = Arrays.copyOf(cs, j + 1); + } + cs[j] = border; + return this; + } + + /** + * Get the core this is assigned to. + * + * @return Core + */ + public Core getCore() { + Core a = cs[0].core; + for(int i = 1; i < cs.length; i++) { + Core v = cs[i].core; + a = a.parent > v.parent ? a : v; // max, of negative values + } + assert (a.parent > GriDBSCAN.Instance.NOISE); + return a; + } + + @Override + public String toString() { + StringBuilder buf = new StringBuilder(); + buf.append("MultiBorder["); + for(Border b : cs) { + buf.append(b.core.parent).append(','); + } + buf.append(']'); + return buf.toString(); + } + } + + @Override + public TypeInformation[] getInputTypeRestriction() { + // We strictly need a vector field of fixed dimensionality! + TypeInformation type = new CombinedTypeInformation(TypeUtil.NUMBER_VECTOR_FIELD, getDistanceFunction().getInputTypeRestriction()); + return TypeUtil.array(type); + } + + @Override + protected Logging getLogger() { + return LOG; + } + + /** + * Parameterization class. + * + * @author Erich Schubert + * + * @apiviz.exclude + * + * @param <O> Vector type to use + */ + public static class Parameterizer<O extends NumberVector> extends AbstractDistanceBasedAlgorithm.Parameterizer<O> { + /** + * Parameter to control the grid width. + * + * Must be at least two times epsilon. + */ + public static final OptionID GRID_ID = new OptionID("gridbscan.gridwidth", "Width of the grid used, must be at least two times epsilon."); + + /** + * Holds the epsilon radius threshold. + */ + protected double epsilon; + + /** + * Holds the minimum cluster size. + */ + protected int minpts; + + /** + * Width of the grid cells. Must be at least 2 epsilon! + */ + protected double gridwidth; + + @Override + protected void makeOptions(Parameterization config) { + // Disabled: super.makeOptions(config); + // Because we currently only allow Lp norms: + ObjectParameter<DistanceFunction<? super O>> distanceFunctionP = makeParameterDistanceFunction(EuclideanDistanceFunction.class, LPNormDistanceFunction.class); + if(config.grab(distanceFunctionP)) { + distanceFunction = distanceFunctionP.instantiateClass(config); + } + + DoubleParameter epsilonP = new DoubleParameter(DBSCAN.Parameterizer.EPSILON_ID) // + .addConstraint(CommonConstraints.GREATER_THAN_ZERO_DOUBLE); + if(config.grab(epsilonP)) { + epsilon = epsilonP.getValue(); + } + + IntParameter minptsP = new IntParameter(DBSCAN.Parameterizer.MINPTS_ID) // + .addConstraint(CommonConstraints.GREATER_EQUAL_ONE_INT); + if(config.grab(minptsP)) { + minpts = minptsP.getValue(); + if(minpts <= 2) { + LOG.warning("DBSCAN with minPts <= 2 is equivalent to single-link clustering at a single height. Consider using larger values of minPts."); + } + } + + DoubleParameter gridP = new DoubleParameter(GRID_ID) // + .addConstraint(CommonConstraints.GREATER_THAN_ZERO_DOUBLE); + if(epsilon > 0.) { + gridP.setDefaultValue(10. * epsilon); + gridP.addConstraint(new GreaterEqualConstraint(1. * epsilon)); + } + if(config.grab(gridP)) { + gridwidth = gridP.doubleValue(); + } + } + + @Override + protected GriDBSCAN<O> makeInstance() { + return new GriDBSCAN<>(distanceFunction, epsilon, minpts, gridwidth); + } + } +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/NaiveMeanShiftClustering.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/NaiveMeanShiftClustering.java index 0d1e9fe2..b6b43047 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/NaiveMeanShiftClustering.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/NaiveMeanShiftClustering.java @@ -77,6 +77,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; * </p> * * @author Erich Schubert + * @since 0.5.5 * * @param <V> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/SNNClustering.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/SNNClustering.java index 2cc48637..39da3e7f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/SNNClustering.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/SNNClustering.java @@ -68,6 +68,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Arthur Zimek + * @since 0.2 * * @apiviz.uses SharedNearestNeighborSimilarityFunction * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/affinitypropagation/AffinityPropagationClusteringAlgorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/affinitypropagation/AffinityPropagationClusteringAlgorithm.java index a1ef9768..0216d475 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/affinitypropagation/AffinityPropagationClusteringAlgorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/affinitypropagation/AffinityPropagationClusteringAlgorithm.java @@ -62,6 +62,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.composedOf AffinityPropagationInitialization * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/affinitypropagation/AffinityPropagationInitialization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/affinitypropagation/AffinityPropagationInitialization.java index 5532f8c8..891b8a3e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/affinitypropagation/AffinityPropagationInitialization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/affinitypropagation/AffinityPropagationInitialization.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; * Initialization methods for affinity propagation. * * @author Erich Schubert + * @since 0.6.0 */ public interface AffinityPropagationInitialization<O> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/affinitypropagation/DistanceBasedInitializationWithMedian.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/affinitypropagation/DistanceBasedInitializationWithMedian.java index 1bdff0c3..e514df53 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/affinitypropagation/DistanceBasedInitializationWithMedian.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/affinitypropagation/DistanceBasedInitializationWithMedian.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Distance based initialization. * * @author Erich Schubert + * @since 0.6.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/affinitypropagation/SimilarityBasedInitializationWithMedian.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/affinitypropagation/SimilarityBasedInitializationWithMedian.java index d8abe9c1..3086d4fb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/affinitypropagation/SimilarityBasedInitializationWithMedian.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/affinitypropagation/SimilarityBasedInitializationWithMedian.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Similarity based initialization. * * @author Erich Schubert + * @since 0.6.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/biclustering/AbstractBiclustering.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/biclustering/AbstractBiclustering.java index 2a0896ea..9d1b2f91 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/biclustering/AbstractBiclustering.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/biclustering/AbstractBiclustering.java @@ -53,6 +53,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.ExceptionMessages; * of the {@link NumberVector}s. * * @author Arthur Zimek + * @since 0.2 * @param <V> a certain subtype of NumberVector - the data matrix is supposed to * consist of rows where each row relates to an object of type V and the * columns relate to the attribute values of these objects diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/biclustering/ChengAndChurch.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/biclustering/ChengAndChurch.java index ceb13976..cf957fc0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/biclustering/ChengAndChurch.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/biclustering/ChengAndChurch.java @@ -61,6 +61,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Erich Schubert + * @since 0.2 * @param <V> Vector type. */ @Reference(authors = "Y. Cheng, G. M. Church", title = "Biclustering of expression data", booktitle = "Proc. 8th International Conference on Intelligent Systems for Molecular Biology (ISMB)") diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/CASH.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/CASH.java index 43c0528d..1db2d79f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/CASH.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/CASH.java @@ -4,7 +4,7 @@ package de.lmu.ifi.dbs.elki.algorithm.clustering.correlation; This file is part of ELKI: Environment for Developing KDD-Applications Supported by Index-Structures - Copyright (C) 2015 + Copyright (C) 2016 Ludwig-Maximilians-Universität München Lehr- und Forschungseinheit für Datenbanksysteme ELKI Development Team @@ -95,6 +95,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Elke Achtert + * @since 0.2 * * @apiviz.has CASHInterval * @apiviz.has ParameterizationFunction @@ -109,84 +110,36 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; title = "Robust clustering in arbitraily oriented subspaces", // booktitle = "Proc. 8th SIAM Int. Conf. on Data Mining (SDM'08), Atlanta, GA, 2008", // url = "http://www.siam.org/proceedings/datamining/2008/dm08_69_AchtertBoehmDavidKroegerZimek.pdf") -public class CASH<V extends NumberVector> extends AbstractAlgorithm<Clustering<Model>>implements ClusteringAlgorithm<Clustering<Model>> { +public class CASH<V extends NumberVector> extends AbstractAlgorithm<Clustering<Model>> implements ClusteringAlgorithm<Clustering<Model>> { /** * The logger for this class. */ private static final Logging LOG = Logging.getLogger(CASH.class); /** - * Parameter to specify the threshold for minimum number of points in a - * cluster, must be an integer greater than 0. - * <p> - * Key: {@code -cash.minpts} - * </p> + * Threshold for minimum number of points in a cluster */ - public static final OptionID MINPTS_ID = new OptionID("cash.minpts", "Threshold for minimum number of points in a cluster."); + protected int minPts; /** - * Parameter to specify the maximum level for splitting the hypercube, must be - * an integer greater than 0. - * <p> - * Key: {@code -cash.maxlevel} - * </p> + * Maximum level for splitting the hypercube. */ - public static final OptionID MAXLEVEL_ID = new OptionID("cash.maxlevel", "The maximum level for splitting the hypercube."); + protected int maxLevel; /** - * Parameter to specify the minimum dimensionality of the subspaces to be - * found, must be an integer greater than 0. - * <p> - * Default value: {@code 1} - * </p> - * <p> - * Key: {@code -cash.mindim} - * </p> + * Minimum dimensionality of the subspaces to be found */ - public static final OptionID MINDIM_ID = new OptionID("cash.mindim", "The minimum dimensionality of the subspaces to be found."); + protected int minDim; /** - * Parameter to specify the maximum jitter for distance values, must be a - * double greater than 0. - * <p> - * Key: {@code -cash.jitter} - * </p> + * Maximum jitter for distance values. */ - public static final OptionID JITTER_ID = new OptionID("cash.jitter", "The maximum jitter for distance values."); + protected double jitter; /** - * Flag to indicate that an adjustment of the applied heuristic for choosing - * an interval is performed after an interval is selected. - * <p> - * Key: {@code -cash.adjust} - * </p> + * Apply adjustment heuristic for interval choosing. */ - public static final OptionID ADJUST_ID = new OptionID("cash.adjust", "Flag to indicate that an adjustment of the applied heuristic for choosing an interval " + "is performed after an interval is selected."); - - /** - * Holds the value of {@link #MINPTS_ID}. - */ - private int minPts; - - /** - * Holds the value of {@link #MAXLEVEL_ID}. - */ - private int maxLevel; - - /** - * Holds the value of {@link #MINDIM_ID}. - */ - private int minDim; - - /** - * Holds the value of {@link #JITTER_ID}. - */ - private double jitter; - - /** - * Holds the value of {@link #ADJUST_ID}. - */ - private boolean adjust; + protected boolean adjust; /** * Holds the dimensionality for noise. @@ -711,7 +664,7 @@ public class CASH<V extends NumberVector> extends AbstractAlgorithm<Clustering<M // set the parameters ListParameterization parameters = new ListParameterization(); parameters.addParameter(PCAFilteredRunner.Parameterizer.PCA_EIGENPAIR_FILTER, FirstNEigenPairFilter.class.getName()); - parameters.addParameter(FirstNEigenPairFilter.EIGENPAIR_FILTER_N, Integer.toString(dim - 1)); + parameters.addParameter(FirstNEigenPairFilter.Parameterizer.EIGENPAIR_FILTER_N, Integer.toString(dim - 1)); DependencyDerivator<DoubleVector> derivator = null; Class<DependencyDerivator<DoubleVector>> cls = ClassGenericsUtil.uglyCastIntoSubclass(DependencyDerivator.class); derivator = parameters.tryInstantiate(cls); @@ -784,7 +737,7 @@ public class CASH<V extends NumberVector> extends AbstractAlgorithm<Clustering<M ListParameterization parameters = new ListParameterization(); parameters.addParameter(PCAFilteredRunner.Parameterizer.PCA_EIGENPAIR_FILTER, FirstNEigenPairFilter.class.getName()); - parameters.addParameter(FirstNEigenPairFilter.EIGENPAIR_FILTER_N, Integer.toString(dimensionality)); + parameters.addParameter(FirstNEigenPairFilter.Parameterizer.EIGENPAIR_FILTER_N, Integer.toString(dimensionality)); DependencyDerivator<DoubleVector> derivator = null; Class<DependencyDerivator<DoubleVector>> cls = ClassGenericsUtil.uglyCastIntoSubclass(DependencyDerivator.class); derivator = parameters.tryInstantiate(cls); @@ -841,14 +794,77 @@ public class CASH<V extends NumberVector> extends AbstractAlgorithm<Clustering<M * @apiviz.exclude */ public static class Parameterizer extends AbstractParameterizer { - protected int minpts; - - protected int maxlevel; - - protected int mindim; - + /** + * Parameter to specify the threshold for minimum number of points in a + * cluster, must be an integer greater than 0. + * <p> + * Key: {@code -cash.minpts} + * </p> + */ + public static final OptionID MINPTS_ID = new OptionID("cash.minpts", "Threshold for minimum number of points in a cluster."); + + /** + * Parameter to specify the maximum level for splitting the hypercube, must + * be an integer greater than 0. + * <p> + * Key: {@code -cash.maxlevel} + * </p> + */ + public static final OptionID MAXLEVEL_ID = new OptionID("cash.maxlevel", "The maximum level for splitting the hypercube."); + + /** + * Parameter to specify the minimum dimensionality of the subspaces to be + * found, must be an integer greater than 0. + * <p> + * Default value: {@code 1} + * </p> + * <p> + * Key: {@code -cash.mindim} + * </p> + */ + public static final OptionID MINDIM_ID = new OptionID("cash.mindim", "The minimum dimensionality of the subspaces to be found."); + + /** + * Parameter to specify the maximum jitter for distance values, must be a + * double greater than 0. + * <p> + * Key: {@code -cash.jitter} + * </p> + */ + public static final OptionID JITTER_ID = new OptionID("cash.jitter", "The maximum jitter for distance values."); + + /** + * Flag to indicate that an adjustment of the applied heuristic for choosing + * an interval is performed after an interval is selected. + * <p> + * Key: {@code -cash.adjust} + * </p> + */ + public static final OptionID ADJUST_ID = new OptionID("cash.adjust", "Flag to indicate that an adjustment of the applied heuristic for choosing an interval " + "is performed after an interval is selected."); + + /** + * Threshold for minimum number of points in a cluster + */ + protected int minPts; + + /** + * Maximum level for splitting the hypercube. + */ + protected int maxLevel; + + /** + * Minimum dimensionality of the subspaces to be found + */ + protected int minDim; + + /** + * Maximum jitter for distance values. + */ protected double jitter; + /** + * Apply adjustment heuristic for interval choosing. + */ protected boolean adjust; @Override @@ -857,17 +873,17 @@ public class CASH<V extends NumberVector> extends AbstractAlgorithm<Clustering<M IntParameter minptsP = new IntParameter(MINPTS_ID); minptsP.addConstraint(CommonConstraints.GREATER_EQUAL_ONE_INT); if(config.grab(minptsP)) { - minpts = minptsP.getValue(); + minPts = minptsP.getValue(); } IntParameter maxlevelP = new IntParameter(MAXLEVEL_ID); maxlevelP.addConstraint(CommonConstraints.GREATER_EQUAL_ONE_INT); if(config.grab(maxlevelP)) { - maxlevel = maxlevelP.getValue(); + maxLevel = maxlevelP.getValue(); } IntParameter mindimP = new IntParameter(MINDIM_ID, 1); mindimP.addConstraint(CommonConstraints.GREATER_EQUAL_ONE_INT); if(config.grab(mindimP)) { - mindim = mindimP.getValue(); + minDim = mindimP.getValue(); } DoubleParameter jitterP = new DoubleParameter(JITTER_ID); jitterP.addConstraint(CommonConstraints.GREATER_THAN_ZERO_DOUBLE); @@ -882,7 +898,7 @@ public class CASH<V extends NumberVector> extends AbstractAlgorithm<Clustering<M @Override protected CASH<NumberVector> makeInstance() { - return new CASH<>(minpts, maxlevel, mindim, jitter, adjust); + return new CASH<>(minPts, maxLevel, minDim, jitter, adjust); } } } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/COPAC.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/COPAC.java index 06e64343..72de0a55 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/COPAC.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/COPAC.java @@ -67,6 +67,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Arthur Zimek + * @since 0.2 * * @apiviz.has DimensionModel * @apiviz.composedOf COPACNeighborPredicate diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/ERiC.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/ERiC.java index 8fb11eaf..f73e9e70 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/ERiC.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/ERiC.java @@ -79,6 +79,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Elke Achtert + * @since 0.2 * * @apiviz.composedOf COPAC * @apiviz.composedOf DBSCAN diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/FourC.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/FourC.java index 52d043ec..63fe9d81 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/FourC.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/FourC.java @@ -47,19 +47,20 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * 4C identifies local subgroups of data objects sharing a uniform correlation. * The algorithm is based on a combination of PCA and density-based clustering * (DBSCAN). - * + * * Reference: * <p> * C. Böhm, K. Kailing, P. Kröger, A. Zimek:<br /> * Computing Clusters of Correlation Connected Objects. <br> * In Proc. ACM SIGMOD Int. Conf. on Management of Data, Paris, France, 2004. * </p> - * + * * @author Arthur Zimek - * + * @since 0.2 + * * @apiviz.composedOf FourCNeighborPredicate * @apiviz.composedOf FourCCorePredicate - * + * * @param <V> type of NumberVector handled by this Algorithm */ @Title("4C: Computing Correlation Connected Clusters") @@ -77,7 +78,7 @@ public class FourC<V extends NumberVector> extends GeneralizedDBSCAN { /** * Constructor. - * + * * @param settings FourC settings. */ public FourC(FourC.Settings settings) { @@ -96,9 +97,9 @@ public class FourC<V extends NumberVector> extends GeneralizedDBSCAN { /** * Class wrapping the 4C parameter settings. - * + * * @author Erich Schubert - * + * * @apiviz.exclude */ public static class Settings { @@ -135,9 +136,9 @@ public class FourC<V extends NumberVector> extends GeneralizedDBSCAN { /** * Parameterization class for 4C settings. - * + * * @author Erich Schubert - * + * * @apiviz.exclude */ public static class Parameterizer extends AbstractParameterizer { @@ -178,7 +179,7 @@ public class FourC<V extends NumberVector> extends GeneralizedDBSCAN { /** * Configure the epsilon radius parameter. - * + * * @param config Parameter source */ protected void configEpsilon(Parameterization config) { @@ -191,7 +192,7 @@ public class FourC<V extends NumberVector> extends GeneralizedDBSCAN { /** * Configure the minPts aka "mu" parameter. - * + * * @param config Parameter source */ protected void configMinPts(Parameterization config) { @@ -204,18 +205,18 @@ public class FourC<V extends NumberVector> extends GeneralizedDBSCAN { /** * Configure the delta parameter. - * + * * @param config Parameter source */ protected void configDelta(Parameterization config) { // Flag for using absolute variances - Flag absoluteF = new Flag(LimitEigenPairFilter.EIGENPAIR_FILTER_ABSOLUTE); + Flag absoluteF = new Flag(LimitEigenPairFilter.Parameterizer.EIGENPAIR_FILTER_ABSOLUTE); if(config.grab(absoluteF)) { settings.absolute = absoluteF.isTrue(); } // Parameter delta - DoubleParameter deltaP = new DoubleParameter(LimitEigenPairFilter.EIGENPAIR_FILTER_DELTA) // + DoubleParameter deltaP = new DoubleParameter(LimitEigenPairFilter.Parameterizer.EIGENPAIR_FILTER_DELTA) // .addConstraint(CommonConstraints.GREATER_EQUAL_ZERO_DOUBLE); if(!settings.absolute) { deltaP.setDefaultValue(DEFAULT_DELTA); @@ -230,7 +231,7 @@ public class FourC<V extends NumberVector> extends GeneralizedDBSCAN { /** * Configure the kappa parameter. - * + * * @param config Parameter source */ protected void configKappa(Parameterization config) { @@ -244,7 +245,7 @@ public class FourC<V extends NumberVector> extends GeneralizedDBSCAN { /** * Configure the delta parameter. - * + * * @param config Parameter source */ protected void configLambda(Parameterization config) { @@ -265,9 +266,9 @@ public class FourC<V extends NumberVector> extends GeneralizedDBSCAN { /** * Parameterization class. - * + * * @author Erich Schubert - * + * * @apiviz.exclude */ public static class Parameterizer<O extends NumberVector> extends AbstractParameterizer { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/HiCO.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/HiCO.java index 0bbd012a..6a741ce1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/HiCO.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/HiCO.java @@ -74,11 +74,12 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * In: Proc. Int. Conf. on Scientific and Statistical Database Management * (SSDBM'06), Vienna, Austria, 2006. * </p> - * + * * @author Elke Achtert - * + * @since 0.3 + * * @apiviz.composedOf HiCO.Instance - * + * * @param <V> the type of NumberVector handled by the algorithm */ @Title("Mining Hierarchies of Correlation Clusters") @@ -117,7 +118,7 @@ public class HiCO<V extends NumberVector> extends GeneralizedOPTICS<V, Correlati /** * Constructor. - * + * * @param indexfactory Index factory * @param mu Mu parameter */ @@ -138,7 +139,7 @@ public class HiCO<V extends NumberVector> extends GeneralizedOPTICS<V, Correlati /** * Instance of the OPTICS algorithm. - * + * * @author Erich Schubert * * @apiviz.uses FilteredLocalPCAIndex @@ -275,7 +276,7 @@ public class HiCO<V extends NumberVector> extends GeneralizedOPTICS<V, Correlati /** * Sort new candidates by their distance, for determining the core size. - * + * * @author Erich Schubert * * @apiviz.exclude @@ -298,7 +299,7 @@ public class HiCO<V extends NumberVector> extends GeneralizedOPTICS<V, Correlati /** * Computes the correlation distance between the two subspaces defined by the * specified PCAs. - * + * * @param pca1 first PCA * @param pca2 second PCA * @param dimensionality the dimensionality of the data space @@ -370,7 +371,7 @@ public class HiCO<V extends NumberVector> extends GeneralizedOPTICS<V, Correlati * <code>v</code> at column <code>corrDim</code>. After insertion the matrix * <code>v</code> is orthonormalized and column <code>corrDim</code> of matrix * <code>e_czech</code> is set to the <code>corrDim</code>-th unit vector. - * + * * @param v the orthonormal matrix of the eigenvectors * @param e_czech the selection matrix of the strong eigenvectors * @param vector the vector to be inserted @@ -411,9 +412,9 @@ public class HiCO<V extends NumberVector> extends GeneralizedOPTICS<V, Correlati /** * Parameterization class. - * + * * @author Erich Schubert - * + * * @apiviz.exclude */ public static class Parameterizer<V extends NumberVector> extends AbstractParameterizer { @@ -421,7 +422,7 @@ public class HiCO<V extends NumberVector> extends GeneralizedOPTICS<V, Correlati * Parameter to specify the smoothing factor, must be an integer greater * than 0. The {link {@link #MU_ID}-nearest neighbor is used to compute the * correlation reachability of an object. - * + * * <p> * Key: {@code -hico.mu} * </p> @@ -515,7 +516,7 @@ public class HiCO<V extends NumberVector> extends GeneralizedOPTICS<V, Correlati ListParameterization params = new ListParameterization(); // preprocessor params.addParameter(KNNQueryFilteredPCAIndex.Factory.Parameterizer.K_ID, k); - params.addParameter(PercentageEigenPairFilter.ALPHA_ID, alpha); + params.addParameter(PercentageEigenPairFilter.Parameterizer.ALPHA_ID, alpha); ChainedParameterization chain = new ChainedParameterization(params, config); chain.errorsTo(config); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/LMCLUS.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/LMCLUS.java index 934d3fc6..0a302005 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/LMCLUS.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/LMCLUS.java @@ -79,6 +79,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * * @author Ernst Waas * @author Erich Schubert + * @since 0.5.0 */ @Reference(authors = "Robert Haralick, Rave Harpaz", title = "Linear manifold clustering in high dimensional spaces by stochastic search", booktitle = "Pattern Recognition volume 40, Issue 10", url = "http://dx.doi.org/10.1016/j.patcog.2007.01.020") public class LMCLUS extends AbstractAlgorithm<Clustering<Model>> { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/ORCLUS.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/ORCLUS.java index 4e5c3fbc..413675a8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/ORCLUS.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/ORCLUS.java @@ -75,6 +75,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * </p> * * @author Elke Achtert + * @since 0.2 * * @apiviz.has PCARunner * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/cash/CASHInterval.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/cash/CASHInterval.java index bf935864..42f1f474 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/cash/CASHInterval.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/cash/CASHInterval.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.logging.LoggingConfiguration; * and a set of objects ids associated with this interval. * * @author Elke Achtert + * @since 0.2 * * @apiviz.has de.lmu.ifi.dbs.elki.algorithm.clustering.correlation.cash.CASHIntervalSplit */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/cash/CASHIntervalSplit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/cash/CASHIntervalSplit.java index 1edec3a9..038495f2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/cash/CASHIntervalSplit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/cash/CASHIntervalSplit.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.FormatUtil; * Supports the splitting of CASH intervals. * * @author Elke Achtert + * @since 0.2 */ public class CASHIntervalSplit { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/cash/ParameterizationFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/cash/ParameterizationFunction.java index 31fea80f..1b0ec58f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/cash/ParameterizationFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/correlation/cash/ParameterizationFunction.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.FormatUtil; * belonging to the normal vector n. * * @author Elke Achtert + * @since 0.2 */ public class ParameterizationFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/AbstractEMModelFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/AbstractEMModelFactory.java index 36ae7804..0b165c75 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/AbstractEMModelFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/AbstractEMModelFactory.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Abstract base class for initializing EM. * * @author Erich Schubert + * @since 0.4.0 * * @param <V> Vector type * @param <M> Model type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/DiagonalGaussianModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/DiagonalGaussianModel.java index 544362da..e31089d5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/DiagonalGaussianModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/DiagonalGaussianModel.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; * Simpler model for a single Gaussian cluster, without covariances. * * @author Erich Schubert + * @since 0.7.0 */ public class DiagonalGaussianModel implements EMClusterModel<EMModel> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/DiagonalGaussianModelFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/DiagonalGaussianModelFactory.java index 3f3bf914..66fb548b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/DiagonalGaussianModelFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/DiagonalGaussianModelFactory.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; * corresponds to the {@code 'VVI'} model in Mclust (R). * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has DiagonalGaussianModel * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/EM.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/EM.java index 208e8450..039c0174 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/EM.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/EM.java @@ -63,14 +63,16 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Clustering by expectation maximization (EM-Algorithm), also known as Gaussian * Mixture Modeling (GMM). * + * Reference: * <p> - * Reference: A. P. Dempster, N. M. Laird, D. B. Rubin:<br /> - * Maximum Likelihood from Incomplete Data via the EM algorithm.<br> + * A. P. Dempster, N. M. Laird, D. B. Rubin:<br /> + * Maximum Likelihood from Incomplete Data via the EM algorithm.<br /> * In Journal of the Royal Statistical Society, Series B, 39(1), 1977, pp. 1-31 * </p> * * @author Arthur Zimek * @author Erich Schubert + * @since 0.2 * * @apiviz.composedOf EMClusterModelFactory * @@ -83,7 +85,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; title = "Maximum Likelihood from Incomplete Data via the EM algorithm", // booktitle = "Journal of the Royal Statistical Society, Series B, 39(1), 1977, pp. 1-31", // url = "http://www.jstor.org/stable/2984875") -@Alias({ "de.lmu.ifi.dbs.elki.algorithm.clustering.EM", "EM" }) +@Alias("de.lmu.ifi.dbs.elki.algorithm.clustering.EM") public class EM<V extends NumberVector, M extends MeanModel> extends AbstractAlgorithm<Clustering<M>> implements ClusteringAlgorithm<Clustering<M>> { /** * The logger for this class. @@ -392,7 +394,7 @@ public class EM<V extends NumberVector, M extends MeanModel> extends AbstractAlg initializer = initialP.instantiateClass(config); } - DoubleParameter deltaP = new DoubleParameter(DELTA_ID, 1e-5)// + DoubleParameter deltaP = new DoubleParameter(DELTA_ID, 1e-7)// .addConstraint(CommonConstraints.GREATER_EQUAL_ZERO_DOUBLE); if(config.grab(deltaP)) { delta = deltaP.getValue(); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/EMClusterModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/EMClusterModel.java index aaf66839..c89d85d0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/EMClusterModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/EMClusterModel.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.data.model.MeanModel; * Models useable in EM clustering. * * @author Erich Schubert + * @since 0.3 */ public interface EMClusterModel<M extends MeanModel> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/EMClusterModelFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/EMClusterModelFactory.java index d486d5d3..a4f1e486 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/EMClusterModelFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/EMClusterModelFactory.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.NumberVectorDistanceFunctio * Factory for initializing the EM models. * * @author Erich Schubert + * @since 0.2 * * @param <V> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/MultivariateGaussianModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/MultivariateGaussianModel.java index 4c020bc1..3b433af1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/MultivariateGaussianModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/MultivariateGaussianModel.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; * Model for a single Gaussian cluster. * * @author Erich Schubert + * @since 0.7.0 */ public class MultivariateGaussianModel implements EMClusterModel<EMModel> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/MultivariateGaussianModelFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/MultivariateGaussianModelFactory.java index 8e767a0f..e47cb1ea 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/MultivariateGaussianModelFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/MultivariateGaussianModelFactory.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; * {@code 'VVV'} model in Mclust (R). * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has MultivariateGaussianModel * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/SphericalGaussianModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/SphericalGaussianModel.java index 7aa5b92b..97296d45 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/SphericalGaussianModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/SphericalGaussianModel.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; * Simple spherical Gaussian cluster. * * @author Erich Schubert + * @since 0.7.0 */ public class SphericalGaussianModel implements EMClusterModel<EMModel> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/SphericalGaussianModelFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/SphericalGaussianModelFactory.java index 8b2dfd57..0b32a962 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/SphericalGaussianModelFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/em/SphericalGaussianModelFactory.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; * corresponds to the {@code 'VVI'} model in Mclust (R). * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has SphericalGaussianModel * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/AbstractRangeQueryNeighborPredicate.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/AbstractRangeQueryNeighborPredicate.java index 53f70aac..aa78033d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/AbstractRangeQueryNeighborPredicate.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/AbstractRangeQueryNeighborPredicate.java @@ -50,6 +50,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Abstract local model neighborhood predicate. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.has Instance * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/COPACNeighborPredicate.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/COPACNeighborPredicate.java index a2ec0e2e..f8aa1b97 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/COPACNeighborPredicate.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/COPACNeighborPredicate.java @@ -70,6 +70,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * * @author Arthur Zimek * @author Erich Schubert + * @since 0.7.0 * * @param <V> the type of NumberVector handled by this Algorithm */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/CorePredicate.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/CorePredicate.java index f87227c1..cd957770 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/CorePredicate.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/CorePredicate.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; * Note the Factory/Instance split of this interface. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.has Instance */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/ERiCNeighborPredicate.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/ERiCNeighborPredicate.java index d137ee67..cbe169ee 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/ERiCNeighborPredicate.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/ERiCNeighborPredicate.java @@ -70,6 +70,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * * @author Elke Achtert * @author Erich Schubert + * @since 0.7.0 * * @param <V> the type of NumberVector handled by this Algorithm */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/EpsilonNeighborPredicate.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/EpsilonNeighborPredicate.java index 8610521a..e3fdb443 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/EpsilonNeighborPredicate.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/EpsilonNeighborPredicate.java @@ -59,6 +59,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.has Instance * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/FourCCorePredicate.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/FourCCorePredicate.java index ecd569e9..72b96fa0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/FourCCorePredicate.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/FourCCorePredicate.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * </p> * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.has Instance */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/FourCNeighborPredicate.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/FourCNeighborPredicate.java index e9f50c41..71b4cf66 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/FourCNeighborPredicate.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/FourCNeighborPredicate.java @@ -65,6 +65,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * * @author Arthur Zimek * @author Erich Schubert + * @since 0.7.0 * * @param <V> the type of NumberVector handled by this Algorithm */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/GeneralizedDBSCAN.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/GeneralizedDBSCAN.java index b6b9d74f..86753fcd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/GeneralizedDBSCAN.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/GeneralizedDBSCAN.java @@ -68,6 +68,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * * @author Erich Schubert * @author Arthur Zimek + * @since 0.5.0 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/LSDBC.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/LSDBC.java index bd145c14..5c6ddafe 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/LSDBC.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/LSDBC.java @@ -75,6 +75,7 @@ import gnu.trove.list.array.TIntArrayList; * </p> * * @author Erich Schubert + * @since 0.7.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/MinPtsCorePredicate.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/MinPtsCorePredicate.java index ff58902d..405ba28a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/MinPtsCorePredicate.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/MinPtsCorePredicate.java @@ -50,6 +50,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.has Instance */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/NeighborPredicate.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/NeighborPredicate.java index 1e2aa716..9d760a4d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/NeighborPredicate.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/NeighborPredicate.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDs; * Note the Factory/Instance split of this interface. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.has Instance */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/PreDeConCorePredicate.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/PreDeConCorePredicate.java index 0ae26c40..e0cd1547 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/PreDeConCorePredicate.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/PreDeConCorePredicate.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * </p> * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.has Instance */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/PreDeConNeighborPredicate.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/PreDeConNeighborPredicate.java index 26991ca9..9da9cc21 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/PreDeConNeighborPredicate.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/gdbscan/PreDeConNeighborPredicate.java @@ -59,6 +59,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * * @author Peer Kröger * @author Erich Schubert + * @since 0.7.0 * * @param <V> the type of NumberVector handled by this Algorithm */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/AGNES.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/AGNES.java index 41de1cac..484c83b7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/AGNES.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/AGNES.java @@ -27,14 +27,8 @@ import de.lmu.ifi.dbs.elki.algorithm.AbstractDistanceBasedAlgorithm; import de.lmu.ifi.dbs.elki.data.type.TypeInformation; import de.lmu.ifi.dbs.elki.data.type.TypeUtil; import de.lmu.ifi.dbs.elki.database.Database; -import de.lmu.ifi.dbs.elki.database.datastore.DataStoreFactory; -import de.lmu.ifi.dbs.elki.database.datastore.DataStoreUtil; -import de.lmu.ifi.dbs.elki.database.datastore.WritableDBIDDataStore; -import de.lmu.ifi.dbs.elki.database.datastore.WritableDoubleDataStore; -import de.lmu.ifi.dbs.elki.database.datastore.WritableIntegerDataStore; import de.lmu.ifi.dbs.elki.database.ids.ArrayDBIDs; import de.lmu.ifi.dbs.elki.database.ids.DBIDArrayIter; -import de.lmu.ifi.dbs.elki.database.ids.DBIDIter; import de.lmu.ifi.dbs.elki.database.ids.DBIDUtil; import de.lmu.ifi.dbs.elki.database.query.distance.DistanceQuery; import de.lmu.ifi.dbs.elki.database.relation.Relation; @@ -57,7 +51,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * * This is the naive O(n^3) algorithm. See {@link SLINK} for a much faster * algorithm (however, only for single-linkage). - * + * * This implementation uses the pointer-based representation used by SLINK, so * that the extraction algorithms we have can be used with either of them. * @@ -92,8 +86,10 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.composedOf LinkageMethod + * @apiviz.composedOf PointerHierarchyRepresentationBuilder * * @param <O> Object type */ @@ -116,7 +112,7 @@ public class AGNES<O> extends AbstractDistanceBasedAlgorithm<O, PointerHierarchy /** * Constructor. - * + * * @param distanceFunction Distance function to use * @param linkage Linkage method */ @@ -136,7 +132,7 @@ public class AGNES<O> extends AbstractDistanceBasedAlgorithm<O, PointerHierarchy /** * Run the algorithm - * + * * @param db Database * @param relation Relation * @return Clustering hierarchy @@ -162,21 +158,16 @@ public class AGNES<O> extends AbstractDistanceBasedAlgorithm<O, PointerHierarchy initializeDistanceMatrix(scratch, dq, ix, iy, square); // Initialize space for result: - WritableDBIDDataStore pi = DataStoreUtil.makeDBIDStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_STATIC); - WritableDoubleDataStore lambda = DataStoreUtil.makeDoubleStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_STATIC, Double.POSITIVE_INFINITY); - WritableIntegerDataStore csize = DataStoreUtil.makeIntegerStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_TEMP, 1); - for(DBIDIter it = ids.iter(); it.valid(); it.advance()) { - pi.put(it, it); - } + PointerHierarchyRepresentationBuilder builder = new PointerHierarchyRepresentationBuilder(ids); // Repeat until everything merged into 1 cluster FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("Agglomerative clustering", size - 1, LOG) : null; int wsize = size; for(int i = 1; i < size; i++) { - int x = findMerge(wsize, scratch, ix, iy, pi, lambda, csize); + int x = findMerge(wsize, scratch, ix, iy, builder); if(x == wsize - 1) { --wsize; - for(ix.seek(wsize - 1); lambda.doubleValue(ix) < Double.POSITIVE_INFINITY; ix.retract()) { + for(ix.seek(wsize - 1); builder.isLinked(ix); ix.retract()) { --wsize; } } @@ -184,12 +175,12 @@ public class AGNES<O> extends AbstractDistanceBasedAlgorithm<O, PointerHierarchy } LOG.ensureCompleted(prog); - return new PointerHierarchyRepresentationResult(ids, pi, lambda); + return builder.complete(); } /** * Compute the size of a complete x by x triangle (minus diagonal) - * + * * @param x Offset * @return Size of complete triangle */ @@ -199,7 +190,7 @@ public class AGNES<O> extends AbstractDistanceBasedAlgorithm<O, PointerHierarchy /** * Initialize a distance matrix. - * + * * @param scratch Scratch space to be used. * @param dq Distance query * @param ix Data iterator @@ -221,29 +212,27 @@ public class AGNES<O> extends AbstractDistanceBasedAlgorithm<O, PointerHierarchy /** * Perform the next merge step in AGNES. - * + * * @param size Data set size * @param scratch Scratch space. * @param ix First iterator * @param iy Second iterator - * @param pi Parent storage - * @param lambda Lambda (join distance) storage - * @param csize Cluster sizes + * @param builder Pointer representation builder * @return x, for shrinking the working set. */ - protected int findMerge(int size, double[] scratch, DBIDArrayIter ix, DBIDArrayIter iy, WritableDBIDDataStore pi, WritableDoubleDataStore lambda, WritableIntegerDataStore csize) { + protected int findMerge(int size, double[] scratch, DBIDArrayIter ix, DBIDArrayIter iy, PointerHierarchyRepresentationBuilder builder) { double mindist = Double.POSITIVE_INFINITY; int x = -1, y = -1; // Find minimum: for(int ox = 0, xbase = 0; ox < size; xbase += ox++) { // Skip if object has already joined a cluster: - if(lambda.doubleValue(ix.seek(ox)) < Double.POSITIVE_INFINITY) { + if(builder.isLinked(ix.seek(ox))) { continue; } assert(xbase == triangleSize(ox)); for(int oy = 0; oy < ox; oy++) { // Skip if object has already joined a cluster: - if(lambda.doubleValue(iy.seek(oy)) < Double.POSITIVE_INFINITY) { + if(builder.isLinked(iy.seek(oy))) { continue; } final int idx = xbase + oy; @@ -255,25 +244,23 @@ public class AGNES<O> extends AbstractDistanceBasedAlgorithm<O, PointerHierarchy } } assert(x >= 0 && y >= 0); - merge(size, scratch, ix, iy, pi, lambda, csize, mindist, x, y); + merge(size, scratch, ix, iy, builder, mindist, x, y); return x; } /** * Execute the cluster merge. - * + * * @param size Data set size * @param scratch Scratch space. * @param ix First iterator * @param iy Second iterator - * @param pi Parent storage - * @param lambda Lambda (join distance) storage - * @param csize Cluster sizes + * @param builder Hierarchy builder * @param mindist Distance that was used for merging * @param x First matrix position * @param y Second matrix position */ - protected void merge(int size, double[] scratch, DBIDArrayIter ix, DBIDArrayIter iy, WritableDBIDDataStore pi, WritableDoubleDataStore lambda, WritableIntegerDataStore csize, double mindist, int x, int y) { + protected void merge(int size, double[] scratch, DBIDArrayIter ix, DBIDArrayIter iy, PointerHierarchyRepresentationBuilder builder, double mindist, int x, int y) { // Avoid allocating memory, by reusing existing iterators: ix.seek(x); iy.seek(y); @@ -283,41 +270,39 @@ public class AGNES<O> extends AbstractDistanceBasedAlgorithm<O, PointerHierarchy // Perform merge in data structure: x -> y assert(y < x); // Since y < x, prefer keeping y, dropping x. - lambda.put(ix, mindist); - pi.put(ix, iy); + builder.add(ix, mindist, iy); // Update cluster size for y: - final int sizex = csize.intValue(ix), sizey = csize.intValue(iy); - csize.put(iy, sizex + sizey); + final int sizex = builder.getSize(ix), sizey = builder.getSize(iy); + builder.setSize(iy, sizex + sizey); // Note: this changes iy. - updateMatrix(size, scratch, iy, lambda, csize, mindist, x, y, sizex, sizey); + updateMatrix(size, scratch, iy, builder, mindist, x, y, sizex, sizey); } /** * Update the scratch distance matrix. - * + * * @param size Data set size * @param scratch Scratch matrix. * @param ij Iterator to reuse - * @param lambda Lambda (join distance) storage - * @param csize Cluster sizes + * @param builder Hierarchy builder * @param mindist Distance that was used for merging * @param x First matrix position * @param y Second matrix position * @param sizex Old size of first cluster * @param sizey Old size of second cluster */ - protected void updateMatrix(int size, double[] scratch, DBIDArrayIter ij, WritableDoubleDataStore lambda, WritableIntegerDataStore csize, double mindist, int x, int y, final int sizex, final int sizey) { + protected void updateMatrix(int size, double[] scratch, DBIDArrayIter ij, PointerHierarchyRepresentationBuilder builder, double mindist, int x, int y, final int sizex, final int sizey) { // Update distance matrix. Note: miny < minx final int xbase = triangleSize(x), ybase = triangleSize(y); // Write to (y, j), with j < y int j = 0; for(; j < y; j++) { - if(lambda.doubleValue(ij.seek(j)) < Double.POSITIVE_INFINITY) { + if(builder.isLinked(ij.seek(j))) { continue; } - final int sizej = csize.intValue(ij); + final int sizej = builder.getSize(ij); final int yb = ybase + j; scratch[yb] = linkage.combine(sizex, scratch[xbase + j], sizey, scratch[yb], sizej, mindist); } @@ -325,20 +310,20 @@ public class AGNES<O> extends AbstractDistanceBasedAlgorithm<O, PointerHierarchy // Write to (j, y), with y < j < x int jbase = triangleSize(j); for(; j < x; jbase += j++) { - if(lambda.doubleValue(ij.seek(j)) < Double.POSITIVE_INFINITY) { + if(builder.isLinked(ij.seek(j))) { continue; } - final int sizej = csize.intValue(ij); + final int sizej = builder.getSize(ij); final int jb = jbase + y; scratch[jb] = linkage.combine(sizex, scratch[xbase + j], sizey, scratch[jb], sizej, mindist); } jbase += j++; // Skip x // Write to (j, y), with y < x < j for(; j < size; jbase += j++) { - if(lambda.doubleValue(ij.seek(j)) < Double.POSITIVE_INFINITY) { + if(builder.isLinked(ij.seek(j))) { continue; } - final int sizej = csize.intValue(ij); + final int sizej = builder.getSize(ij); scratch[jbase + y] = linkage.combine(sizex, scratch[jbase + x], sizey, scratch[jbase + y], sizej, mindist); } } @@ -356,11 +341,11 @@ public class AGNES<O> extends AbstractDistanceBasedAlgorithm<O, PointerHierarchy /** * Parameterization class - * + * * @author Erich Schubert - * + * * @apiviz.exclude - * + * * @param <O> Object type */ public static class Parameterizer<O> extends AbstractDistanceBasedAlgorithm.Parameterizer<O> { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/AbstractHDBSCAN.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/AbstractHDBSCAN.java index 8febff49..a38f629f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/AbstractHDBSCAN.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/AbstractHDBSCAN.java @@ -66,6 +66,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf HDBSCANAdapter * @apiviz.composedOf HeapMSTCollector @@ -107,7 +108,7 @@ public abstract class AbstractHDBSCAN<O, R extends Result> extends AbstractDista protected WritableDoubleDataStore computeCoreDists(DBIDs ids, KNNQuery<O> knnQ, int minPts) { final Logging LOG = getLogger(); final WritableDoubleDataStore coredists = DataStoreUtil.makeDoubleStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_DB); - FiniteProgress cprog = LOG.isVerbose() ? new FiniteProgress("Computing core sizes.", ids.size(), LOG) : null; + FiniteProgress cprog = LOG.isVerbose() ? new FiniteProgress("Computing core sizes", ids.size(), LOG) : null; for(DBIDIter iter = ids.iter(); iter.valid(); iter.advance()) { coredists.put(iter, knnQ.getKNNForDBID(iter, minPts).getKNNDistance()); LOG.incrementProcessed(cprog); @@ -234,7 +235,7 @@ public abstract class AbstractHDBSCAN<O, R extends Result> extends AbstractDista pi.put(iter, iter); // Initialize } DBIDVar p = DBIDUtil.newVar(), q = DBIDUtil.newVar(), n = DBIDUtil.newVar(); - FiniteProgress pprog = LOG.isVerbose() ? new FiniteProgress("Converting MST to pointer representation.", heap.size(), LOG) : null; + FiniteProgress pprog = LOG.isVerbose() ? new FiniteProgress("Converting MST to pointer representation", heap.size(), LOG) : null; while(!heap.isEmpty()) { final double dist = heap.peekKey(); final long pair = heap.peekValue(); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/AnderbergHierarchicalClustering.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/AnderbergHierarchicalClustering.java index 0484b7ad..f30bd8df 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/AnderbergHierarchicalClustering.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/AnderbergHierarchicalClustering.java @@ -29,14 +29,8 @@ import de.lmu.ifi.dbs.elki.algorithm.AbstractDistanceBasedAlgorithm; import de.lmu.ifi.dbs.elki.data.type.TypeInformation; import de.lmu.ifi.dbs.elki.data.type.TypeUtil; import de.lmu.ifi.dbs.elki.database.Database; -import de.lmu.ifi.dbs.elki.database.datastore.DataStoreFactory; -import de.lmu.ifi.dbs.elki.database.datastore.DataStoreUtil; -import de.lmu.ifi.dbs.elki.database.datastore.WritableDBIDDataStore; -import de.lmu.ifi.dbs.elki.database.datastore.WritableDoubleDataStore; -import de.lmu.ifi.dbs.elki.database.datastore.WritableIntegerDataStore; import de.lmu.ifi.dbs.elki.database.ids.ArrayDBIDs; import de.lmu.ifi.dbs.elki.database.ids.DBIDArrayIter; -import de.lmu.ifi.dbs.elki.database.ids.DBIDIter; import de.lmu.ifi.dbs.elki.database.ids.DBIDUtil; import de.lmu.ifi.dbs.elki.database.query.distance.DistanceQuery; import de.lmu.ifi.dbs.elki.database.relation.Relation; @@ -52,16 +46,16 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; /** * This is a modification of the classic AGNES algorithm for hierarchical * clustering using a nearest-neighbor heuristic for acceleration. - * + * * Instead of scanning the matrix (with cost O(n^2)) to find the minimum, the * nearest neighbor of each object is remembered. On the downside, we need to * check these values at every merge, and it may now cost O(n^2) to perform a * merge, so there is no worst-case advantage to this approach. The average case * however improves from O(n^3) to O(n^2), which yields a considerable * improvement in running time. - * + * * This optimization is attributed to M. R. Anderberg. - * + * * Reference: * <p> * M. R. Anderberg<br /> @@ -71,8 +65,10 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.composedOf LinkageMethod + * @apiviz.composedOf PointerHierarchyRepresentationBuilder * * @param <O> Object type */ @@ -92,7 +88,7 @@ public class AnderbergHierarchicalClustering<O> extends AbstractDistanceBasedAlg /** * Constructor. - * + * * @param distanceFunction Distance function to use * @param linkage Linkage method */ @@ -103,7 +99,7 @@ public class AnderbergHierarchicalClustering<O> extends AbstractDistanceBasedAlg /** * Run the algorithm - * + * * @param db Database * @param relation Relation * @return Clustering hierarchy @@ -135,21 +131,16 @@ public class AnderbergHierarchicalClustering<O> extends AbstractDistanceBasedAlg initializeNNCache(scratch, bestd, besti); // Initialize space for result: - WritableDBIDDataStore pi = DataStoreUtil.makeDBIDStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_STATIC); - WritableDoubleDataStore lambda = DataStoreUtil.makeDoubleStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_STATIC, Double.POSITIVE_INFINITY); - WritableIntegerDataStore csize = DataStoreUtil.makeIntegerStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_TEMP, 1); - for(DBIDIter it = ids.iter(); it.valid(); it.advance()) { - pi.put(it, it); - } + PointerHierarchyRepresentationBuilder builder = new PointerHierarchyRepresentationBuilder(ids); // Repeat until everything merged into 1 cluster FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("Agglomerative clustering", size - 1, LOG) : null; int wsize = size; for(int i = 1; i < size; i++) { - int x = findMerge(wsize, scratch, ix, iy, bestd, besti, pi, lambda, csize); + int x = findMerge(wsize, scratch, ix, iy, bestd, besti, builder); if(x == wsize - 1) { --wsize; - for(ix.seek(wsize - 1); lambda.doubleValue(ix) < Double.POSITIVE_INFINITY; ix.retract()) { + for(ix.seek(wsize - 1); builder.isLinked(ix); ix.retract()) { --wsize; } } @@ -157,12 +148,12 @@ public class AnderbergHierarchicalClustering<O> extends AbstractDistanceBasedAlg } LOG.ensureCompleted(prog); - return new PointerHierarchyRepresentationResult(ids, pi, lambda); + return builder.complete(); } /** * Initialize the NN cache. - * + * * @param scratch Scatch space * @param bestd Best distance * @param besti Best index @@ -193,21 +184,19 @@ public class AnderbergHierarchicalClustering<O> extends AbstractDistanceBasedAlg /** * Perform the next merge step. - * + * * Due to the cache, this is now O(n) each time, instead of O(n*n). - * + * * @param size Data set size * @param scratch Scratch space. * @param ix First iterator * @param iy Second iterator * @param bestd Best distance * @param besti Index of best distance - * @param pi Parent storage - * @param lambda Lambda (join distance) storage - * @param csize Cluster sizes + * @param builder Hierarchy builder * @return x, for shrinking the working set. */ - protected int findMerge(int size, double[] scratch, DBIDArrayIter ix, DBIDArrayIter iy, double[] bestd, int[] besti, WritableDBIDDataStore pi, WritableDoubleDataStore lambda, WritableIntegerDataStore csize) { + protected int findMerge(int size, double[] scratch, DBIDArrayIter ix, DBIDArrayIter iy, double[] bestd, int[] besti, PointerHierarchyRepresentationBuilder builder) { double mindist = Double.POSITIVE_INFINITY; int x = -1, y = -1; // Find minimum: @@ -223,27 +212,25 @@ public class AnderbergHierarchicalClustering<O> extends AbstractDistanceBasedAlg } } assert(x >= 0 && y >= 0); - merge(size, scratch, ix, iy, bestd, besti, pi, lambda, csize, mindist, x < y ? y : x, x < y ? x : y); + merge(size, scratch, ix, iy, bestd, besti, builder, mindist, x < y ? y : x, x < y ? x : y); return x; } /** * Execute the cluster merge. - * + * * @param size Data set size * @param scratch Scratch space. * @param ix First iterator * @param iy Second iterator * @param bestd Best distance * @param besti Index of best distance - * @param pi Parent storage - * @param lambda Lambda (join distance) storage - * @param csize Cluster sizes + * @param builder Hierarchy builder * @param mindist Distance that was used for merging * @param x First matrix position * @param y Second matrix position */ - protected void merge(int size, double[] scratch, DBIDArrayIter ix, DBIDArrayIter iy, double[] bestd, int[] besti, WritableDBIDDataStore pi, WritableDoubleDataStore lambda, WritableIntegerDataStore csize, double mindist, int x, int y) { + protected void merge(int size, double[] scratch, DBIDArrayIter ix, DBIDArrayIter iy, double[] bestd, int[] besti, PointerHierarchyRepresentationBuilder builder, double mindist, int x, int y) { // Avoid allocating memory, by reusing existing iterators: ix.seek(x); iy.seek(y); @@ -253,17 +240,16 @@ public class AnderbergHierarchicalClustering<O> extends AbstractDistanceBasedAlg // Perform merge in data structure: x -> y assert(y < x); // Since y < x, prefer keeping y, dropping x. - lambda.put(ix, mindist); - pi.put(ix, iy); + builder.add(ix, mindist, iy); // Update cluster size for y: - final int sizex = csize.intValue(ix), sizey = csize.intValue(iy); - csize.put(iy, sizex + sizey); + final int sizex = builder.getSize(ix), sizey = builder.getSize(iy); + builder.setSize(iy, sizex + sizey); // Deactivate x in cache: besti[x] = -1; // Note: this changes iy. - updateMatrix(size, scratch, iy, bestd, besti, lambda, csize, mindist, x, y, sizex, sizey); + updateMatrix(size, scratch, iy, bestd, besti, builder, mindist, x, y, sizex, sizey); if(besti[y] == x) { findBest(size, scratch, bestd, besti, y); } @@ -271,31 +257,30 @@ public class AnderbergHierarchicalClustering<O> extends AbstractDistanceBasedAlg /** * Update the scratch distance matrix. - * + * * @param size Data set size * @param scratch Scratch matrix. * @param ij Iterator to reuse * @param bestd Best distance * @param besti Index of best distance - * @param lambda Lambda (join distance) storage - * @param csize Cluster sizes + * @param builder Hierarchy builder * @param mindist Distance that was used for merging * @param x First matrix position * @param y Second matrix position * @param sizex Old size of first cluster * @param sizey Old size of second cluster */ - protected void updateMatrix(int size, double[] scratch, DBIDArrayIter ij, double[] bestd, int[] besti, WritableDoubleDataStore lambda, WritableIntegerDataStore csize, double mindist, int x, int y, final int sizex, final int sizey) { + protected void updateMatrix(int size, double[] scratch, DBIDArrayIter ij, double[] bestd, int[] besti, PointerHierarchyRepresentationBuilder builder, double mindist, int x, int y, final int sizex, final int sizey) { // Update distance matrix. Note: miny < minx final int xbase = AGNES.triangleSize(x), ybase = AGNES.triangleSize(y); // Write to (y, j), with j < y int j = 0; for(; j < y; j++) { - if(lambda.doubleValue(ij.seek(j)) < Double.POSITIVE_INFINITY) { + if(builder.isLinked(ij.seek(j))) { continue; } - final int sizej = csize.intValue(ij); + final int sizej = builder.getSize(ij); final int yb = ybase + j; final double d = scratch[yb] = linkage.combine(sizex, scratch[xbase + j], sizey, scratch[yb], sizej, mindist); updateCache(size, scratch, bestd, besti, x, y, j, d); @@ -304,10 +289,10 @@ public class AnderbergHierarchicalClustering<O> extends AbstractDistanceBasedAlg // Write to (j, y), with y < j < x int jbase = AGNES.triangleSize(j); for(; j < x; jbase += j++) { - if(lambda.doubleValue(ij.seek(j)) < Double.POSITIVE_INFINITY) { + if(builder.isLinked(ij.seek(j))) { continue; } - final int sizej = csize.intValue(ij); + final int sizej = builder.getSize(ij); final int jb = jbase + y; final double d = scratch[jb] = linkage.combine(sizex, scratch[xbase + j], sizey, scratch[jb], sizej, mindist); updateCache(size, scratch, bestd, besti, x, y, j, d); @@ -315,10 +300,10 @@ public class AnderbergHierarchicalClustering<O> extends AbstractDistanceBasedAlg jbase += j++; // Skip x // Write to (j, y), with y < x < j for(; j < size; jbase += j++) { - if(lambda.doubleValue(ij.seek(j)) < Double.POSITIVE_INFINITY) { + if(builder.isLinked(ij.seek(j))) { continue; } - final int sizej = csize.intValue(ij); + final int sizej = builder.getSize(ij); final double d = scratch[jbase + y] = linkage.combine(sizex, scratch[jbase + x], sizey, scratch[jbase + y], sizej, mindist); updateCache(size, scratch, bestd, besti, x, y, j, d); } @@ -390,11 +375,11 @@ public class AnderbergHierarchicalClustering<O> extends AbstractDistanceBasedAlg /** * Parameterization class - * + * * @author Erich Schubert - * + * * @apiviz.exclude - * + * * @param <O> Object type */ public static class Parameterizer<O> extends AbstractDistanceBasedAlgorithm.Parameterizer<O> { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/CLINK.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/CLINK.java index 65eba0cd..711cc5c7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/CLINK.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/CLINK.java @@ -56,6 +56,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has CompleteLinkageMethod * @@ -65,7 +66,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; title = "An Efficient Algorithm for the Complete Link Cluster Method", // booktitle = "The Computer Journal 20.4", // url = "http://dx.doi.org/10.1093/comjnl/20.4.364") -@Alias({ "CLINK", "Defays" }) +@Alias("Defays") public class CLINK<O> extends SLINK<O> { /** * The logger for this class. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/CentroidLinkageMethod.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/CentroidLinkageMethod.java index 9fc13e20..5d33f693 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/CentroidLinkageMethod.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/CentroidLinkageMethod.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 */ @Alias({ "centroid", "upgmc" }) @Reference(authors = "A. K. Jain and R. C. Dubes", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/CompleteLinkageMethod.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/CompleteLinkageMethod.java index 28c6841d..241137e1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/CompleteLinkageMethod.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/CompleteLinkageMethod.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Complete-linkage clustering method. * * @author Erich Schubert + * @since 0.5.0 */ @Alias({ "complete", "clink", "complete-link", "farthest-neighbor" }) public class CompleteLinkageMethod implements LinkageMethod { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/GroupAverageLinkageMethod.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/GroupAverageLinkageMethod.java index c618775e..551f84cb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/GroupAverageLinkageMethod.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/GroupAverageLinkageMethod.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.3 */ @Alias({ "upgma", "average", "average-link", "average-linkage", "UPGMA" }) @Reference(authors = "A. K. Jain and R. C. Dubes", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/HDBSCANLinearMemory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/HDBSCANLinearMemory.java index 37dfd01f..b402d65f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/HDBSCANLinearMemory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/HDBSCANLinearMemory.java @@ -74,8 +74,11 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * </p> * * @author Erich Schubert + * @since 0.7.0 * * @param <O> Object type + * + * @apiviz.has PointerDensityHierarchyRepresentationResult */ @Title("HDBSCAN: Hierarchical Density-Based Spatial Clustering of Applications with Noise") @Description("Density-Based Clustering Based on Hierarchical Density Estimates") @@ -119,7 +122,7 @@ public class HDBSCANLinearMemory<O> extends AbstractHDBSCAN<O, PointerDensityHie final int numedges = ids.size() - 1; DoubleLongHeap heap = new DoubleLongMinHeap(numedges); // 2. Build spanning tree. - FiniteProgress mprog = LOG.isVerbose() ? new FiniteProgress("Computing minimum spanning tree (n-1 edges).", numedges, LOG) : null; + FiniteProgress mprog = LOG.isVerbose() ? new FiniteProgress("Computing minimum spanning tree (n-1 edges)", numedges, LOG) : null; PrimsMinimumSpanningTree.processDense(ids,// new HDBSCANAdapter(ids, coredists, distQ), // new HeapMSTCollector(heap, mprog, LOG)); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/HierarchicalClusteringAlgorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/HierarchicalClusteringAlgorithm.java index 0dfb31e0..80f72a69 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/HierarchicalClusteringAlgorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/HierarchicalClusteringAlgorithm.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.database.Database; * {@link de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.extraction.ExtractFlatClusteringFromHierarchy}. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has PointerHierarchyRepresentationResult */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/LinkageMethod.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/LinkageMethod.java index ea853eec..de134e1d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/LinkageMethod.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/LinkageMethod.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.4.0 */ @Reference(authors = "G. N. Lance and W. T. Williams", // title = "A general theory of classificatory sorting strategies 1. Hierarchical systems", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/MedianLinkageMethod.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/MedianLinkageMethod.java index 6eb2e156..20f83feb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/MedianLinkageMethod.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/MedianLinkageMethod.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.3 */ @Reference(authors = "J. C. Gower", // title = "A comparison of some methods of cluster analysis", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/PointerDensityHierarchyRepresentationResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/PointerDensityHierarchyRepresentationResult.java index 581841b8..b37e82af 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/PointerDensityHierarchyRepresentationResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/PointerDensityHierarchyRepresentationResult.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDs; * which is a density estimation. * * @author Erich Schubert + * @since 0.5.0 */ public class PointerDensityHierarchyRepresentationResult extends PointerHierarchyRepresentationResult { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/PointerHierarchyRepresentationBuilder.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/PointerHierarchyRepresentationBuilder.java new file mode 100644 index 00000000..8e15bf81 --- /dev/null +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/PointerHierarchyRepresentationBuilder.java @@ -0,0 +1,171 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical; +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import de.lmu.ifi.dbs.elki.database.datastore.DataStoreFactory; +import de.lmu.ifi.dbs.elki.database.datastore.DataStoreUtil; +import de.lmu.ifi.dbs.elki.database.datastore.WritableDBIDDataStore; +import de.lmu.ifi.dbs.elki.database.datastore.WritableDoubleDataStore; +import de.lmu.ifi.dbs.elki.database.datastore.WritableIntegerDataStore; +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.DBIDs; +import de.lmu.ifi.dbs.elki.logging.Logging; + +/** + * Class to help building a pointer hierarchy. + * + * @author Erich Schubert + * @since 0.7.1 + * + * @apiviz.has PointerHierarchyRepresentationResult + */ +public class PointerHierarchyRepresentationBuilder { + /** + * Class logger. + */ + private static final Logging LOG = Logging.getLogger(PointerHierarchyRepresentationBuilder.class); + + /** + * The DBIDs in this result. + */ + protected final DBIDs ids; + + /** + * The parent DBID relation. + */ + protected WritableDBIDDataStore parent; + + /** + * Distance to the parent object. + */ + protected WritableDoubleDataStore parentDistance; + + /** + * Last linking distance. + */ + protected double prevdist; + + /** + * Cluster size storage. May be uninitialized! + */ + protected WritableIntegerDataStore csize; + + /** + * Constructor. + * + * @param ids IDs + */ + public PointerHierarchyRepresentationBuilder(DBIDs ids) { + super(); + this.ids = ids; + this.parent = DataStoreUtil.makeDBIDStorage(ids, DataStoreFactory.HINT_DB | DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_STATIC); + this.parentDistance = DataStoreUtil.makeDoubleStorage(ids, DataStoreFactory.HINT_DB | DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_STATIC, Double.POSITIVE_INFINITY); + this.prevdist = Double.NEGATIVE_INFINITY; + for(DBIDIter it = ids.iter(); it.valid(); it.advance()) { + parent.put(it, it); + } + } + + /** + * Add an element to the pointer representation. + * + * Important: If an algorithm does not produce links in an increasing fashion, + * a warning will be issued and the linking distance will be increased. + * Otherwise, the hierarchy would be misinterpreted when links are executed + * ordered by their distance. + * + * @param cur Current object + * @param distance Link distance + * @param par Parent + */ + public void add(DBIDRef cur, double distance, DBIDRef par) { + if(distance < prevdist) { + LOG.warning("Non-monotone hierarchical clustering detected. Adjusting linking distance from " + distance + " to " + prevdist); + distance = prevdist; + } + parent.putDBID(cur, par); + double olddist = parentDistance.putDouble(cur, distance); + assert (olddist == Double.POSITIVE_INFINITY) : "Object was already linked!"; + prevdist = distance; + } + + /** + * Finalize the result. + * + * @return Completed result + */ + public PointerHierarchyRepresentationResult complete() { + if(csize != null) { + csize.destroy(); + csize = null; + } + return new PointerHierarchyRepresentationResult(ids, parent, parentDistance); + } + + /** + * Get the cluster size of the current object. + * + * @param id Object id + * @return Cluster size (initially 1). + */ + public int getSize(DBIDRef id) { + if(csize == null) { + csize = DataStoreUtil.makeIntegerStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_TEMP, 1); + } + return csize.intValue(id); + } + + /** + * Set the cluster size of an object. + * + * @param id Object to set + * @param size Cluster size + */ + public void setSize(DBIDRef id, int size) { + if(csize == null) { + csize = DataStoreUtil.makeIntegerStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_TEMP, 1); + } + csize.putInt(id, size); + } + + /** + * Test if an object is already linked. + * + * @param id Object + * @return {@code true} if the object is already linked. + */ + public boolean isLinked(DBIDRef id) { + return parentDistance.doubleValue(id) < Double.POSITIVE_INFINITY; + } + + /** + * Get the current linking distance of an object. + * + * @param id Object + * @return Distance, or infinity + */ + public double getDistance(DBIDRef id) { + return parentDistance.doubleValue(id); + } +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/PointerHierarchyRepresentationResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/PointerHierarchyRepresentationResult.java index 2369c6e5..fbd3d6b9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/PointerHierarchyRepresentationResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/PointerHierarchyRepresentationResult.java @@ -24,8 +24,19 @@ package de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical; */ import de.lmu.ifi.dbs.elki.database.datastore.DBIDDataStore; +import de.lmu.ifi.dbs.elki.database.datastore.DataStoreFactory; +import de.lmu.ifi.dbs.elki.database.datastore.DataStoreUtil; import de.lmu.ifi.dbs.elki.database.datastore.DoubleDataStore; +import de.lmu.ifi.dbs.elki.database.datastore.IntegerDataStore; +import de.lmu.ifi.dbs.elki.database.datastore.WritableIntegerDataStore; +import de.lmu.ifi.dbs.elki.database.ids.ArrayDBIDs; +import de.lmu.ifi.dbs.elki.database.ids.ArrayModifiableDBIDs; +import de.lmu.ifi.dbs.elki.database.ids.DBIDArrayIter; +import de.lmu.ifi.dbs.elki.database.ids.DBIDIter; +import de.lmu.ifi.dbs.elki.database.ids.DBIDUtil; +import de.lmu.ifi.dbs.elki.database.ids.DBIDVar; import de.lmu.ifi.dbs.elki.database.ids.DBIDs; +import de.lmu.ifi.dbs.elki.database.ids.ModifiableDBIDs; import de.lmu.ifi.dbs.elki.result.BasicResult; /** @@ -36,7 +47,12 @@ import de.lmu.ifi.dbs.elki.result.BasicResult; * {@link de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.extraction.ExtractFlatClusteringFromHierarchy} * can be used to extract partitions from this graph. * + * This class can also compute dendrogram positions, but using a faster + * algorithm than the one proposed by Sibson 1971, using only O(n log n) time + * due to sorting, but using an additional temporary array. + * * @author Erich Schubert + * @since 0.6.0 */ public class PointerHierarchyRepresentationResult extends BasicResult { /** @@ -55,8 +71,13 @@ public class PointerHierarchyRepresentationResult extends BasicResult { DoubleDataStore parentDistance; /** + * Position storage, computed on demand. + */ + IntegerDataStore positions = null; + + /** * Constructor. - * + * * @param ids IDs processed. * @param parent Parent pointer. * @param parentDistance Distance to parent. @@ -70,7 +91,7 @@ public class PointerHierarchyRepresentationResult extends BasicResult { /** * Get the clustered DBIDs. - * + * * @return DBIDs */ public DBIDs getDBIDs() { @@ -79,7 +100,7 @@ public class PointerHierarchyRepresentationResult extends BasicResult { /** * Get the parent DBID relation. - * + * * @return Parent relation. */ public DBIDDataStore getParentStore() { @@ -88,10 +109,98 @@ public class PointerHierarchyRepresentationResult extends BasicResult { /** * Get the distance to the parent. - * + * * @return Parent distance. */ public DoubleDataStore getParentDistanceStore() { return parentDistance; } + + /** + * Get / compute the positions. + * + * @return Dendrogram positions + */ + public IntegerDataStore getPositions() { + if(positions != null) { + return positions; // Return cached. + } + ArrayDBIDs order = topologicalSort(ids, parent, parentDistance); + DBIDArrayIter it = order.iter(); + final int last = order.size() - 1; + // Subtree sizes of each element: + WritableIntegerDataStore siz = DataStoreUtil.makeIntegerStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_DB, 1); + DBIDVar v1 = DBIDUtil.newVar(); + for(it.seek(0); it.valid(); it.advance()) { + if(DBIDUtil.equal(it, parent.assignVar(it, v1))) { + continue; + } + siz.increment(v1, siz.intValue(it)); + } + // Assertion only holds for exact e.g. single linkage + //assert (siz.intValue(it.seek(last)) == ids.size()); + WritableIntegerDataStore pos = DataStoreUtil.makeIntegerStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_DB, -1); + WritableIntegerDataStore ins = DataStoreUtil.makeIntegerStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_TEMP, -1); + int defins = 0; + // Place elements based on their successor + for(it.seek(last); it.valid(); it.retract()) { + int size = siz.intValue(it); + parent.assignVar(it, v1); // v1 = parent + final int ipos = ins.intValue(v1); + // Assertion only holds for exact e.g. single linkage + // assert (ipos >= 0); + if(ipos < 0 || DBIDUtil.equal(it, v1)) { + // Root: use interval [defins; defins + size] + ins.putInt(it, defins); + pos.putInt(it, defins + size - 1); + defins += size; + continue; + } + // Insertion position of parent = leftmost + pos.putInt(it, ipos + size - 1); + ins.putInt(it, ipos); + ins.increment(v1, size); + } + ins.destroy(); + return positions = pos; + } + + /** + * Perform topological sorting based on the successor order. + * + * @param oids IDs to sort + * @param parent Parent relationship. + * @param parentDistance Distance to parent. + * @return Sorted order + */ + public static ArrayDBIDs topologicalSort(DBIDs oids, DBIDDataStore parent, DoubleDataStore parentDistance) { + // We used to simply use this: + // But for e.g. Median Linkage, this would lead to problems, as links are + // not necessarily performed in ascending order anymore! + ArrayModifiableDBIDs ids = DBIDUtil.newArray(oids); + ids.sort(new DataStoreUtil.DescendingByDoubleDataStoreAndId(parentDistance)); + final int size = ids.size(); + ModifiableDBIDs seen = DBIDUtil.newHashSet(size); + ArrayModifiableDBIDs order = DBIDUtil.newArray(size); + DBIDVar v1 = DBIDUtil.newVar(), prev = DBIDUtil.newVar(); + for(DBIDIter it = ids.iter(); it.valid(); it.advance()) { + if(!seen.add(it)) { + continue; + } + order.add(it); + prev.set(it); // Copy + while(!DBIDUtil.equal(prev, parent.assignVar(prev, v1))) { + if(!seen.add(v1)) { + break; + } + order.add(v1); + prev.set(v1); // Copy + } + } + // Reverse the array: + for(int i = 0, j = size - 1; i < j; i++, j--) { + order.swap(i, j); + } + return order; + } } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/SLINK.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/SLINK.java index 71213208..f41a18bb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/SLINK.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/SLINK.java @@ -63,6 +63,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * * @author Elke Achtert * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has SingleLinkageMethod * @@ -74,7 +75,8 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; title = "SLINK: An optimally efficient algorithm for the single-link cluster method", // booktitle = "The Computer Journal 16 (1973), No. 1, p. 30-34.", // url = "http://dx.doi.org/10.1093/comjnl/16.1.30") -@Alias(value = { "de.lmu.ifi.dbs.elki.algorithm.clustering.SLINK", "clustering.SLINK", "SLINK", "single-link", "single-linkage" }) +@Alias({ "de.lmu.ifi.dbs.elki.algorithm.clustering.SLINK", "clustering.SLINK", // +"single-link", "single-linkage" }) public class SLINK<O> extends AbstractDistanceBasedAlgorithm<O, PointerHierarchyRepresentationResult>implements HierarchicalClusteringAlgorithm { /** * The logger for this class. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/SLINKHDBSCANLinearMemory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/SLINKHDBSCANLinearMemory.java index 8f1c6195..d89da303 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/SLINKHDBSCANLinearMemory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/SLINKHDBSCANLinearMemory.java @@ -50,22 +50,22 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; /** * Linear memory implementation of HDBSCAN clustering based on SLINK. - * + * * By not building a distance matrix, we can reduce memory usage to linear * memory only; but at the cost of roughly double the runtime (unless using * indexes) as we first need to compute all kNN distances (for core sizes), then * recompute distances when building the spanning tree. - * + * * This version uses the SLINK algorithm to directly produce the pointer * representation expected by the extraction methods. The SLINK algorithm is * closely related to Prim's minimum spanning tree, but produces the more * compact pointer representation instead of an edges list. - * + * * This implementation does <em>not</em> include the cluster extraction * discussed as Step 4. This functionality should however already be provided by * {@link de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.extraction.HDBSCANHierarchyExtraction} * . For this reason, we also do <em>not include self-edges</em>. - * + * * Reference: * <p> * R. J. G. B. Campello, D. Moulavi, and J. Sander<br /> @@ -73,8 +73,11 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * Pacific-Asia Conference on Advances in Knowledge Discovery and Data Mining, * PAKDD * </p> - * + * * @author Erich Schubert + * @since 0.6.0 + * + * @apiviz.has PointerDensityHierarchyRepresentationResult */ @Title("HDBSCAN: Hierarchical Density-Based Spatial Clustering of Applications with Noise") @Description("Density-Based Clustering Based on Hierarchical Density Estimates") @@ -90,7 +93,7 @@ public class SLINKHDBSCANLinearMemory<O> extends AbstractHDBSCAN<O, PointerDensi /** * Constructor. - * + * * @param distanceFunction Distance function * @param minPts Minimum number of points for density */ @@ -100,7 +103,7 @@ public class SLINKHDBSCANLinearMemory<O> extends AbstractHDBSCAN<O, PointerDensi /** * Run the algorithm - * + * * @param db Database * @param relation Relation * @return Clustering hierarchy @@ -143,7 +146,7 @@ public class SLINKHDBSCANLinearMemory<O> extends AbstractHDBSCAN<O, PointerDensi /** * First step: Initialize P(id) = id, L(id) = infinity. - * + * * @param id the id of the object to be inserted into the pointer * representation * @param pi Pi data store @@ -160,7 +163,7 @@ public class SLINKHDBSCANLinearMemory<O> extends AbstractHDBSCAN<O, PointerDensi /** * Second step: Determine the pairwise distances from all objects in the * pointer representation to the new object with the specified id. - * + * * @param id the id of the object to be inserted into the pointer * representation * @param processedIDs the already processed ids @@ -179,7 +182,7 @@ public class SLINKHDBSCANLinearMemory<O> extends AbstractHDBSCAN<O, PointerDensi /** * Third step: Determine the values for P and L - * + * * @param id the id of the object to be inserted into the pointer * representation * @param pi Pi data store @@ -220,7 +223,7 @@ public class SLINKHDBSCANLinearMemory<O> extends AbstractHDBSCAN<O, PointerDensi /** * Fourth step: Actualize the clusters if necessary - * + * * @param id the id of the current object * @param pi Pi data store * @param lambda Lambda data store @@ -254,11 +257,11 @@ public class SLINKHDBSCANLinearMemory<O> extends AbstractHDBSCAN<O, PointerDensi /** * Parameterization class - * + * * @author Erich Schubert - * + * * @apiviz.exclude - * + * * @param <O> Object type */ public static class Parameterizer<O> extends AbstractHDBSCAN.Parameterizer<O> { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/SingleLinkageMethod.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/SingleLinkageMethod.java index f16393de..73cf4b99 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/SingleLinkageMethod.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/SingleLinkageMethod.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.3 */ @Reference(authors = "K. Florek and J. Łukaszewicz and J. Perkal and H. Steinhaus and S. Zubrzycki", // title = "Sur la liaison et la division des points d'un ensemble fini",// diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/WardLinkageMethod.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/WardLinkageMethod.java index 80194a87..ad61d6da 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/WardLinkageMethod.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/WardLinkageMethod.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.6.0 */ @Reference(authors = "J. H. Ward Jr", // title = "Hierarchical grouping to optimize an objective function", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/WeightedAverageLinkageMethod.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/WeightedAverageLinkageMethod.java index 162d4bc9..3cb583f8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/WeightedAverageLinkageMethod.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/WeightedAverageLinkageMethod.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 */ @Reference(authors = "A. K. Jain and R. C. Dubes", // title = "Algorithms for Clustering Data", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/extraction/ExtractFlatClusteringFromHierarchy.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/extraction/ExtractFlatClusteringFromHierarchy.java index 5f4bbd70..9d055b03 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/extraction/ExtractFlatClusteringFromHierarchy.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/extraction/ExtractFlatClusteringFromHierarchy.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDs; import de.lmu.ifi.dbs.elki.database.ids.ModifiableDBIDs; import de.lmu.ifi.dbs.elki.logging.Logging; import de.lmu.ifi.dbs.elki.logging.progress.FiniteProgress; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.DoubleArray; import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; @@ -69,10 +70,12 @@ import de.lmu.ifi.dbs.elki.workflow.AlgorithmStep; * TODO: add an hierarchy simplification step. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.uses HierarchicalClusteringAlgorithm * @apiviz.uses PointerHierarchyRepresentationResult */ +@Alias("de.lmu.ifi.dbs.elki.algorithm.clustering.hierarchical.ExtractFlatClusteringFromHierarchy") public class ExtractFlatClusteringFromHierarchy implements ClusteringAlgorithm<Clustering<DendrogramModel>> { /** * Class logger. @@ -182,8 +185,7 @@ public class ExtractFlatClusteringFromHierarchy implements ClusteringAlgorithm<C // Sort DBIDs by lambda. We need this for two things: // a) to determine the stop distance from "minclusters" parameter // b) to process arrows in decreasing / increasing order - ArrayModifiableDBIDs order = DBIDUtil.newArray(ids); - order.sort(new DataStoreUtil.AscendingByDoubleDataStore(lambda)); + ArrayDBIDs order = PointerHierarchyRepresentationResult.topologicalSort(ids, pi, lambda); DBIDArrayIter it = order.iter(); // Used multiple times! final int split = findSplit(order, it, lambda); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/extraction/HDBSCANHierarchyExtraction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/extraction/HDBSCANHierarchyExtraction.java index 20c5e211..80c32ae4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/extraction/HDBSCANHierarchyExtraction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/extraction/HDBSCANHierarchyExtraction.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.database.datastore.DataStoreFactory; import de.lmu.ifi.dbs.elki.database.datastore.DataStoreUtil; import de.lmu.ifi.dbs.elki.database.datastore.DoubleDataStore; import de.lmu.ifi.dbs.elki.database.datastore.WritableDataStore; +import de.lmu.ifi.dbs.elki.database.ids.ArrayDBIDs; import de.lmu.ifi.dbs.elki.database.ids.ArrayModifiableDBIDs; import de.lmu.ifi.dbs.elki.database.ids.DBIDArrayIter; import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; @@ -81,6 +82,7 @@ import de.lmu.ifi.dbs.elki.workflow.AlgorithmStep; * one-element clusters to reduce garbage collection overhead. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.uses HierarchicalClusteringAlgorithm * @apiviz.uses PointerHierarchyRepresentationResult @@ -153,8 +155,7 @@ public class HDBSCANHierarchyExtraction implements ClusteringAlgorithm<Clusterin FiniteProgress progress = LOG.isVerbose() ? new FiniteProgress("Extracting clusters", ids.size(), LOG) : null; // Sort DBIDs by lambda, to process merges in increasing order. - ArrayModifiableDBIDs order = DBIDUtil.newArray(ids); - order.sort(new DataStoreUtil.AscendingByDoubleDataStore(lambda)); + ArrayDBIDs order = PointerHierarchyRepresentationResult.topologicalSort(ids, pi, lambda); WritableDataStore<TempCluster> cluster_map = DataStoreUtil.makeStorage(ids, DataStoreFactory.HINT_TEMP, TempCluster.class); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/extraction/SimplifiedHierarchyExtraction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/extraction/SimplifiedHierarchyExtraction.java index 236e7e0a..b84d1a6f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/extraction/SimplifiedHierarchyExtraction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/hierarchical/extraction/SimplifiedHierarchyExtraction.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.database.datastore.DataStoreFactory; import de.lmu.ifi.dbs.elki.database.datastore.DataStoreUtil; import de.lmu.ifi.dbs.elki.database.datastore.DoubleDataStore; import de.lmu.ifi.dbs.elki.database.datastore.WritableDataStore; +import de.lmu.ifi.dbs.elki.database.ids.ArrayDBIDs; import de.lmu.ifi.dbs.elki.database.ids.ArrayModifiableDBIDs; import de.lmu.ifi.dbs.elki.database.ids.DBIDArrayIter; import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; @@ -73,6 +74,7 @@ import de.lmu.ifi.dbs.elki.workflow.AlgorithmStep; * </p> * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.uses HierarchicalClusteringAlgorithm * @apiviz.uses PointerHierarchyRepresentationResult @@ -138,8 +140,7 @@ public class SimplifiedHierarchyExtraction implements ClusteringAlgorithm<Cluste FiniteProgress progress = LOG.isVerbose() ? new FiniteProgress("Extracting clusters", ids.size(), LOG) : null; // Sort DBIDs by lambda, to process merges in increasing order. - ArrayModifiableDBIDs order = DBIDUtil.newArray(ids); - order.sort(new DataStoreUtil.AscendingByDoubleDataStore(lambda)); + ArrayDBIDs order = PointerHierarchyRepresentationResult.topologicalSort(ids, pi, lambda); WritableDataStore<TempCluster> cluster_map = DataStoreUtil.makeStorage(ids, DataStoreFactory.HINT_TEMP, TempCluster.class); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/AbstractKMeans.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/AbstractKMeans.java index 40fb313d..5df1bee8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/AbstractKMeans.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/AbstractKMeans.java @@ -63,6 +63,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Abstract base class for k-means implementations. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.composedOf KMeansInitialization * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/BestOfMultipleKMeans.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/BestOfMultipleKMeans.java index 292e74db..84fb877c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/BestOfMultipleKMeans.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/BestOfMultipleKMeans.java @@ -49,6 +49,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * * @author Stephan Baier * @author Erich Schubert + * @since 0.6.0 * * @param <V> Vector type * @param <M> Model type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/CLARA.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/CLARA.java index 4e2bf7a8..42ea12b6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/CLARA.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/CLARA.java @@ -66,6 +66,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * </p> * * @author Erich Schubert + * @since 0.7.0 * * @param <V> Vector type */ @@ -124,7 +125,7 @@ public class CLARA<V> extends KMedoidsPAM<V> { WritableIntegerDataStore bestclusters = null; Random rnd = random.getSingleThreadedRandom(); - FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("Random samples.", numsamples, LOG) : null; + FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("Processing random samples", numsamples, LOG) : null; for(int j = 0; j < numsamples; j++) { DBIDs rids = DBIDUtil.randomSample(ids, sampling, rnd); // Choose initial medoids diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeans.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeans.java index b242b407..697655d8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeans.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeans.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; * Some constants and options shared among kmeans family algorithms. * * @author Erich Schubert + * @since 0.2 * * @param <V> Number vector type * @param <M> Actual model type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansBatchedLloyd.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansBatchedLloyd.java index c6082176..8885fc46 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansBatchedLloyd.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansBatchedLloyd.java @@ -69,6 +69,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * blocks. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has KMeansModel * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansBisecting.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansBisecting.java index 70b6a30e..92e00e0d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansBisecting.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansBisecting.java @@ -61,6 +61,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Stephan Baier + * @since 0.6.0 * * @param <V> Vector type * @param <M> Model type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansCompare.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansCompare.java new file mode 100644 index 00000000..5632621a --- /dev/null +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansCompare.java @@ -0,0 +1,271 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMeansInitialization; +import de.lmu.ifi.dbs.elki.data.Cluster; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.NumberVector; +import de.lmu.ifi.dbs.elki.data.model.KMeansModel; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.database.datastore.DataStoreFactory; +import de.lmu.ifi.dbs.elki.database.datastore.DataStoreUtil; +import de.lmu.ifi.dbs.elki.database.datastore.WritableIntegerDataStore; +import de.lmu.ifi.dbs.elki.database.ids.DBIDIter; +import de.lmu.ifi.dbs.elki.database.ids.DBIDUtil; +import de.lmu.ifi.dbs.elki.database.ids.DBIDs; +import de.lmu.ifi.dbs.elki.database.ids.ModifiableDBIDs; +import de.lmu.ifi.dbs.elki.database.relation.Relation; +import de.lmu.ifi.dbs.elki.distance.distancefunction.NumberVectorDistanceFunction; +import de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction; +import de.lmu.ifi.dbs.elki.logging.Logging; +import de.lmu.ifi.dbs.elki.logging.progress.IndefiniteProgress; +import de.lmu.ifi.dbs.elki.logging.statistics.DoubleStatistic; +import de.lmu.ifi.dbs.elki.logging.statistics.LongStatistic; +import de.lmu.ifi.dbs.elki.logging.statistics.StringStatistic; +import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; +import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; +import de.lmu.ifi.dbs.elki.utilities.documentation.Title; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; + +/** + * Compare-Means: Accelerated k-means by exploiting the triangle inequality and + * pairwise distances of means to prune candidate means. + * + * Reference: + * <p> + * S. J. Phillips<br /> + * Acceleration of k-means and related clustering algorithms<br /> + * Proc. 4th Int. Workshop on Algorithm Engineering and Experiments (ALENEX + * 2002) + * </p> + * + * @author Erich Schubert + * @since 0.5.0 + * + * @apiviz.has KMeansModel + * + * @param <V> vector datatype + */ +@Title("Compare-Means") +@Reference(authors = "S. J. Phillips", // +title = "Acceleration of k-means and related clustering algorithms", // +booktitle = "Proc. 4th Int. Workshop on Algorithm Engineering and Experiments (ALENEX 2002)", // +url = "http://dx.doi.org/10.1007/3-540-45643-0_13") +public class KMeansCompare<V extends NumberVector> extends AbstractKMeans<V, KMeansModel> { + /** + * The logger for this class. + */ + private static final Logging LOG = Logging.getLogger(KMeansCompare.class); + + /** + * Key for statistics logging. + */ + private static final String KEY = KMeansCompare.class.getName(); + + /** + * Constructor. + * + * @param distanceFunction distance function + * @param k k parameter + * @param maxiter Maxiter parameter + * @param initializer Initialization method + */ + public KMeansCompare(NumberVectorDistanceFunction<? super V> distanceFunction, int k, int maxiter, KMeansInitialization<? super V> initializer) { + super(distanceFunction, k, maxiter, initializer); + } + + @Override + public Clustering<KMeansModel> run(Database database, Relation<V> relation) { + if(relation.size() <= 0) { + return new Clustering<>("k-Means Clustering", "kmeans-clustering"); + } + // Choose initial means + if(LOG.isStatistics()) { + LOG.statistics(new StringStatistic(KEY + ".initialization", initializer.toString())); + } + List<Vector> means = initializer.chooseInitialMeans(database, relation, k, getDistanceFunction(), Vector.FACTORY); + // Setup cluster assignment store + List<ModifiableDBIDs> clusters = new ArrayList<>(); + for(int i = 0; i < k; i++) { + clusters.add(DBIDUtil.newHashSet((int) (relation.size() * 2. / k))); + } + WritableIntegerDataStore assignment = DataStoreUtil.makeIntegerStorage(relation.getDBIDs(), DataStoreFactory.HINT_TEMP | DataStoreFactory.HINT_HOT, -1); + double[] varsum = new double[k]; + + // Cluster distances + double[][] cdist = new double[k][k]; + + IndefiniteProgress prog = LOG.isVerbose() ? new IndefiniteProgress("K-Means iteration", LOG) : null; + DoubleStatistic varstat = LOG.isStatistics() ? new DoubleStatistic(this.getClass().getName() + ".variance-sum") : null; + LongStatistic diststat = LOG.isStatistics() ? new LongStatistic(KEY + ".distance-computations") : null; + int iteration = 0; + for(; maxiter <= 0 || iteration < maxiter; iteration++) { + LOG.incrementProcessed(prog); + recomputeSeperation(means, cdist, diststat); + boolean changed = assignToNearestCluster(relation, means, clusters, assignment, varsum, cdist, diststat); + logVarstat(varstat, varsum); + if(LOG.isStatistics()) { + LOG.statistics(diststat); + } + // Stop if no cluster assignment changed. + if(!changed) { + break; + } + // Recompute means. + means = means(clusters, means, relation); + } + LOG.setCompleted(prog); + if(LOG.isStatistics()) { + LOG.statistics(new LongStatistic(KEY + ".iterations", iteration)); + } + + // Wrap result + Clustering<KMeansModel> result = new Clustering<>("k-Means Clustering", "kmeans-clustering"); + for(int i = 0; i < clusters.size(); i++) { + DBIDs ids = clusters.get(i); + if(ids.size() == 0) { + continue; + } + KMeansModel model = new KMeansModel(means.get(i), varsum[i]); + result.addToplevelCluster(new Cluster<>(ids, model)); + } + return result; + } + + /** + * Recompute the separation of cluster means. + * + * @param means Means + * @param cdist Center-to-Center distances + * @param diststat Distance counting statistic + */ + private void recomputeSeperation(List<Vector> means, double[][] cdist, LongStatistic diststat) { + final int k = means.size(); + for(int i = 1; i < k; i++) { + Vector mi = means.get(i); + for(int j = 0; j < i; j++) { + double d = distanceFunction.distance(mi, means.get(j)); + cdist[i][j] = d; + cdist[j][i] = d; + } + } + if(diststat != null) { + diststat.increment((k * (k - 1)) >> 1); + } + } + + /** + * Reassign objects, but only if their bounds indicate it is necessary to do + * so. + * + * @param relation Data + * @param means Current means + * @param clusters Current clusters + * @param assignment Cluster assignment + * @param varsum Variance sum counter + * @param cdist Centroid distances + * @param diststat Distance statistics + * @return true when the object was reassigned + */ + private boolean assignToNearestCluster(Relation<V> relation, List<Vector> means, List<ModifiableDBIDs> clusters, WritableIntegerDataStore assignment, double[] varsum, double[][] cdist, LongStatistic diststat) { + assert (k == means.size()); + long dists = 0; + boolean changed = false; + // Reset all clusters + Arrays.fill(varsum, 0.); + for(ModifiableDBIDs cluster : clusters) { + cluster.clear(); + } + final NumberVectorDistanceFunction<?> df = getDistanceFunction(); + double mult = (df instanceof SquaredEuclideanDistanceFunction) ? 4 : 2; + for(DBIDIter iditer = relation.iterDBIDs(); iditer.valid(); iditer.advance()) { + final int cur = assignment.intValue(iditer), ini = cur >= 0 ? cur : 0; + // Distance to current mean: + V fv = relation.get(iditer); + double mindist = df.distance(fv, means.get(ini)); + ++dists; + final double thresh = mult * mindist; + int minIndex = ini; + for(int i = 0; i < k; i++) { + if(i == ini || cdist[minIndex][i] >= thresh) { // Compare pruning + continue; + } + double dist = df.distance(fv, means.get(i)); + ++dists; + if(dist < mindist) { + minIndex = i; + mindist = dist; + } + } + varsum[minIndex] += mindist; + clusters.get(minIndex).add(iditer); + changed |= assignment.putInt(iditer, minIndex) != minIndex; + } + // Increment distance computations counter. + if(diststat != null) { + diststat.increment(dists); + } + return changed; + } + + @Override + protected Logging getLogger() { + return LOG; + } + + /** + * Parameterization class. + * + * @author Erich Schubert + * + * @apiviz.exclude + */ + public static class Parameterizer<V extends NumberVector> extends AbstractKMeans.Parameterizer<V> { + @Override + protected Logging getLogger() { + return LOG; + } + + @Override + protected void getParameterDistanceFunction(Parameterization config) { + super.getParameterDistanceFunction(config); + if(distanceFunction instanceof SquaredEuclideanDistanceFunction) { + return; // Proper choice. + } + if(distanceFunction != null && !distanceFunction.isMetric()) { + LOG.warning("Compare k-means requires a metric distance, and k-means should only be used with squared Euclidean distance!"); + } + } + + @Override + protected KMeansCompare<V> makeInstance() { + return new KMeansCompare<>(distanceFunction, k, maxiter, initializer); + } + } +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansElkan.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansElkan.java index e2dcf88c..58015327 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansElkan.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansElkan.java @@ -47,11 +47,14 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.NumberVectorDistanceFunctio import de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction; import de.lmu.ifi.dbs.elki.logging.Logging; import de.lmu.ifi.dbs.elki.logging.progress.IndefiniteProgress; +import de.lmu.ifi.dbs.elki.logging.statistics.DoubleStatistic; import de.lmu.ifi.dbs.elki.logging.statistics.LongStatistic; import de.lmu.ifi.dbs.elki.logging.statistics.StringStatistic; import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag; /** * Elkan's fast k-means by exploiting the triangle inequality. @@ -69,6 +72,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * </p> * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has KMeansModel * @@ -90,15 +94,22 @@ public class KMeansElkan<V extends NumberVector> extends AbstractKMeans<V, KMean private static final String KEY = KMeansElkan.class.getName(); /** + * Flag whether to compute the final variance statistic. + */ + private boolean varstat = false; + + /** * Constructor. * * @param distanceFunction distance function * @param k k parameter * @param maxiter Maxiter parameter * @param initializer Initialization method + * @param varstat Compute the variance statistic */ - public KMeansElkan(NumberVectorDistanceFunction<? super V> distanceFunction, int k, int maxiter, KMeansInitialization<? super V> initializer) { + public KMeansElkan(NumberVectorDistanceFunction<? super V> distanceFunction, int k, int maxiter, KMeansInitialization<? super V> initializer, boolean varstat) { super(distanceFunction, k, maxiter, initializer); + this.varstat = varstat; } @Override @@ -108,7 +119,7 @@ public class KMeansElkan<V extends NumberVector> extends AbstractKMeans<V, KMean } // Choose initial means if(LOG.isStatistics()) { - LOG.statistics(new StringStatistic(KEY + ".initializer", initializer.toString())); + LOG.statistics(new StringStatistic(KEY + ".initialization", initializer.toString())); } List<Vector> means = initializer.chooseInitialMeans(database, relation, k, getDistanceFunction(), Vector.FACTORY); // Setup cluster assignment store @@ -136,7 +147,7 @@ public class KMeansElkan<V extends NumberVector> extends AbstractKMeans<V, KMean double[][] cdist = new double[k][k]; IndefiniteProgress prog = LOG.isVerbose() ? new IndefiniteProgress("K-Means iteration", LOG) : null; - LongStatistic varstat = LOG.isStatistics() ? new LongStatistic(this.getClass().getName() + ".reassignments") : null; + LongStatistic rstat = LOG.isStatistics() ? new LongStatistic(this.getClass().getName() + ".reassignments") : null; int iteration = 0; for(; maxiter <= 0 || iteration < maxiter; iteration++) { LOG.incrementProcessed(prog); @@ -148,9 +159,9 @@ public class KMeansElkan<V extends NumberVector> extends AbstractKMeans<V, KMean recomputeSeperation(means, sep, cdist); // #1 changed = assignToNearestCluster(relation, means, sums, clusters, assignment, sep, cdist, upper, lower); } - if(varstat != null) { - varstat.setLong(changed); - LOG.statistics(varstat); + if(rstat != null) { + rstat.setLong(changed); + LOG.statistics(rstat); } // Stop if no cluster assignment changed. if(changed == 0) { @@ -178,6 +189,7 @@ public class KMeansElkan<V extends NumberVector> extends AbstractKMeans<V, KMean lower.destroy(); // Wrap result + double totalvariance = 0.; Clustering<KMeansModel> result = new Clustering<>("k-Means Clustering", "kmeans-clustering"); for(int i = 0; i < clusters.size(); i++) { DBIDs ids = clusters.get(i); @@ -189,9 +201,13 @@ public class KMeansElkan<V extends NumberVector> extends AbstractKMeans<V, KMean for(DBIDIter it = ids.iter(); it.valid(); it.advance()) { varsum += distanceFunction.distance(mean, relation.get(it)); } + totalvariance += varsum; KMeansModel model = new KMeansModel(mean, varsum); result.addToplevelCluster(new Cluster<>(ids, model)); } + if(LOG.isStatistics() && varstat) { + LOG.statistics(new DoubleStatistic(this.getClass().getName() + ".variance-sum", totalvariance)); + } return result; } @@ -395,6 +411,16 @@ public class KMeansElkan<V extends NumberVector> extends AbstractKMeans<V, KMean * @apiviz.exclude */ public static class Parameterizer<V extends NumberVector> extends AbstractKMeans.Parameterizer<V> { + /** + * Flag to compute the final clustering variance statistic. + */ + public static final OptionID VARSTAT_ID = new OptionID("kmeans.varstat", "Compute the final clustering variance statistic. Needs an additional full pass over the data set."); + + /** + * Compute the final variance statisic. + */ + protected boolean varstat = false; + @Override protected Logging getLogger() { return LOG; @@ -412,8 +438,17 @@ public class KMeansElkan<V extends NumberVector> extends AbstractKMeans<V, KMean } @Override + protected void makeOptions(Parameterization config) { + super.makeOptions(config); + Flag varF = new Flag(VARSTAT_ID); + if(config.grab(varF)) { + varstat = varF.isTrue(); + } + } + + @Override protected KMeansElkan<V> makeInstance() { - return new KMeansElkan<>(distanceFunction, k, maxiter, initializer); + return new KMeansElkan<>(distanceFunction, k, maxiter, initializer, varstat); } } } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansHamerly.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansHamerly.java index 1b114701..06228525 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansHamerly.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansHamerly.java @@ -46,11 +46,14 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.NumberVectorDistanceFunctio import de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction; import de.lmu.ifi.dbs.elki.logging.Logging; import de.lmu.ifi.dbs.elki.logging.progress.IndefiniteProgress; +import de.lmu.ifi.dbs.elki.logging.statistics.DoubleStatistic; import de.lmu.ifi.dbs.elki.logging.statistics.LongStatistic; import de.lmu.ifi.dbs.elki.logging.statistics.StringStatistic; import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag; /** * Hamerly's fast k-means by exploiting the triangle inequality. @@ -63,6 +66,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * </p> * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has KMeansModel * @@ -84,15 +88,22 @@ public class KMeansHamerly<V extends NumberVector> extends AbstractKMeans<V, KMe private static final String KEY = KMeansHamerly.class.getName(); /** + * Flag whether to compute the final variance statistic. + */ + private boolean varstat = false; + + /** * Constructor. * * @param distanceFunction distance function * @param k k parameter * @param maxiter Maxiter parameter * @param initializer Initialization method + * @param varstat Compute the variance statistic */ - public KMeansHamerly(NumberVectorDistanceFunction<? super V> distanceFunction, int k, int maxiter, KMeansInitialization<? super V> initializer) { + public KMeansHamerly(NumberVectorDistanceFunction<? super V> distanceFunction, int k, int maxiter, KMeansInitialization<? super V> initializer, boolean varstat) { super(distanceFunction, k, maxiter, initializer); + this.varstat = varstat; } @Override @@ -102,7 +113,7 @@ public class KMeansHamerly<V extends NumberVector> extends AbstractKMeans<V, KMe } // Choose initial means if(LOG.isStatistics()) { - LOG.statistics(new StringStatistic(KEY + ".initializer", initializer.toString())); + LOG.statistics(new StringStatistic(KEY + ".initialization", initializer.toString())); } List<Vector> means = initializer.chooseInitialMeans(database, relation, k, getDistanceFunction(), Vector.FACTORY); // Setup cluster assignment store @@ -124,7 +135,7 @@ public class KMeansHamerly<V extends NumberVector> extends AbstractKMeans<V, KMe double[] sep = new double[k]; IndefiniteProgress prog = LOG.isVerbose() ? new IndefiniteProgress("K-Means iteration", LOG) : null; - LongStatistic varstat = LOG.isStatistics() ? new LongStatistic(KEY + ".reassignments") : null; + LongStatistic rstat = LOG.isStatistics() ? new LongStatistic(KEY + ".reassignments") : null; int iteration = 0; for(; maxiter <= 0 || iteration < maxiter; iteration++) { LOG.incrementProcessed(prog); @@ -136,9 +147,9 @@ public class KMeansHamerly<V extends NumberVector> extends AbstractKMeans<V, KMe recomputeSeperation(means, sep); changed = assignToNearestCluster(relation, means, sums, clusters, assignment, sep, upper, lower); } - if(varstat != null) { - varstat.setLong(changed); - LOG.statistics(varstat); + if(rstat != null) { + rstat.setLong(changed); + LOG.statistics(rstat); } // Stop if no cluster assignment changed. if(changed == 0) { @@ -167,6 +178,7 @@ public class KMeansHamerly<V extends NumberVector> extends AbstractKMeans<V, KMe lower.destroy(); // Wrap result + double totalvariance = 0.; Clustering<KMeansModel> result = new Clustering<>("k-Means Clustering", "kmeans-clustering"); for(int i = 0; i < clusters.size(); i++) { DBIDs ids = clusters.get(i); @@ -178,9 +190,13 @@ public class KMeansHamerly<V extends NumberVector> extends AbstractKMeans<V, KMe for(DBIDIter it = ids.iter(); it.valid(); it.advance()) { varsum += distanceFunction.distance(mean, relation.get(it)); } + totalvariance += varsum; KMeansModel model = new KMeansModel(mean, varsum); result.addToplevelCluster(new Cluster<>(ids, model)); } + if(LOG.isStatistics() && varstat) { + LOG.statistics(new DoubleStatistic(this.getClass().getName() + ".variance-sum", totalvariance)); + } return result; } @@ -389,6 +405,16 @@ public class KMeansHamerly<V extends NumberVector> extends AbstractKMeans<V, KMe * @apiviz.exclude */ public static class Parameterizer<V extends NumberVector> extends AbstractKMeans.Parameterizer<V> { + /** + * Flag to compute the final clustering variance statistic. + */ + public static final OptionID VARSTAT_ID = new OptionID("kmeans.varstat", "Compute the final clustering variance statistic. Needs an additional full pass over the data set."); + + /** + * Compute the final variance statisic. + */ + protected boolean varstat = false; + @Override protected Logging getLogger() { return LOG; @@ -406,8 +432,17 @@ public class KMeansHamerly<V extends NumberVector> extends AbstractKMeans<V, KMe } @Override + protected void makeOptions(Parameterization config) { + super.makeOptions(config); + Flag varF = new Flag(VARSTAT_ID); + if(config.grab(varF)) { + varstat = varF.isTrue(); + } + } + + @Override protected KMeansHamerly<V> makeInstance() { - return new KMeansHamerly<>(distanceFunction, k, maxiter, initializer); + return new KMeansHamerly<>(distanceFunction, k, maxiter, initializer, varstat); } } } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansHybridLloydMacQueen.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansHybridLloydMacQueen.java index cd025b03..476f95f2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansHybridLloydMacQueen.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansHybridLloydMacQueen.java @@ -52,6 +52,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; * processing and Lloyd-Style batch steps. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.has KMeansModel * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansLloyd.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansLloyd.java index d8b69f54..c32f22c1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansLloyd.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansLloyd.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.logging.statistics.DoubleStatistic; import de.lmu.ifi.dbs.elki.logging.statistics.LongStatistic; import de.lmu.ifi.dbs.elki.logging.statistics.StringStatistic; import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; import de.lmu.ifi.dbs.elki.utilities.documentation.Title; @@ -53,15 +54,16 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; /** * The standard k-means algorithm, using Lloyd-style bulk iterations. * + * Reference: * <p> - * Reference:<br /> - * S. Lloyd<br/> + * S. Lloyd:<br/> * Least squares quantization in PCM<br/> * IEEE Transactions on Information Theory 28 (2)<br/> * previously published as Bell Telephone Laboratories Paper * </p> * * @author Arthur Zimek + * @since 0.5.0 * * @apiviz.landmark * @apiviz.has KMeansModel @@ -74,6 +76,8 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; title = "Least squares quantization in PCM", // booktitle = "IEEE Transactions on Information Theory 28 (2): 129–137.", // url = "http://dx.doi.org/10.1109/TIT.1982.1056489") +@Alias({ "de.lmu.ifi.dbs.elki.algorithm.clustering.KMeans", // +"de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeans" }) public class KMeansLloyd<V extends NumberVector> extends AbstractKMeans<V, KMeansModel> { /** * The logger for this class. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansMacQueen.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansMacQueen.java index 176fa311..4f22497d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansMacQueen.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansMacQueen.java @@ -58,14 +58,16 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * convergence, although MacQueen likely only meant to do a single pass over the * data. * + * Reference: * <p> - * Reference:<br /> - * J. MacQueen: Some Methods for Classification and Analysis of Multivariate - * Observations. <br /> + * J. MacQueen:<br /> + * Some Methods for Classification and Analysis of Multivariate Observations. + * <br /> * In 5th Berkeley Symp. Math. Statist. Prob., Vol. 1, 1967, pp 281-297. * </p> * * @author Erich Schubert + * @since 0.5.0 * @apiviz.has KMeansModel * * @param <V> vector type to use diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansSort.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansSort.java new file mode 100644 index 00000000..c119c4ec --- /dev/null +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMeansSort.java @@ -0,0 +1,284 @@ +package de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.initialization.KMeansInitialization; +import de.lmu.ifi.dbs.elki.data.Cluster; +import de.lmu.ifi.dbs.elki.data.Clustering; +import de.lmu.ifi.dbs.elki.data.NumberVector; +import de.lmu.ifi.dbs.elki.data.model.KMeansModel; +import de.lmu.ifi.dbs.elki.database.Database; +import de.lmu.ifi.dbs.elki.database.datastore.DataStoreFactory; +import de.lmu.ifi.dbs.elki.database.datastore.DataStoreUtil; +import de.lmu.ifi.dbs.elki.database.datastore.WritableIntegerDataStore; +import de.lmu.ifi.dbs.elki.database.ids.DBIDIter; +import de.lmu.ifi.dbs.elki.database.ids.DBIDUtil; +import de.lmu.ifi.dbs.elki.database.ids.DBIDs; +import de.lmu.ifi.dbs.elki.database.ids.ModifiableDBIDs; +import de.lmu.ifi.dbs.elki.database.relation.Relation; +import de.lmu.ifi.dbs.elki.distance.distancefunction.NumberVectorDistanceFunction; +import de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction; +import de.lmu.ifi.dbs.elki.logging.Logging; +import de.lmu.ifi.dbs.elki.logging.progress.IndefiniteProgress; +import de.lmu.ifi.dbs.elki.logging.statistics.DoubleStatistic; +import de.lmu.ifi.dbs.elki.logging.statistics.LongStatistic; +import de.lmu.ifi.dbs.elki.logging.statistics.StringStatistic; +import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; +import de.lmu.ifi.dbs.elki.utilities.datastructures.arrays.DoubleIntegerArrayQuickSort; +import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; +import de.lmu.ifi.dbs.elki.utilities.documentation.Title; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; + +/** + * Sort-Means: Accelerated k-means by exploiting the triangle inequality and + * pairwise distances of means to prune candidate means (with sorting). + * + * Reference: + * <p> + * S. J. Phillips<br /> + * Acceleration of k-means and related clustering algorithms<br /> + * Proc. 4th Int. Workshop on Algorithm Engineering and Experiments (ALENEX + * 2002) + * </p> + * + * @author Erich Schubert + * @since 0.7.1 + * + * @apiviz.has KMeansModel + * + * @param <V> vector datatype + */ +@Title("Sort-Means") +@Reference(authors = "S. J. Phillips", // +title = "Acceleration of k-means and related clustering algorithms", // +booktitle = "Proc. 4th Int. Workshop on Algorithm Engineering and Experiments (ALENEX 2002)", // +url = "http://dx.doi.org/10.1007/3-540-45643-0_13") +public class KMeansSort<V extends NumberVector> extends AbstractKMeans<V, KMeansModel> { + /** + * The logger for this class. + */ + private static final Logging LOG = Logging.getLogger(KMeansSort.class); + + /** + * Key for statistics logging. + */ + private static final String KEY = KMeansSort.class.getName(); + + /** + * Constructor. + * + * @param distanceFunction distance function + * @param k k parameter + * @param maxiter Maxiter parameter + * @param initializer Initialization method + */ + public KMeansSort(NumberVectorDistanceFunction<? super V> distanceFunction, int k, int maxiter, KMeansInitialization<? super V> initializer) { + super(distanceFunction, k, maxiter, initializer); + } + + @Override + public Clustering<KMeansModel> run(Database database, Relation<V> relation) { + if(relation.size() <= 0) { + return new Clustering<>("k-Means Clustering", "kmeans-clustering"); + } + // Choose initial means + if(LOG.isStatistics()) { + LOG.statistics(new StringStatistic(KEY + ".initialization", initializer.toString())); + } + List<Vector> means = initializer.chooseInitialMeans(database, relation, k, getDistanceFunction(), Vector.FACTORY); + // Setup cluster assignment store + List<ModifiableDBIDs> clusters = new ArrayList<>(); + for(int i = 0; i < k; i++) { + clusters.add(DBIDUtil.newHashSet((int) (relation.size() * 2. / k))); + } + WritableIntegerDataStore assignment = DataStoreUtil.makeIntegerStorage(relation.getDBIDs(), DataStoreFactory.HINT_TEMP | DataStoreFactory.HINT_HOT, -1); + double[] varsum = new double[k]; + + // Cluster distances + double[][] cdist = new double[k][k]; + int[][] cnum = new int[k][k - 1]; + + IndefiniteProgress prog = LOG.isVerbose() ? new IndefiniteProgress("K-Means iteration", LOG) : null; + DoubleStatistic varstat = LOG.isStatistics() ? new DoubleStatistic(this.getClass().getName() + ".variance-sum") : null; + LongStatistic diststat = LOG.isStatistics() ? new LongStatistic(KEY + ".distance-computations") : null; + int iteration = 0; + for(; maxiter <= 0 || iteration < maxiter; iteration++) { + LOG.incrementProcessed(prog); + recomputeSeperation(means, cdist, cnum, diststat); + boolean changed = assignToNearestCluster(relation, means, clusters, assignment, varsum, cdist, cnum, diststat); + logVarstat(varstat, varsum); + if(LOG.isStatistics()) { + LOG.statistics(diststat); + } + // Stop if no cluster assignment changed. + if(!changed) { + break; + } + // Recompute means. + means = means(clusters, means, relation); + } + LOG.setCompleted(prog); + if(LOG.isStatistics()) { + LOG.statistics(new LongStatistic(KEY + ".iterations", iteration)); + } + + // Wrap result + Clustering<KMeansModel> result = new Clustering<>("k-Means Clustering", "kmeans-clustering"); + for(int i = 0; i < clusters.size(); i++) { + DBIDs ids = clusters.get(i); + if(ids.size() == 0) { + continue; + } + KMeansModel model = new KMeansModel(means.get(i), varsum[i]); + result.addToplevelCluster(new Cluster<>(ids, model)); + } + return result; + } + + /** + * Recompute the separation of cluster means. + * + * @param means Means + * @param cdist Center-to-Center distances + * @param cnum Center numbers + * @param diststat Distance counting statistic + */ + private void recomputeSeperation(List<Vector> means, double[][] cdist, int[][] cnum, LongStatistic diststat) { + final int k = means.size(); + for(int i = 1; i < k; i++) { + Vector mi = means.get(i); + for(int j = 0; j < i; j++) { + double d = distanceFunction.distance(mi, means.get(j)); + cdist[i][j] = d; + cdist[j][i] = d; + } + } + double[] buf = new double[k - 1]; + for(int i = 0; i < k; i++) { + System.arraycopy(cdist[i], 0, buf, 0, i); + System.arraycopy(cdist[i], i + 1, buf, i, k - i - 1); + for(int j = 0; j < buf.length; j++) { + cnum[i][j] = j < i ? j : (j + 1); + } + DoubleIntegerArrayQuickSort.sort(buf, cnum[i], k - 1); + } + if(diststat != null) { + diststat.increment((k * (k - 1)) >> 1); + } + } + + /** + * Reassign objects, but only if their bounds indicate it is necessary to do + * so. + * + * @param relation Data + * @param means Current means + * @param clusters Current clusters + * @param assignment Cluster assignment + * @param varsum Variance sum counter + * @param cdist Centroid distances + * @param cnum Centroid nearest neighbors + * @param diststat Distance statistics + * @return true when the object was reassigned + */ + private boolean assignToNearestCluster(Relation<V> relation, List<Vector> means, List<ModifiableDBIDs> clusters, WritableIntegerDataStore assignment, double[] varsum, double[][] cdist, int[][] cnum, LongStatistic diststat) { + assert (k == means.size()); + long dists = 0; + boolean changed = false; + // Reset all clusters + Arrays.fill(varsum, 0.); + for(ModifiableDBIDs cluster : clusters) { + cluster.clear(); + } + final NumberVectorDistanceFunction<?> df = getDistanceFunction(); + double mult = (df instanceof SquaredEuclideanDistanceFunction) ? 4 : 2; + for(DBIDIter iditer = relation.iterDBIDs(); iditer.valid(); iditer.advance()) { + final int cur = assignment.intValue(iditer), ini = cur >= 0 ? cur : 0; + // Distance to current mean: + V fv = relation.get(iditer); + double mindist = df.distance(fv, means.get(ini)); + ++dists; + final double threshold = mult * mindist; + int minIndex = ini; + for(int i : cnum[ini]) { + if(cdist[minIndex][i] >= threshold) { // Sort pruning + break; // All following can only be worse. + } + double dist = df.distance(fv, means.get(i)); + ++dists; + if(dist < mindist) { + minIndex = i; + mindist = dist; + } + } + varsum[minIndex] += mindist; + clusters.get(minIndex).add(iditer); + changed |= assignment.putInt(iditer, minIndex) != minIndex; + } + // Increment distance computations counter. + if(diststat != null) { + diststat.increment(dists); + } + return changed; + } + + @Override + protected Logging getLogger() { + return LOG; + } + + /** + * Parameterization class. + * + * @author Erich Schubert + * + * @apiviz.exclude + */ + public static class Parameterizer<V extends NumberVector> extends AbstractKMeans.Parameterizer<V> { + @Override + protected Logging getLogger() { + return LOG; + } + + @Override + protected void getParameterDistanceFunction(Parameterization config) { + super.getParameterDistanceFunction(config); + if(distanceFunction instanceof SquaredEuclideanDistanceFunction) { + return; // Proper choice. + } + if(distanceFunction != null && !distanceFunction.isMetric()) { + LOG.warning("Compare k-means requires a metric distance, and k-means should only be used with squared Euclidean distance!"); + } + } + + @Override + protected KMeansSort<V> makeInstance() { + return new KMeansSort<>(distanceFunction, k, maxiter, initializer); + } + } +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMediansLloyd.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMediansLloyd.java index 6d8b5874..7e4b4524 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMediansLloyd.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMediansLloyd.java @@ -60,6 +60,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * </p> * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.has MeanModel * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMedoidsEM.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMedoidsEM.java index 567d6753..cc06a4d5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMedoidsEM.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMedoidsEM.java @@ -72,6 +72,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * (this variation is likely not worth publishing on its own). * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.has MedoidModel * @apiviz.composedOf KMedoidsInitialization diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMedoidsPAM.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMedoidsPAM.java index fc3bdd5f..4d45eb3d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMedoidsPAM.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/KMedoidsPAM.java @@ -77,6 +77,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.has MedoidModel * @apiviz.composedOf KMedoidsInitialization diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/SingleAssignmentKMeans.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/SingleAssignmentKMeans.java index 5fa88a33..b4413904 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/SingleAssignmentKMeans.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/SingleAssignmentKMeans.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * Pseudo-k-Means variations, that assigns each object to the nearest center. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.has KMeansModel * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/XMeans.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/XMeans.java index d354327b..75a87daa 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/XMeans.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/XMeans.java @@ -77,6 +77,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * * @author Tibor Goldschwendt * @author Erich Schubert + * @since 0.7.0 * * @param <V> Vector type * @param <M> Model type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/AbstractKMeansInitialization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/AbstractKMeansInitialization.java index 723c86cc..72f9a887 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/AbstractKMeansInitialization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/AbstractKMeansInitialization.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * Abstract base class for common k-means initializations. * * @author Erich Schubert + * @since 0.3 * * @param <V> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestPointsInitialMeans.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestPointsInitialMeans.java index 4fa0d004..a686f345 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestPointsInitialMeans.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestPointsInitialMeans.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.database.query.distance.DistanceQuery; import de.lmu.ifi.dbs.elki.database.relation.Relation; import de.lmu.ifi.dbs.elki.distance.distancefunction.NumberVectorDistanceFunction; import de.lmu.ifi.dbs.elki.math.random.RandomFactory; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag; @@ -52,9 +53,11 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag; * times will be more likely to return the same local minima. * * @author Erich Schubert + * @since 0.6.0 * * @param <O> Object type for kMedoids and kMedians */ +@Alias("de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.FarthestPointsInitialMeans") public class FarthestPointsInitialMeans<O> extends AbstractKMeansInitialization<NumberVector> implements KMedoidsInitialization<O> { /** * Discard the first vector. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestSumPointsInitialMeans.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestSumPointsInitialMeans.java index 9cceb4f2..9f223dac 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestSumPointsInitialMeans.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FarthestSumPointsInitialMeans.java @@ -49,6 +49,7 @@ import de.lmu.ifi.dbs.elki.math.random.RandomFactory; * times will be more likely to return the same local minima. * * @author Erich Schubert + * @since 0.6.0 * * @param <O> Object type for kmedoids and kmedians */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FirstKInitialMeans.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FirstKInitialMeans.java index beab423e..210994e5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FirstKInitialMeans.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/FirstKInitialMeans.java @@ -34,15 +34,18 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDs; import de.lmu.ifi.dbs.elki.database.query.distance.DistanceQuery; import de.lmu.ifi.dbs.elki.database.relation.Relation; import de.lmu.ifi.dbs.elki.distance.distancefunction.NumberVectorDistanceFunction; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; /** * Initialize K-means by using the first k objects as initial means. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type for KMedoids */ +@Alias("de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.FirstKInitialMeans") public class FirstKInitialMeans<O> implements KMeansInitialization<NumberVector>, KMedoidsInitialization<O> { /** * Constructor. @@ -84,4 +87,4 @@ public class FirstKInitialMeans<O> implements KMeansInitialization<NumberVector> return new FirstKInitialMeans<>(); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/KMeansInitialization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/KMeansInitialization.java index 55ffb65e..c1cd71a0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/KMeansInitialization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/KMeansInitialization.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.NumberVectorDistanceFunctio * Interface for initializing K-Means * * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/KMeansPlusPlusInitialMeans.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/KMeansPlusPlusInitialMeans.java index c1518d18..11bfef59 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/KMeansPlusPlusInitialMeans.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/KMeansPlusPlusInitialMeans.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; import de.lmu.ifi.dbs.elki.distance.distancefunction.NumberVectorDistanceFunction; import de.lmu.ifi.dbs.elki.logging.LoggingUtil; import de.lmu.ifi.dbs.elki.math.random.RandomFactory; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; @@ -56,6 +57,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * </p> * * @author Erich Schubert + * @since 0.5.0 * * @param <O> Vector type */ @@ -63,6 +65,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; title = "k-means++: the advantages of careful seeding", // booktitle = "Proc. of the Eighteenth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2007", // url = "http://dx.doi.org/10.1145/1283383.1283494") +@Alias("de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.KMeansPlusPlusInitialMeans") public class KMeansPlusPlusInitialMeans<O> extends AbstractKMeansInitialization<NumberVector> implements KMedoidsInitialization<O> { /** * Constructor. @@ -232,4 +235,4 @@ public class KMeansPlusPlusInitialMeans<O> extends AbstractKMeansInitialization< return new KMeansPlusPlusInitialMeans<>(rnd); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/KMedoidsInitialization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/KMedoidsInitialization.java index 0ae3723e..2dc11c52 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/KMedoidsInitialization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/KMedoidsInitialization.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.query.distance.DistanceQuery; * this initialization will only return members of the original data set. * * @author Erich Schubert + * @since 0.5.0 * * @param <V> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/PAMInitialMeans.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/PAMInitialMeans.java index 396d79e6..ea11330e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/PAMInitialMeans.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/PAMInitialMeans.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.PrimitiveDistanceFunction; import de.lmu.ifi.dbs.elki.logging.Logging; import de.lmu.ifi.dbs.elki.logging.progress.FiniteProgress; import de.lmu.ifi.dbs.elki.math.MathUtil; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; @@ -57,12 +58,14 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.5.0 * * @param <O> Object type for KMedoids initialization */ @Reference(title = "Clustering my means of Medoids", // authors = "Kaufman, L. and Rousseeuw, P.J.", // booktitle = "Statistical Data Analysis Based on the L_1–Norm and Related Methods") +@Alias("de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.PAMInitialMeans") public class PAMInitialMeans<O> implements KMeansInitialization<NumberVector>, KMedoidsInitialization<O> { /** * Class logger. @@ -78,6 +81,9 @@ public class PAMInitialMeans<O> implements KMeansInitialization<NumberVector>, K @Override public <T extends NumberVector, V extends NumberVector> List<V> chooseInitialMeans(Database database, Relation<T> relation, int k, NumberVectorDistanceFunction<? super T> distanceFunction, NumberVector.Factory<V> factory) { + if(relation.size() < k) { + throw new AbortException("Database has less than k objects."); + } // Ugly cast; but better than code duplication. @SuppressWarnings("unchecked") Relation<O> rel = (Relation<O>) relation; @@ -97,38 +103,33 @@ public class PAMInitialMeans<O> implements KMeansInitialization<NumberVector>, K public DBIDs chooseInitialMedoids(int k, DBIDs ids, DistanceQuery<? super O> distQ) { ArrayModifiableDBIDs medids = DBIDUtil.newArray(k); DBIDVar bestid = DBIDUtil.newVar(); - WritableDoubleDataStore mindist = null; + // We need three temporary storage arrays: + WritableDoubleDataStore mindist, bestd, tempd; + mindist = DataStoreUtil.makeDoubleStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_TEMP); + bestd = DataStoreUtil.makeDoubleStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_TEMP); + tempd = DataStoreUtil.makeDoubleStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_TEMP); // First mean is chosen by having the smallest distance sum to all others. { double best = Double.POSITIVE_INFINITY; - WritableDoubleDataStore newd = null; FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("Choosing initial mean", ids.size(), LOG) : null; for(DBIDIter iter = ids.iter(); iter.valid(); iter.advance()) { - if(newd == null) { - newd = DataStoreUtil.makeDoubleStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_TEMP); - } - int sum = 0; + double sum = 0, d; for(DBIDIter iter2 = ids.iter(); iter2.valid(); iter2.advance()) { - double d = distQ.distance(iter, iter2); - sum += d; - newd.putDouble(iter2, d); + sum += d = distQ.distance(iter, iter2); + tempd.putDouble(iter2, d); } if(sum < best) { best = sum; bestid.set(iter); - if(mindist != null) { - mindist.destroy(); - } - mindist = newd; - newd = null; + // Swap mindist and newd: + WritableDoubleDataStore temp = mindist; + mindist = tempd; + tempd = temp; } LOG.incrementProcessed(prog); } LOG.ensureCompleted(prog); - if(newd != null) { - newd.destroy(); - } medids.add(bestid); } assert(mindist != null); @@ -138,44 +139,40 @@ public class PAMInitialMeans<O> implements KMeansInitialization<NumberVector>, K LOG.incrementProcessed(prog); // First one was just chosen. for(int i = 1; i < k; i++) { double best = Double.POSITIVE_INFINITY; - WritableDoubleDataStore bestd = null, newd = null; + bestid.unset(); for(DBIDIter iter = ids.iter(); iter.valid(); iter.advance()) { if(medids.contains(iter)) { continue; } - if(newd == null) { - newd = DataStoreUtil.makeDoubleStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_TEMP); - } - double sum = 0.; + double sum = 0., v; for(DBIDIter iter2 = ids.iter(); iter2.valid(); iter2.advance()) { - double v = MathUtil.min(distQ.distance(iter, iter2), mindist.doubleValue(iter2)); - sum += v; - newd.put(iter2, v); + sum += v = MathUtil.min(distQ.distance(iter, iter2), mindist.doubleValue(iter2)); + tempd.put(iter2, v); } if(sum < best) { best = sum; bestid.set(iter); - if(bestd != null) { - bestd.destroy(); - } - bestd = newd; - newd = null; + // Swap bestd and newd: + WritableDoubleDataStore temp = bestd; + bestd = tempd; + tempd = temp; } } - if(bestd == null) { + if(!bestid.isSet()) { throw new AbortException("No median found that improves the criterion function?!? Too many infinite distances."); } medids.add(bestid); - if(newd != null) { - newd.destroy(); - } - mindist.destroy(); - mindist = bestd; + // Swap bestd and mindist: + WritableDoubleDataStore temp = bestd; + bestd = mindist; + mindist = temp; LOG.incrementProcessed(prog); } LOG.ensureCompleted(prog); mindist.destroy(); + bestd.destroy(); + tempd.destroy(); return medids; } @@ -192,4 +189,4 @@ public class PAMInitialMeans<O> implements KMeansInitialization<NumberVector>, K return new PAMInitialMeans<>(); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/PredefinedInitialMeans.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/PredefinedInitialMeans.java index ca8a612a..b01651b8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/PredefinedInitialMeans.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/PredefinedInitialMeans.java @@ -38,12 +38,13 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.VectorListParameter; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleArrayListParameter; /** * Run k-means with prespecified initial means. * * @author Erich Schubert + * @since 0.7.0 */ public class PredefinedInitialMeans extends AbstractKMeansInitialization<NumberVector> { /** @@ -147,9 +148,12 @@ public class PredefinedInitialMeans extends AbstractKMeansInitialization<NumberV @Override protected void makeOptions(Parameterization config) { super.makeOptions(config); - VectorListParameter meansP = new VectorListParameter(INITIAL_MEANS); + DoubleArrayListParameter meansP = new DoubleArrayListParameter(INITIAL_MEANS); if(config.grab(meansP)) { - initialMeans = meansP.getValue(); + initialMeans = new ArrayList<>(meansP.getValue().size()); + for(double[] v : meansP.getValue()) { + initialMeans.add(new Vector(v)); + } } } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyChosenInitialMeans.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyChosenInitialMeans.java index b6cfad8d..bb03b278 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyChosenInitialMeans.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyChosenInitialMeans.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.database.query.distance.DistanceQuery; import de.lmu.ifi.dbs.elki.database.relation.Relation; import de.lmu.ifi.dbs.elki.distance.distancefunction.NumberVectorDistanceFunction; import de.lmu.ifi.dbs.elki.math.random.RandomFactory; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; /** @@ -51,12 +52,14 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * available in Biometrics). * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Vector type */ @Reference(authors = "E. W. Forgy", // title = "Cluster analysis of multivariate data: efficiency versus interpretability of classifications", // booktitle = "Biometrics 21(3)") +@Alias("de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.RandomlyChosenInitialMeans") public class RandomlyChosenInitialMeans<O> extends AbstractKMeansInitialization<NumberVector> implements KMedoidsInitialization<O> { /** * Constructor. @@ -95,4 +98,4 @@ public class RandomlyChosenInitialMeans<O> extends AbstractKMeansInitialization< return new RandomlyChosenInitialMeans<>(rnd); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyGeneratedInitialMeans.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyGeneratedInitialMeans.java index bc2181e8..30d1b00f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyGeneratedInitialMeans.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/RandomlyGeneratedInitialMeans.java @@ -33,13 +33,16 @@ import de.lmu.ifi.dbs.elki.database.relation.RelationUtil; import de.lmu.ifi.dbs.elki.distance.distancefunction.NumberVectorDistanceFunction; import de.lmu.ifi.dbs.elki.math.MathUtil; import de.lmu.ifi.dbs.elki.math.random.RandomFactory; +import de.lmu.ifi.dbs.elki.utilities.Alias; /** * Initialize k-means by generating random vectors (within the data sets value * range). * * @author Erich Schubert + * @since 0.5.0 */ +@Alias("de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.RandomlyGeneratedInitialMeans") public class RandomlyGeneratedInitialMeans extends AbstractKMeansInitialization<NumberVector> { /** * Constructor. @@ -84,4 +87,4 @@ public class RandomlyGeneratedInitialMeans extends AbstractKMeansInitialization< return new RandomlyGeneratedInitialMeans(rnd); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/SampleKMeansInitialization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/SampleKMeansInitialization.java index ac7f7f27..f5ed00f1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/SampleKMeansInitialization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/initialization/SampleKMeansInitialization.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.NumberVectorDistanceFunctio import de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanDistanceFunction; import de.lmu.ifi.dbs.elki.logging.LoggingUtil; import de.lmu.ifi.dbs.elki.math.random.RandomFactory; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ChainedParameterization; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; @@ -53,9 +54,11 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Initialize k-means by running k-means on a sample of the data set only. * * @author Erich Schubert + * @since 0.6.0 * * @param <V> Vector type */ +@Alias("de.lmu.ifi.dbs.elki.algorithm.clustering.kmeans.SampleKMeansInitialization") public class SampleKMeansInitialization<V extends NumberVector> extends AbstractKMeansInitialization<V> { /** * Variant of kMeans to use for initialization. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/parallel/KMeansProcessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/parallel/KMeansProcessor.java index c0e34f12..f2b9db1f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/parallel/KMeansProcessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/parallel/KMeansProcessor.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.parallel.processor.Processor; * Parallel k-means implementation. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has Instance */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/parallel/ParallelLloydKMeans.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/parallel/ParallelLloydKMeans.java index a10d45ae..e214581a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/parallel/ParallelLloydKMeans.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/parallel/ParallelLloydKMeans.java @@ -51,6 +51,7 @@ import de.lmu.ifi.dbs.elki.parallel.ParallelExecutor; * Parallel implementation of k-Means clustering. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has KMeansProcessor * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/AbstractKMeansQualityMeasure.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/AbstractKMeansQualityMeasure.java index 721b74b6..cc4c00ea 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/AbstractKMeansQualityMeasure.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/AbstractKMeansQualityMeasure.java @@ -65,6 +65,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * * @author Tibor Goldschwendt * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "D. Pelleg, A. Moore", // booktitle = "X-means: Extending K-means with Efficient Estimation on the Number of Clusters", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/AkaikeInformationCriterion.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/AkaikeInformationCriterion.java index e1e72b51..aafd6173 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/AkaikeInformationCriterion.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/AkaikeInformationCriterion.java @@ -51,6 +51,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * * @author Tibor Goldschwendt * @author Erich Schubert + * @since 0.2 */ @Reference(authors = "H. Akaike", // title = "On entropy maximization principle", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/BayesianInformationCriterion.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/BayesianInformationCriterion.java index 8b21753d..22ad56d9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/BayesianInformationCriterion.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/BayesianInformationCriterion.java @@ -52,6 +52,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * * @author Tibor Goldschwendt * @author Erich Schubert + * @since 0.6.0 */ @Reference(authors = "G. Schwarz", // title = "Estimating the dimension of a model", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/BayesianInformationCriterionZhao.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/BayesianInformationCriterionZhao.java index 755d7137..6a18269a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/BayesianInformationCriterionZhao.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/BayesianInformationCriterionZhao.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * * @author Tibor Goldschwendt * @author Erich Schubert + * @since 0.2 */ @Reference(authors = "Q. Zhao, M. Xu, P. Fränti", // title = "Knee Point Detection on Bayesian Information Criterion", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/KMeansQualityMeasure.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/KMeansQualityMeasure.java index bd0f12a1..100c2dfc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/KMeansQualityMeasure.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/KMeansQualityMeasure.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.NumberVectorDistanceFunctio * Important note: some measures are ascending, others are descending! * * @author Erich Schubert + * @since 0.2 * * @param <O> Input Object restriction type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/WithinClusterMeanDistanceQualityMeasure.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/WithinClusterMeanDistanceQualityMeasure.java index cd7a4d14..e7069ac0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/WithinClusterMeanDistanceQualityMeasure.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/WithinClusterMeanDistanceQualityMeasure.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.NumberVectorDistanceFunctio * The average of all average pairwise distances in a cluster. * * @author Stephan Baier + * @since 0.6.0 */ public class WithinClusterMeanDistanceQualityMeasure implements KMeansQualityMeasure<NumberVector> { @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/WithinClusterVarianceQualityMeasure.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/WithinClusterVarianceQualityMeasure.java index 09017413..fbd04dbd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/WithinClusterVarianceQualityMeasure.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/kmeans/quality/WithinClusterVarianceQualityMeasure.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.NumberVectorDistanceFunctio * * @author Stephan Baier * @author Erich Schubert + * @since 0.6.0 */ public class WithinClusterVarianceQualityMeasure extends AbstractKMeansQualityMeasure<NumberVector> { @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/meta/ExternalClustering.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/meta/ExternalClustering.java index ef8045a9..634eb057 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/meta/ExternalClustering.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/meta/ExternalClustering.java @@ -79,6 +79,7 @@ import gnu.trove.map.hash.TIntObjectHashMap; * considered noise clusters. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf CSVReaderFormat * @apiviz.has Clustering diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/onedimensional/KNNKernelDensityMinimaClustering.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/onedimensional/KNNKernelDensityMinimaClustering.java index 71167a90..4b2d5b8a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/onedimensional/KNNKernelDensityMinimaClustering.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/onedimensional/KNNKernelDensityMinimaClustering.java @@ -58,6 +58,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * performing kernel density estimation. * * @author Erich Schubert + * @since 0.6.0 */ public class KNNKernelDensityMinimaClustering<V extends NumberVector> extends AbstractAlgorithm<Clustering<ClusterModel>> implements ClusteringAlgorithm<Clustering<ClusterModel>> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/AbstractOPTICS.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/AbstractOPTICS.java index da4c94f1..da0a6dc3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/AbstractOPTICS.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/AbstractOPTICS.java @@ -53,6 +53,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * * @author Elke Achtert * @author Erich Schubert + * @since 0.7.0 * * @param <O> the type of DatabaseObjects handled by the algorithm */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/ClusterOrder.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/ClusterOrder.java index 93a24407..dc50b086 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/ClusterOrder.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/ClusterOrder.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.result.OrderingResult; * Class to store the result of an ordering clustering algorithm such as OPTICS. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/CorrelationClusterOrder.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/CorrelationClusterOrder.java index 6b94e358..d8bdf5a8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/CorrelationClusterOrder.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/CorrelationClusterOrder.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; * * @author Elke Achtert * @author Erich Schubert + * @since 0.7.0 */ public class CorrelationClusterOrder extends ClusterOrder { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/DeLiClu.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/DeLiClu.java index e2017f85..27737f60 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/DeLiClu.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/DeLiClu.java @@ -80,6 +80,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Elke Achtert + * @since 0.7.0 * @param <NV> the type of NumberVector handled by this Algorithm */ @Title("DeliClu: Density-Based Hierarchical Clustering") diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/FastOPTICS.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/FastOPTICS.java index 9ec79b29..5df5712b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/FastOPTICS.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/FastOPTICS.java @@ -73,6 +73,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * * @author Johannes Schneider * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf RandomProjectedNeighborsAndDensities */ @@ -158,7 +159,7 @@ public class FastOPTICS<V extends NumberVector> extends AbstractAlgorithm<Cluste neighs = index.getNeighs(); // get neighbors of points // compute ordering as for OPTICS - FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("OPTICS clustering.", ids.size(), LOG) : null; + FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("FastOPTICS clustering", ids.size(), LOG) : null; processed = DBIDUtil.newHashSet(ids.size()); order = new ClusterOrder(ids, "FastOPTICS Cluster Order", "fast-optics"); for(DBIDIter it = ids.iter(); it.valid(); it.advance()) { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/GeneralizedOPTICS.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/GeneralizedOPTICS.java index 771d59e8..5b47ec16 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/GeneralizedOPTICS.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/GeneralizedOPTICS.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.QuickSelect; * distances, and serves as a base for several other algorithms (HiCO, HiSC). * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf Instance * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSHeap.java index cb1265eb..a7d7b3f7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSHeap.java @@ -58,6 +58,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * * @author Elke Achtert * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf Instance * @@ -69,8 +70,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; title = "OPTICS: Ordering Points to Identify the Clustering Structure", // booktitle = "Proc. ACM SIGMOD Int. Conf. on Management of Data (SIGMOD '99)", // url = "http://dx.doi.org/10.1145/304181.304187") -@Alias({ "OPTICS", "de.lmu.ifi.dbs.elki.algorithm.clustering.OPTICS", // -"de.lmu.ifi.dbs.elki.algorithm.clustering.optics.OPTICS" }) +@Alias("de.lmu.ifi.dbs.elki.algorithm.clustering.OPTICS") public class OPTICSHeap<O> extends AbstractOPTICS<O> { /** * The logger for this class. @@ -213,4 +213,4 @@ public class OPTICSHeap<O> extends AbstractOPTICS<O> { return new OPTICSHeap<>(distanceFunction, epsilon, minpts); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSHeapEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSHeapEntry.java index 89e6ebb1..0b181442 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSHeapEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSHeapEntry.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDUtil; * Entry in the priority heap. * * @author Elke Achtert + * @since 0.2 * * @apiviz.exclude */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSList.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSList.java index 34d822cc..313bba79 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSList.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSList.java @@ -65,6 +65,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * * @author Elke Achtert * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf OPTICSList.Instance * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSTypeAlgorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSTypeAlgorithm.java index 695ef8fd..9b9cde62 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSTypeAlgorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSTypeAlgorithm.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.Database; * Interface for OPTICS type algorithms, that can be analyzed by OPTICS Xi etc. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has ClusterOrder */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSXi.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSXi.java index 087876dc..7ce0bba1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSXi.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/optics/OPTICSXi.java @@ -66,12 +66,13 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag; * This removes a popular type of artifacts. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf OPTICSTypeAlgorithm oneway - «runs» * @apiviz.uses ClusterOrder oneway - «reads» * @apiviz.has SteepAreaResult oneway - «produces» */ -@Alias({ "OPTICSXi", "de.lmu.ifi.dbs.elki.algorithm.clustering.OPTICSXi" }) +@Alias("de.lmu.ifi.dbs.elki.algorithm.clustering.OPTICSXi") public class OPTICSXi extends AbstractAlgorithm<Clustering<OPTICSModel>> implements ClusteringAlgorithm<Clustering<OPTICSModel>> { /** * The logger for this class. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/CLIQUE.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/CLIQUE.java index 86aa3b3f..c8dada62 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/CLIQUE.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/CLIQUE.java @@ -85,6 +85,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; * </p> * * @author Elke Achtert + * @since 0.2 * * @apiviz.has SubspaceModel * @apiviz.has CLIQUESubspace diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/DOC.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/DOC.java index 896519b3..a19ea88a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/DOC.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/DOC.java @@ -77,6 +77,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * </p> * * @author Florian Nuecke + * @since 0.6.0 * * @apiviz.has SubspaceModel * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/DiSH.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/DiSH.java index 1bbd4def..7653246f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/DiSH.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/DiSH.java @@ -95,6 +95,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; * </p> * * @author Elke Achtert + * @since 0.2 * * @apiviz.uses DiSHPreferenceVectorIndex * @apiviz.has SubspaceModel diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/HiSC.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/HiSC.java index 64bde076..088b81d9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/HiSC.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/HiSC.java @@ -69,6 +69,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * </p> * * @author Elke Achtert + * @since 0.3 * * @apiviz.uses HiSCPreferenceVectorIndex * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/P3C.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/P3C.java index 03670579..02e7792c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/P3C.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/P3C.java @@ -93,6 +93,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * * @author Florian Nuecke * @author Erich Schubert + * @since 0.6.0 * * @apiviz.uses EM * @apiviz.has SubspaceModel @@ -363,7 +364,7 @@ public class P3C<V extends NumberVector> extends AbstractAlgorithm<Clustering<Su * @return p-signatures */ private ArrayList<Signature> mergeClusterCores(final int binCount, ArrayList<Signature> signatures) { - MutableProgress mergeProgress = LOG.isVerbose() ? new MutableProgress("Merging signatures.", signatures.size(), LOG) : null; + MutableProgress mergeProgress = LOG.isVerbose() ? new MutableProgress("Merging signatures", signatures.size(), LOG) : null; // Annotate dimensions to 1-signatures for quick stopping. int[] firstdim = new int[signatures.size()]; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/PROCLUS.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/PROCLUS.java index 45cc4c97..dcc84d20 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/PROCLUS.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/PROCLUS.java @@ -88,6 +88,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; * </p> * * @author Elke Achtert + * @since 0.2 * * @apiviz.has SubspaceModel * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/PreDeCon.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/PreDeCon.java index f7533443..9a98396b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/PreDeCon.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/PreDeCon.java @@ -52,6 +52,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Peer Kröger + * @since 0.2 * * @apiviz.has PreDeCon.Settings * @apiviz.composedOf PreDeConNeighborPredicate diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/SUBCLU.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/SUBCLU.java index b8856044..f20064be 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/SUBCLU.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/SUBCLU.java @@ -74,6 +74,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Elke Achtert + * @since 0.2 * * @apiviz.uses DBSCAN * @apiviz.uses DimensionSelectingSubspaceDistanceFunction diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/SubspaceClusteringAlgorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/SubspaceClusteringAlgorithm.java index 453b26dc..e3f97350 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/SubspaceClusteringAlgorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/SubspaceClusteringAlgorithm.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.data.model.SubspaceModel; * {@link SubspaceModel}, that can then be post-processed for outlier detection. * * @author Erich Schubert + * @since 0.4.0 * * @param <M> Model type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/clique/CLIQUEInterval.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/clique/CLIQUEInterval.java index 510f10a8..7305d43f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/clique/CLIQUEInterval.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/clique/CLIQUEInterval.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.FormatUtil; * Represents an interval in a certain dimension of the data space. * * @author Elke Achtert + * @since 0.2 */ public class CLIQUEInterval implements Comparable<CLIQUEInterval> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/clique/CLIQUESubspace.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/clique/CLIQUESubspace.java index cda00f8b..280702cb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/clique/CLIQUESubspace.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/clique/CLIQUESubspace.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; * Represents a subspace of the original data space in the CLIQUE algorithm. * * @author Elke Achtert + * @since 0.2 * * @apiviz.has CoverageComparator * @apiviz.composedOf CLIQUEUnit diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/clique/CLIQUEUnit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/clique/CLIQUEUnit.java index cf96670e..f7b581a7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/clique/CLIQUEUnit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/subspace/clique/CLIQUEUnit.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.database.ids.ModifiableDBIDs; * Represents a unit in the CLIQUE algorithm. * * @author Elke Achtert + * @since 0.2 * * @apiviz.composedOf CLIQUEInterval * @apiviz.composedOf ModifiableDBIDs diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/ByLabelClustering.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/ByLabelClustering.java index 29006f01..d2ba1b38 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/ByLabelClustering.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/ByLabelClustering.java @@ -47,6 +47,7 @@ import de.lmu.ifi.dbs.elki.database.ids.HashSetModifiableDBIDs; import de.lmu.ifi.dbs.elki.database.ids.ModifiableDBIDs; import de.lmu.ifi.dbs.elki.database.relation.Relation; import de.lmu.ifi.dbs.elki.logging.Logging; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; import de.lmu.ifi.dbs.elki.utilities.documentation.Title; import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; @@ -65,16 +66,18 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.PatternParameter; * * If an assignment of an object to multiple clusters is desired, the labels of * the object indicating the clusters need to be separated by blanks and the - * flag {@link #MULTIPLE_ID} needs to be set. + * flag {@link Parameterizer#MULTIPLE_ID} needs to be set. * * TODO: handling of data sets with no labels? * * @author Erich Schubert + * @since 0.2 * * @apiviz.uses de.lmu.ifi.dbs.elki.data.ClassLabel */ @Title("Clustering by label") @Description("Cluster points by a (pre-assigned!) label. For comparing results with a reference clustering.") +@Alias("de.lmu.ifi.dbs.elki.algorithm.clustering.ByLabelClustering") public class ByLabelClustering extends AbstractAlgorithm<Clustering<Model>> implements ClusteringAlgorithm<Clustering<Model>> { /** * The logger for this class. @@ -82,24 +85,12 @@ public class ByLabelClustering extends AbstractAlgorithm<Clustering<Model>> impl private static final Logging LOG = Logging.getLogger(ByLabelClustering.class); /** - * Flag to indicate that multiple cluster assignment is possible. If an - * assignment to multiple clusters is desired, the labels indicating the - * clusters need to be separated by blanks. - */ - public static final OptionID MULTIPLE_ID = new OptionID("bylabelclustering.multiple", "Flag to indicate that only subspaces with large coverage " + "(i.e. the fraction of the database that is covered by the dense units) " + "are selected, the rest will be pruned."); - - /** - * Pattern to recognize noise clusters by. - */ - public static final OptionID NOISE_ID = new OptionID("bylabelclustering.noise", "Pattern to recognize noise classes by their label."); - - /** - * Holds the value of {@link #MULTIPLE_ID}. + * Allow multiple cluster assignment. */ private boolean multiple; /** - * Holds the value of {@link #NOISE_ID}. + * Pattern to recognize noise clusters by. */ private Pattern noisepattern = null; @@ -248,8 +239,26 @@ public class ByLabelClustering extends AbstractAlgorithm<Clustering<Model>> impl * @apiviz.exclude */ public static class Parameterizer extends AbstractParameterizer { + /** + * Flag to indicate that multiple cluster assignment is possible. If an + * assignment to multiple clusters is desired, the labels indicating the + * clusters need to be separated by blanks. + */ + public static final OptionID MULTIPLE_ID = new OptionID("bylabelclustering.multiple", "Flag to indicate that only subspaces with large coverage " + "(i.e. the fraction of the database that is covered by the dense units) " + "are selected, the rest will be pruned."); + + /** + * Parameter to specify the pattern to recognize noise clusters by. + */ + public static final OptionID NOISE_ID = new OptionID("bylabelclustering.noise", "Pattern to recognize noise classes by their label."); + + /** + * Allow multiple cluster assignment. + */ protected boolean multiple; + /** + * Pattern to recognize noise clusters by. + */ protected Pattern noisepat; @Override @@ -272,4 +281,4 @@ public class ByLabelClustering extends AbstractAlgorithm<Clustering<Model>> impl return new ByLabelClustering(multiple, noisepat); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/ByLabelHierarchicalClustering.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/ByLabelHierarchicalClustering.java index e246c4e6..d48efe68 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/ByLabelHierarchicalClustering.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/ByLabelHierarchicalClustering.java @@ -47,6 +47,7 @@ import de.lmu.ifi.dbs.elki.database.ids.HashSetModifiableDBIDs; import de.lmu.ifi.dbs.elki.database.ids.ModifiableDBIDs; import de.lmu.ifi.dbs.elki.database.relation.Relation; import de.lmu.ifi.dbs.elki.logging.Logging; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; import de.lmu.ifi.dbs.elki.utilities.documentation.Title; @@ -64,11 +65,13 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * TODO: Noise handling (e.g. allow the user to specify a noise label pattern?) * * @author Erich Schubert + * @since 0.2 * * @apiviz.uses de.lmu.ifi.dbs.elki.data.ClassLabel */ @Title("Hierarchical clustering by label") @Description("Cluster points by a (pre-assigned!) label. For comparing results with a reference clustering.") +@Alias("de.lmu.ifi.dbs.elki.algorithm.clustering.ByLabelHierarchicalClustering") public class ByLabelHierarchicalClustering extends AbstractAlgorithm<Clustering<Model>> implements ClusteringAlgorithm<Clustering<Model>> { /** * The logger for this class. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/ByLabelOrAllInOneClustering.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/ByLabelOrAllInOneClustering.java index 12af74ba..7de4c4f0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/ByLabelOrAllInOneClustering.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/ByLabelOrAllInOneClustering.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * "all-in-one" clustering. * * @author Erich Schubert + * @since 0.2 */ public class ByLabelOrAllInOneClustering extends ByLabelClustering { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/ByModelClustering.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/ByModelClustering.java index 9832ea4a..0583ceb5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/ByModelClustering.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/ByModelClustering.java @@ -56,6 +56,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.PatternParameter; * reference result / golden standard used by the generator). * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.uses Model */ @@ -68,12 +69,7 @@ public class ByModelClustering extends AbstractAlgorithm<Clustering<Model>> impl private static final Logging LOG = Logging.getLogger(ByModelClustering.class); /** - * Pattern to recognize noise clusters with - */ - public static final OptionID NOISE_ID = new OptionID("bymodel.noise", "Pattern to recognize noise models by their label."); - - /** - * Holds the value of {@link #NOISE_ID}. + * Pattern to recognize noise clusters with. */ private Pattern noisepattern = null; @@ -144,6 +140,14 @@ public class ByModelClustering extends AbstractAlgorithm<Clustering<Model>> impl * @apiviz.exclude */ public static class Parameterizer extends AbstractParameterizer { + /** + * Parameter to specify the pattern to recognize noise clusters with. + */ + public static final OptionID NOISE_ID = new OptionID("bymodel.noise", "Pattern to recognize noise models by their label."); + + /** + * Pattern to recognize noise clusters with + */ protected Pattern noisepat; @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/TrivialAllInOne.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/TrivialAllInOne.java index 64c103c3..188db3e9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/TrivialAllInOne.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/TrivialAllInOne.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.data.type.TypeUtil; import de.lmu.ifi.dbs.elki.database.ids.DBIDs; import de.lmu.ifi.dbs.elki.database.relation.Relation; import de.lmu.ifi.dbs.elki.logging.Logging; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; import de.lmu.ifi.dbs.elki.utilities.documentation.Title; @@ -44,9 +45,11 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * Useful for evaluation and testing. * * @author Erich Schubert + * @since 0.2 */ @Title("Trivial all-in-one clustering") @Description("Returns a 'tivial' clustering which just considers all points to be one big cluster.") +@Alias("de.lmu.ifi.dbs.elki.algorithm.clustering.TrivialAllInOne") public class TrivialAllInOne extends AbstractAlgorithm<Clustering<Model>> implements ClusteringAlgorithm<Clustering<Model>> { /** * The logger for this class. @@ -77,4 +80,4 @@ public class TrivialAllInOne extends AbstractAlgorithm<Clustering<Model>> implem protected Logging getLogger() { return LOG; } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/TrivialAllNoise.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/TrivialAllNoise.java index db4cb8dd..4db4dfed 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/TrivialAllNoise.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/trivial/TrivialAllNoise.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.data.type.TypeUtil; import de.lmu.ifi.dbs.elki.database.ids.DBIDs; import de.lmu.ifi.dbs.elki.database.relation.Relation; import de.lmu.ifi.dbs.elki.logging.Logging; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; import de.lmu.ifi.dbs.elki.utilities.documentation.Title; @@ -43,9 +44,11 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * Useful for evaluation and testing. * * @author Erich Schubert + * @since 0.2 */ @Title("Trivial all-noise clustering") @Description("Returns a 'trivial' clustering which just considers all points as noise points.") +@Alias("de.lmu.ifi.dbs.elki.algorithm.clustering.TrivialAllNoise") public class TrivialAllNoise extends AbstractAlgorithm<Clustering<Model>> implements ClusteringAlgorithm<Clustering<Model>> { /** * The logger for this class. @@ -76,4 +79,4 @@ public class TrivialAllNoise extends AbstractAlgorithm<Clustering<Model>> implem protected Logging getLogger() { return LOG; } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/CKMeans.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/CKMeans.java index 14915807..3d095cbd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/CKMeans.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/CKMeans.java @@ -57,6 +57,7 @@ import de.lmu.ifi.dbs.elki.workflow.AlgorithmStep; * however, is constant. * * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "S. D. Lee, B. Kao, R. Cheng", // title = "Reducing UK-means to K-means", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/CenterOfMassMetaClustering.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/CenterOfMassMetaClustering.java index 1187ff30..961e7fc2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/CenterOfMassMetaClustering.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/CenterOfMassMetaClustering.java @@ -66,6 +66,7 @@ import de.lmu.ifi.dbs.elki.workflow.AlgorithmStep; * </p> * * @author Erich Schubert + * @since 0.7.0 * * @param <C> Clustering result type (inherited from inner algorithm) */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/FDBSCAN.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/FDBSCAN.java index 47f3e6bb..4c177463 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/FDBSCAN.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/FDBSCAN.java @@ -52,6 +52,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * </p> * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf FDBSCANNeighborPredicate */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/FDBSCANNeighborPredicate.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/FDBSCANNeighborPredicate.java index a51ec92a..8fc3bd03 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/FDBSCANNeighborPredicate.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/FDBSCANNeighborPredicate.java @@ -76,6 +76,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * * @author Alexander Koos * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf Instance */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/RepresentativeUncertainClustering.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/RepresentativeUncertainClustering.java index da377ea1..c1ee8ed8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/RepresentativeUncertainClustering.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/RepresentativeUncertainClustering.java @@ -104,6 +104,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.DoubleObjPair; * * @author Alexander Koos * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has RepresentativenessEvaluation */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/UKMeans.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/UKMeans.java index fc602d1f..14aee8aa 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/UKMeans.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/clustering/uncertain/UKMeans.java @@ -76,6 +76,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * </p> * * @author Klaus Arthur Schmidt + * @since 0.7.0 */ @Reference(authors = "M. Chau, R. Cheng, B. Kao, J. Ng", // title = "Uncertain data mining: An example in clustering location data", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/APRIORI.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/APRIORI.java index 64cfa509..3555e307 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/APRIORI.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/APRIORI.java @@ -23,9 +23,6 @@ package de.lmu.ifi.dbs.elki.algorithm.itemsetmining; along with this program. If not, see <http://www.gnu.org/licenses/>. */ -import gnu.trove.iterator.TLongIntIterator; -import gnu.trove.map.hash.TLongIntHashMap; - import java.util.ArrayList; import java.util.Collections; import java.util.Iterator; @@ -46,11 +43,14 @@ import de.lmu.ifi.dbs.elki.logging.Logging; import de.lmu.ifi.dbs.elki.logging.statistics.Duration; import de.lmu.ifi.dbs.elki.logging.statistics.LongStatistic; import de.lmu.ifi.dbs.elki.result.FrequentItemsetsResult; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.BitsUtil; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; import de.lmu.ifi.dbs.elki.utilities.documentation.Title; import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; +import gnu.trove.iterator.TLongIntIterator; +import gnu.trove.map.hash.TLongIntHashMap; /** * The APRIORI algorithm for Mining Association Rules. @@ -72,6 +72,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * * @author Arthur Zimek * @author Erich Schubert + * @since 0.2 * * @apiviz.has Itemset * @apiviz.uses BitVector @@ -82,6 +83,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; title = "Fast Algorithms for Mining Association Rules", // booktitle = "Proc. 20th Int. Conf. on Very Large Data Bases (VLDB '94), Santiago de Chile, Chile 1994", // url = "http://www.vldb.org/conf/1994/P487.PDF") +@Alias("de.lmu.ifi.dbs.elki.algorithm.APRIORI") public class APRIORI extends AbstractFrequentItemsetAlgorithm { /** * The logger for this class. @@ -596,4 +598,4 @@ public class APRIORI extends AbstractFrequentItemsetAlgorithm { return new APRIORI(minsupp, minlength, maxlength); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/AbstractFrequentItemsetAlgorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/AbstractFrequentItemsetAlgorithm.java index 31947c33..4f73d247 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/AbstractFrequentItemsetAlgorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/AbstractFrequentItemsetAlgorithm.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * Abstract base class for frequent itemset mining. * * @author Erich Schubert + * @since 0.7.0 */ public abstract class AbstractFrequentItemsetAlgorithm extends AbstractAlgorithm<FrequentItemsetsResult> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/DenseItemset.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/DenseItemset.java index d77a0915..7896bb00 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/DenseItemset.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/DenseItemset.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.BitsUtil; * APRIORI itemset. * * @author Erich Schubert + * @since 0.7.0 */ public class DenseItemset extends Itemset { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/Eclat.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/Eclat.java index 47f75c54..9e62c5ed 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/Eclat.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/Eclat.java @@ -74,6 +74,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.7.0 */ @Reference(title = "New Algorithms for Fast Discovery of Association Rules", // authors = "M.J. Zaki, S. Parthasarathy, M. Ogihara, and W. Li", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/FPGrowth.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/FPGrowth.java index 5cdde71a..a09bf551 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/FPGrowth.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/FPGrowth.java @@ -75,6 +75,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf FPTree */ @@ -194,7 +195,7 @@ public class FPGrowth extends AbstractFrequentItemsetAlgorithm { */ private int[] countItemSupport(final Relation<BitVector> relation, final int dim) { final int[] counts = new int[dim]; - FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("Finding frequent 1-items.", relation.size(), LOG) : null; + FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("Finding frequent 1-items", relation.size(), LOG) : null; for(DBIDIter iditer = relation.iterDBIDs(); iditer.valid(); iditer.advance()) { SparseFeatureVector<?> bv = relation.get(iditer); // TODO: only count those which satisfy minlength? diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/Itemset.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/Itemset.java index c195a79f..7e6446e7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/Itemset.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/Itemset.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.data.type.VectorFieldTypeInformation; * APRIORI itemset. * * @author Erich Schubert + * @since 0.7.0 */ public abstract class Itemset implements Comparable<Itemset> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/OneItemset.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/OneItemset.java index 9fddd758..63ca1dde 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/OneItemset.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/OneItemset.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * APRIORI itemset. * * @author Erich Schubert + * @since 0.7.0 */ public class OneItemset extends Itemset { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/SmallDenseItemset.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/SmallDenseItemset.java index e1b8ca55..c68c65ab 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/SmallDenseItemset.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/SmallDenseItemset.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.BitsUtil; * APRIORI itemset. * * @author Erich Schubert + * @since 0.7.0 */ public class SmallDenseItemset extends Itemset { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/SparseItemset.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/SparseItemset.java index 87534439..3eada0a6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/SparseItemset.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/itemsetmining/SparseItemset.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * APRIORI itemset. * * @author Erich Schubert + * @since 0.7.0 */ public class SparseItemset extends Itemset { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/COP.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/COP.java index 7f43796b..d2ba2160 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/COP.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/COP.java @@ -83,6 +83,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Erich Schubert + * @since 0.2 * * @param <V> the type of NumberVector handled by this Algorithm */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/DWOF.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/DWOF.java index a3e9e1d2..51ca8848 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/DWOF.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/DWOF.java @@ -90,6 +90,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Omar Yousry + * @since 0.6.0 * * @param <O> the type of DatabaseObjects handled by this Algorithm */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/GaussianModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/GaussianModel.java index 25a776e0..4f6ba095 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/GaussianModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/GaussianModel.java @@ -56,6 +56,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag; * <em>probability density</em> of the assumed distribution. * * @author Lisa Reichert + * @since 0.3 * * @param <V> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/GaussianUniformMixture.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/GaussianUniformMixture.java index cb170573..190bbb55 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/GaussianUniformMixture.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/GaussianUniformMixture.java @@ -74,6 +74,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * </p> * * @author Lisa Reichert + * @since 0.3 * * @param <V> Vector Type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/OPTICSOF.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/OPTICSOF.java index 484736bb..ccde20eb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/OPTICSOF.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/OPTICSOF.java @@ -72,6 +72,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * and Data Mining (PKDD), Prague, Czech Republic * * @author Ahmed Hettab + * @since 0.3 * * @apiviz.has KNNQuery * @apiviz.has RangeQuery diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/OutlierAlgorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/OutlierAlgorithm.java index 6d671cd0..fff0310c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/OutlierAlgorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/OutlierAlgorithm.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; * Generic super interface for outlier detection algorithms. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.excludeSubtypes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/SimpleCOP.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/SimpleCOP.java index 6b8f645d..271d0467 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/SimpleCOP.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/SimpleCOP.java @@ -70,6 +70,8 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Algorithm to compute local correlation outlier probability. * * This is the simpler, original version of COP, as published in + * + * Reference: * <p> * Arthur Zimek<br /> * Correlation Clustering.<br /> @@ -78,10 +80,13 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * which has then been refined to the method published as {@link COP} * * @author Erich Schubert + * @since 0.5.5 * @param <V> the type of NumberVector handled by this Algorithm */ @Title("Simple COP: Correlation Outlier Probability") -@Reference(authors = "Arthur Zimek", title = "Correlation Clustering. PhD thesis, Chapter 18", booktitle = "") +@Reference(authors = "Arthur Zimek", // +title = "Correlation Clustering", // +booktitle = "PhD thesis, Chapter 18") public class SimpleCOP<V extends NumberVector> extends AbstractDistanceBasedAlgorithm<V, OutlierResult> implements OutlierAlgorithm { /** * The logger for this class. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/ABOD.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/ABOD.java index a78f76c9..946c94ad 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/ABOD.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/ABOD.java @@ -75,6 +75,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * * @author Matthias Schubert (Original Code) * @author Erich Schubert (ELKIfication) + * @since 0.2 * * @param <V> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/FastABOD.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/FastABOD.java index 88a606d5..5ff844a5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/FastABOD.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/FastABOD.java @@ -75,6 +75,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * * @author Matthias Schubert (Original Code) * @author Erich Schubert (ELKIfication) + * @since 0.6.0 * * @param <V> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/LBABOD.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/LBABOD.java index 945d3d46..cb0e4114 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/LBABOD.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/anglebased/LBABOD.java @@ -82,6 +82,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * * @author Matthias Schubert (Original Code) * @author Erich Schubert (ELKIfication) + * @since 0.6.0 * * @param <V> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/EMOutlier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/EMOutlier.java index fc33d88f..62f492e3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/EMOutlier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/EMOutlier.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.result.Result; import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; import de.lmu.ifi.dbs.elki.result.outlier.OutlierScoreMeta; import de.lmu.ifi.dbs.elki.result.outlier.ProbabilisticOutlierScore; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; import de.lmu.ifi.dbs.elki.utilities.datastructures.hierarchy.Hierarchy.Iter; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; @@ -57,6 +58,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * object is an outlier. * * @author Lisa Reichert + * @since 0.3 * * @apiviz.has EM * @@ -65,6 +67,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz // TODO: re-use an existing EM when present? @Title("EM Outlier: Outlier Detection based on the generic EM clustering") @Description("The outlier score assigned is based on the highest cluster probability obtained from EM clustering.") +@Alias("de.lmu.ifi.dbs.elki.algorithm.outlier.EMOutlier") public class EMOutlier<V extends NumberVector> extends AbstractAlgorithm<OutlierResult> implements OutlierAlgorithm { /** * The logger for this class. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/KMeansOutlierDetection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/KMeansOutlierDetection.java index 4db56748..b4a7b44c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/KMeansOutlierDetection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/KMeansOutlierDetection.java @@ -67,6 +67,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * publication list</a> for citation information and BibTeX templates). * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has KMeans * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/SilhouetteOutlierDetection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/SilhouetteOutlierDetection.java index 34600968..a4a3d7f1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/SilhouetteOutlierDetection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/clustering/SilhouetteOutlierDetection.java @@ -74,6 +74,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * for citation information and BibTeX templates). * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has ClusteringAlgorithm * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/AbstractDBOutlier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/AbstractDBOutlier.java index 6a7a2922..7d7fc950 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/AbstractDBOutlier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/AbstractDBOutlier.java @@ -53,6 +53,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * </p> * * @author Lisa Reichert + * @since 0.3 * * @param <O> the type of DatabaseObjects handled by this Algorithm */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/DBOutlierDetection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/DBOutlierDetection.java index bee17874..d9e705d8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/DBOutlierDetection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/DBOutlierDetection.java @@ -62,6 +62,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * 3.1. * * @author Lisa Reichert + * @since 0.3 * * @apiviz.has KNNQuery * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/DBOutlierScore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/DBOutlierScore.java index e1775bad..354057a4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/DBOutlierScore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/DBOutlierScore.java @@ -54,6 +54,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * </p> * * @author Lisa Reichert + * @since 0.3 * * @apiviz.has RangeQuery * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/HilOut.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/HilOut.java index c748c832..35fe19e0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/HilOut.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/HilOut.java @@ -85,6 +85,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * * @author Jonathan von Brünken * @author Erich Schubert + * @since 0.5.0 * * @apiviz.composedOf HilbertFeatures * @apiviz.uses HilFeature diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/KNNOutlier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/KNNOutlier.java index 649ea088..41653ac3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/KNNOutlier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/KNNOutlier.java @@ -73,6 +73,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Lisa Reichert + * @since 0.3 * * @apiviz.has KNNQuery * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/KNNWeightOutlier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/KNNWeightOutlier.java index 3aeb6da2..5b92cef5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/KNNWeightOutlier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/KNNWeightOutlier.java @@ -81,6 +81,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Lisa Reichert + * @since 0.3 * * @apiviz.has KNNQuery * @@ -125,7 +126,7 @@ public class KNNWeightOutlier<O> extends AbstractDistanceBasedAlgorithm<O, Outli final DistanceQuery<O> distanceQuery = database.getDistanceQuery(relation, getDistanceFunction()); KNNQuery<O> knnQuery = database.getKNNQuery(distanceQuery, k + 1); // + query point - FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("Compute kNN weights.", relation.size(), LOG) : null; + FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("Compute kNN weights", relation.size(), LOG) : null; DoubleMinMax minmax = new DoubleMinMax(); WritableDoubleDataStore knnw_score = DataStoreUtil.makeDoubleStorage(relation.getDBIDs(), DataStoreFactory.HINT_STATIC); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/LocalIsolationCoefficient.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/LocalIsolationCoefficient.java index 33450eb1..034f6af2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/LocalIsolationCoefficient.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/LocalIsolationCoefficient.java @@ -68,6 +68,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Erich Schubert + * @since 0.3 * * @apiviz.has KNNQuery * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ODIN.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ODIN.java index e249e543..534f2be1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ODIN.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ODIN.java @@ -65,6 +65,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ReferenceBasedOutlierDetection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ReferenceBasedOutlierDetection.java index cf184221..304474a3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ReferenceBasedOutlierDetection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/ReferenceBasedOutlierDetection.java @@ -81,6 +81,7 @@ import de.lmu.ifi.dbs.elki.utilities.referencepoints.ReferencePointsHeuristic; * * @author Lisa Reichert * @author Erich Schubert + * @since 0.3 * * @apiviz.composedOf ReferencePointsHeuristic */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/KNNWeightProcessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/KNNWeightProcessor.java index 60ebcd8b..3de88864 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/KNNWeightProcessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/KNNWeightProcessor.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.parallel.variables.SharedObject; * Needs the k nearest neighbors as input, for example from {@link KNNProcessor} * * @author Erich Schubert + * @since 0.7.0 */ public class KNNWeightProcessor extends AbstractDoubleProcessor { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/ParallelKNNOutlier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/ParallelKNNOutlier.java index 3b4c17f1..96c70b60 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/ParallelKNNOutlier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/ParallelKNNOutlier.java @@ -76,6 +76,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf KNNProcessor * @apiviz.composedOf KDistanceProcessor diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/ParallelKNNWeightOutlier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/ParallelKNNWeightOutlier.java index 571c2038..7f86e48f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/ParallelKNNWeightOutlier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/distance/parallel/ParallelKNNWeightOutlier.java @@ -76,6 +76,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf KNNWeightProcessor * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/intrinsic/IDOS.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/intrinsic/IDOS.java index b462b836..442a96a1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/intrinsic/IDOS.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/intrinsic/IDOS.java @@ -70,6 +70,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p>
*
* @author Jonathan von Brünken
+ * @since 0.7.0 * @author Erich Schubert
*
* @param <O> Object type
diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/intrinsic/IntrinsicDimensionalityOutlier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/intrinsic/IntrinsicDimensionalityOutlier.java index 1b2d25ef..04679930 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/intrinsic/IntrinsicDimensionalityOutlier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/intrinsic/IntrinsicDimensionalityOutlier.java @@ -63,6 +63,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Please see their upcoming publications for an improved solution. * * @author Erich Schubert + * @since 0.3 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/ALOCI.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/ALOCI.java index f7edae0f..e0fefe2d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/ALOCI.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/ALOCI.java @@ -55,6 +55,7 @@ import de.lmu.ifi.dbs.elki.math.random.RandomFactory; import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; import de.lmu.ifi.dbs.elki.result.outlier.OutlierScoreMeta; import de.lmu.ifi.dbs.elki.result.outlier.QuotientOutlierScoreMeta; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; import de.lmu.ifi.dbs.elki.utilities.documentation.Title; @@ -67,27 +68,31 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; /** * Fast Outlier Detection Using the "approximate Local Correlation Integral". - * + * * Outlier detection using multiple epsilon neighborhoods. - * + * * Reference: * <p> - * S. Papadimitriou, H. Kitagawa, P. B. Gibbons and C. Faloutsos:<br /> - * LOCI: Fast Outlier Detection Using the Local Correlation Integral.<br /> - * In: Proc. 19th IEEE Int. Conf. on Data Engineering (ICDE '03), Bangalore, - * India, 2003. + * S. Papadimitriou, H. Kitagawa, P. B. Gibbons and C. Faloutsos: <br /> + * LOCI: Fast Outlier Detection Using the Local Correlation Integral. <br /> + * In: Proc. 19th IEEE Int. Conf. on Data Engineering (ICDE '03) * </p> - * + * * @author Jonathan von Brünken * @author Erich Schubert - * + * @since 0.5.0 + * * @apiviz.composedOf ALOCIQuadTree - * + * * @param <O> Object type */ @Title("LOCI: Fast Outlier Detection Using the Local Correlation Integral") @Description("Algorithm to compute outliers based on the Local Correlation Integral") -@Reference(authors = "S. Papadimitriou, H. Kitagawa, P. B. Gibbons, C. Faloutsos", title = "LOCI: Fast Outlier Detection Using the Local Correlation Integral", booktitle = "Proc. 19th IEEE Int. Conf. on Data Engineering (ICDE '03), Bangalore, India, 2003", url = "http://dx.doi.org/10.1109/ICDE.2003.1260802") +@Reference(authors = "S. Papadimitriou, H. Kitagawa, P. B. Gibbons, C. Faloutsos", // +title = "LOCI: Fast Outlier Detection Using the Local Correlation Integral", // +booktitle = "Proc. 19th IEEE Int. Conf. on Data Engineering (ICDE '03)", // +url = "http://dx.doi.org/10.1109/ICDE.2003.1260802") +@Alias("de.lmu.ifi.dbs.elki.algorithm.outlier.ALOCI") public class ALOCI<O extends NumberVector> extends AbstractAlgorithm<OutlierResult> implements OutlierAlgorithm { /** * The logger for this class. @@ -121,7 +126,7 @@ public class ALOCI<O extends NumberVector> extends AbstractAlgorithm<OutlierResu /** * Constructor. - * + * * @param distanceFunction Distance function * @param nmin Minimum neighborhood size * @param alpha Alpha value @@ -246,10 +251,10 @@ public class ALOCI<O extends NumberVector> extends AbstractAlgorithm<OutlierResu /** * Method for the MDEF calculation - * + * * @param sn Sampling Neighborhood * @param cg Counting Neighborhood - * + * * @return MDEF norm */ private static double calculate_MDEF_norm(Node sn, Node cg) { @@ -294,13 +299,13 @@ public class ALOCI<O extends NumberVector> extends AbstractAlgorithm<OutlierResu /** * Simple quadtree for ALOCI. Not storing the actual objects, just the counts. - * + * * Furthermore, the quadtree can be shifted by a specified vector, wrapping * around min/max - * + * * @author Jonathan von Brünken * @author Erich Schubert - * + * * @apiviz.composedOf Node */ static class ALOCIQuadTree { @@ -326,7 +331,7 @@ public class ALOCI<O extends NumberVector> extends AbstractAlgorithm<OutlierResu /** * Constructor. - * + * * @param min Minimum coordinates * @param max Maximum coordinates * @param shift Tree shift offset @@ -364,7 +369,7 @@ public class ALOCI<O extends NumberVector> extends AbstractAlgorithm<OutlierResu /** * Bulk load the tree - * + * * @param lmin Subtree minimum (unshifted, will be modified) * @param lmax Subtree maximum (unshifted, will be modified) * @param children List of children for current parent @@ -461,7 +466,7 @@ public class ALOCI<O extends NumberVector> extends AbstractAlgorithm<OutlierResu /** * Shift and wrap a single dimension. - * + * * @param obj Object * @param dim Dimension * @param level Level (controls scaling/wraping!) @@ -476,7 +481,7 @@ public class ALOCI<O extends NumberVector> extends AbstractAlgorithm<OutlierResu /** * Find the closest node (of depth tlevel or above, if there is no node at * this depth) for the given vector. - * + * * @param vec Query vector * @param tlevel Target level * @return Node @@ -511,7 +516,7 @@ public class ALOCI<O extends NumberVector> extends AbstractAlgorithm<OutlierResu /** * Node of the ALOCI Quadtree - * + * * @author Erich Schubert */ static class Node { @@ -547,7 +552,7 @@ public class ALOCI<O extends NumberVector> extends AbstractAlgorithm<OutlierResu /** * Constructor. - * + * * @param code Node code * @param center Center vector * @param count Element count @@ -569,7 +574,7 @@ public class ALOCI<O extends NumberVector> extends AbstractAlgorithm<OutlierResu /** * Get level of node. - * + * * @return Level of node */ public int getLevel() { @@ -578,7 +583,7 @@ public class ALOCI<O extends NumberVector> extends AbstractAlgorithm<OutlierResu /** * Get count of subtree - * + * * @return subtree count */ public int getCount() { @@ -587,7 +592,7 @@ public class ALOCI<O extends NumberVector> extends AbstractAlgorithm<OutlierResu /** * Return center vector - * + * * @return center vector */ public Vector getCenter() { @@ -596,7 +601,7 @@ public class ALOCI<O extends NumberVector> extends AbstractAlgorithm<OutlierResu /** * Get sum of squares, recursively - * + * * @param levels Depth to collect * @return Sum of squares */ @@ -613,7 +618,7 @@ public class ALOCI<O extends NumberVector> extends AbstractAlgorithm<OutlierResu /** * Get cubic sum. - * + * * @param levels Level to collect * @return sum of cubes */ @@ -631,9 +636,9 @@ public class ALOCI<O extends NumberVector> extends AbstractAlgorithm<OutlierResu /** * Parameterization class. - * + * * @author Erich Schubert - * + * * @apiviz.exclude */ public static class Parameterizer<O extends NumberVector> extends AbstractParameterizer { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/COF.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/COF.java index 87019ae6..61cb915f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/COF.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/COF.java @@ -67,6 +67,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Erich Schubert + * @since 0.2 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/FlexibleLOF.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/FlexibleLOF.java index e38e8da2..eae6f530 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/FlexibleLOF.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/FlexibleLOF.java @@ -107,6 +107,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; * @author Peer Kröger * @author Erich Schubert * @author Elke Achtert + * @since 0.2 * * @apiviz.has LOFResult oneway - - computes * @apiviz.has KNNQuery diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/INFLO.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/INFLO.java index 1e77cab5..375031f9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/INFLO.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/INFLO.java @@ -49,6 +49,7 @@ import de.lmu.ifi.dbs.elki.math.DoubleMinMax; import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; import de.lmu.ifi.dbs.elki.result.outlier.OutlierScoreMeta; import de.lmu.ifi.dbs.elki.result.outlier.QuotientOutlierScoreMeta; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; import de.lmu.ifi.dbs.elki.utilities.documentation.Title; @@ -72,6 +73,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * * @author Ahmed Hettab * @author Erich Schubert + * @since 0.3 * * @apiviz.has KNNQuery * @@ -83,6 +85,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; title = "Ranking outliers using symmetric neighborhood relationship", // booktitle = "Proc. 10th Pacific-Asia conference on Advances in Knowledge Discovery and Data Mining", // url = "http://dx.doi.org/10.1007/11731139_68") +@Alias("de.lmu.ifi.dbs.elki.algorithm.outlier.INFLO") public class INFLO<O> extends AbstractDistanceBasedAlgorithm<O, OutlierResult> implements OutlierAlgorithm { /** * The logger for this class. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/KDEOS.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/KDEOS.java index 1583ac99..92f0d7a9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/KDEOS.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/KDEOS.java @@ -93,6 +93,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has KNNQuery * @apiviz.has KernelDensityFunction @@ -203,7 +204,7 @@ public class KDEOS<O> extends AbstractDistanceBasedAlgorithm<O, OutlierResult>im densities.put(iter, new double[knum]); } // Distribute densities: - FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("Computing densities.", ids.size(), LOG) : null; + FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("Computing densities", ids.size(), LOG) : null; double iminbw = (minBandwidth > 0.) ? 1. / (minBandwidth * scale) : Double.POSITIVE_INFINITY; for(DBIDIter iter = ids.iter(); iter.valid(); iter.advance()) { KNNList neighbors = knnq.getKNNForDBID(iter, kmax + 1); @@ -269,7 +270,7 @@ public class KDEOS<O> extends AbstractDistanceBasedAlgorithm<O, OutlierResult>im */ protected void computeOutlierScores(KNNQuery<O> knnq, final DBIDs ids, WritableDataStore<double[]> densities, WritableDoubleDataStore kdeos, DoubleMinMax minmax) { final int knum = kmax + 1 - kmin; - FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("Computing KDEOS scores.", ids.size(), LOG) : null; + FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("Computing KDEOS scores", ids.size(), LOG) : null; double[][] scratch = new double[knum][kmax + 5]; MeanVariance mv = new MeanVariance(); @@ -339,32 +340,32 @@ public class KDEOS<O> extends AbstractDistanceBasedAlgorithm<O, OutlierResult>im /** * Parameter to specify the kernel density function. */ - private static final OptionID KERNEL_ID = new OptionID("kdeos.kernel", "Kernel density function to use."); + public static final OptionID KERNEL_ID = new OptionID("kdeos.kernel", "Kernel density function to use."); /** * Parameter to specify the minimum bandwidth. */ - private static final OptionID KERNEL_MIN_ID = new OptionID("kdeos.kernel.minbw", "Minimum bandwidth for kernel density estimation."); + public static final OptionID KERNEL_MIN_ID = new OptionID("kdeos.kernel.minbw", "Minimum bandwidth for kernel density estimation."); /** * Parameter to specify the kernel scaling factor. */ - private static final OptionID KERNEL_SCALE_ID = new OptionID("kdeos.kernel.scale", "Scaling factor for the kernel function."); + public static final OptionID KERNEL_SCALE_ID = new OptionID("kdeos.kernel.scale", "Scaling factor for the kernel function."); /** * Minimum value of k to analyze. */ - private static final OptionID KMIN_ID = new OptionID("kdeos.k.min", "Minimum value of k to analyze."); + public static final OptionID KMIN_ID = new OptionID("kdeos.k.min", "Minimum value of k to analyze."); /** * Maximum value of k to analyze. */ - private static final OptionID KMAX_ID = new OptionID("kdeos.k.max", "Maximum value of k to analyze."); + public static final OptionID KMAX_ID = new OptionID("kdeos.k.max", "Maximum value of k to analyze."); /** * Intrinsic dimensionality. */ - private static final OptionID IDIM_ID = new OptionID("kdeos.idim", "Intrinsic dimensionality of this data set. Use -1 for using the true data dimensionality, but values such as 0-2 often offer better performance."); + public static final OptionID IDIM_ID = new OptionID("kdeos.idim", "Intrinsic dimensionality of this data set. Use -1 for using the true data dimensionality, but values such as 0-2 often offer better performance."); /** * Kernel function to use for density estimation. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LDF.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LDF.java index 056a6ba3..c4067504 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LDF.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LDF.java @@ -54,6 +54,7 @@ import de.lmu.ifi.dbs.elki.math.statistics.kernelfunctions.KernelDensityFunction import de.lmu.ifi.dbs.elki.result.outlier.BasicOutlierScoreMeta; import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; import de.lmu.ifi.dbs.elki.result.outlier.OutlierScoreMeta; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.DatabaseUtil; import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; @@ -77,6 +78,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has KNNQuery * @apiviz.has KernelDensityFunction @@ -87,6 +89,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; title = "Outlier Detection with Kernel Density Functions", // booktitle = "Machine Learning and Data Mining in Pattern Recognition", // url = "http://dx.doi.org/10.1007/978-3-540-73499-4_6") +@Alias("de.lmu.ifi.dbs.elki.algorithm.outlier.LDF") public class LDF<O extends NumberVector> extends AbstractDistanceBasedAlgorithm<O, OutlierResult> implements OutlierAlgorithm { /** * The logger for this class. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LDOF.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LDOF.java index b41af3bd..9dadf0e3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LDOF.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LDOF.java @@ -71,6 +71,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Arthur Zimek + * @since 0.3 * * @apiviz.has KNNQuery * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LOCI.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LOCI.java index 7b332639..f8623bcc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LOCI.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LOCI.java @@ -63,26 +63,33 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; /** * Fast Outlier Detection Using the "Local Correlation Integral". - * + * * Exact implementation only, not aLOCI. See {@link ALOCI}. - * + * * Outlier detection using multiple epsilon neighborhoods. - * + * * This implementation has O(n<sup>3</sup> log n) runtime complexity! - * - * Based on: S. Papadimitriou, H. Kitagawa, P. B. Gibbons and C. Faloutsos: - * LOCI: Fast Outlier Detection Using the Local Correlation Integral. In: Proc. - * 19th IEEE Int. Conf. on Data Engineering (ICDE '03), Bangalore, India, 2003. - * + * + * Reference: + * <p> + * S. Papadimitriou, H. Kitagawa, P. B. Gibbons and C. Faloutsos: <br /> + * LOCI: Fast Outlier Detection Using the Local Correlation Integral. <br /> + * In: Proc. 19th IEEE Int. Conf. on Data Engineering (ICDE '03) + * </p> + * * @author Erich Schubert - * + * @since 0.2 + * * @apiviz.has RangeQuery - * + * * @param <O> Object type */ @Title("LOCI: Fast Outlier Detection Using the Local Correlation Integral") @Description("Algorithm to compute outliers based on the Local Correlation Integral") -@Reference(authors = "S. Papadimitriou, H. Kitagawa, P. B. Gibbons, C. Faloutsos", title = "LOCI: Fast Outlier Detection Using the Local Correlation Integral", booktitle = "Proc. 19th IEEE Int. Conf. on Data Engineering (ICDE '03), Bangalore, India, 2003", url = "http://dx.doi.org/10.1109/ICDE.2003.1260802") +@Reference(authors = "S. Papadimitriou, H. Kitagawa, P. B. Gibbons, C. Faloutsos", // +title = "LOCI: Fast Outlier Detection Using the Local Correlation Integral", // +booktitle = "Proc. 19th IEEE Int. Conf. on Data Engineering (ICDE '03)", // +url = "http://dx.doi.org/10.1109/ICDE.2003.1260802") @Alias({ "de.lmu.ifi.dbs.elki.algorithm.outlier.LOCI" }) public class LOCI<O> extends AbstractDistanceBasedAlgorithm<O, OutlierResult> implements OutlierAlgorithm { /** @@ -91,39 +98,23 @@ public class LOCI<O> extends AbstractDistanceBasedAlgorithm<O, OutlierResult> im private static final Logging LOG = Logging.getLogger(LOCI.class); /** - * Parameter to specify the maximum radius of the neighborhood to be - * considered, must be suitable to the distance function specified. - */ - public static final OptionID RMAX_ID = new OptionID("loci.rmax", "The maximum radius of the neighborhood to be considered."); - - /** - * Parameter to specify the minimum neighborhood size - */ - public static final OptionID NMIN_ID = new OptionID("loci.nmin", "Minimum neighborhood size to be considered."); - - /** - * Parameter to specify the averaging neighborhood scaling. - */ - public static final OptionID ALPHA_ID = new OptionID("loci.alpha", "Scaling factor for averaging neighborhood"); - - /** - * Holds the value of {@link #RMAX_ID}. + * Maximum radius. */ private double rmax; /** - * Holds the value of {@link #NMIN_ID}. + * Minimum neighborhood size. */ - private int nmin; + private int nmin = 0; /** - * Holds the value of {@link #ALPHA_ID}. + * Scaling of averaging neighborhood. */ - private double alpha; + private double alpha = 0.5; /** * Constructor. - * + * * @param distanceFunction Distance function * @param rmax Maximum radius * @param nmin Minimum neighborhood size @@ -138,7 +129,7 @@ public class LOCI<O> extends AbstractDistanceBasedAlgorithm<O, OutlierResult> im /** * Run the algorithm - * + * * @param database Database to process * @param relation Relation to process * @return Outlier result @@ -228,7 +219,7 @@ public class LOCI<O> extends AbstractDistanceBasedAlgorithm<O, OutlierResult> im /** * Preprocessing step: determine the radii of interest for each point. - * + * * @param ids IDs to process * @param rangeQuery Range query * @param interestingDistances Distances of interest @@ -284,7 +275,7 @@ public class LOCI<O> extends AbstractDistanceBasedAlgorithm<O, OutlierResult> im /** * Array of double-int values. - * + * * @author Erich Schubert * * @apiviz.exclude @@ -307,7 +298,7 @@ public class LOCI<O> extends AbstractDistanceBasedAlgorithm<O, OutlierResult> im /** * Constructor. - * + * * @param alloc Initial allocation. */ public DoubleIntArrayList(int alloc) { @@ -318,7 +309,7 @@ public class LOCI<O> extends AbstractDistanceBasedAlgorithm<O, OutlierResult> im /** * Collection size. - * + * * @return Size */ public int size() { @@ -327,7 +318,7 @@ public class LOCI<O> extends AbstractDistanceBasedAlgorithm<O, OutlierResult> im /** * Get the key at the given position. - * + * * @param i Position * @return Key */ @@ -337,7 +328,7 @@ public class LOCI<O> extends AbstractDistanceBasedAlgorithm<O, OutlierResult> im /** * Get the value at the given position. - * + * * @param i Position * @return Value */ @@ -347,7 +338,7 @@ public class LOCI<O> extends AbstractDistanceBasedAlgorithm<O, OutlierResult> im /** * Get the value at the given position. - * + * * @param i Position * @param val New value */ @@ -357,7 +348,7 @@ public class LOCI<O> extends AbstractDistanceBasedAlgorithm<O, OutlierResult> im /** * Append a key-value pair. - * + * * @param key Key to append * @param val Value to append. */ @@ -373,7 +364,7 @@ public class LOCI<O> extends AbstractDistanceBasedAlgorithm<O, OutlierResult> im /** * Find the last position with a smaller or equal key. - * + * * @param search Key * @return Position */ @@ -412,18 +403,43 @@ public class LOCI<O> extends AbstractDistanceBasedAlgorithm<O, OutlierResult> im /** * Parameterization class. - * + * * @author Erich Schubert - * + * * @apiviz.exclude - * + * * @param <O> Object type */ public static class Parameterizer<O> extends AbstractDistanceBasedAlgorithm.Parameterizer<O> { + /** + * Parameter to specify the maximum radius of the neighborhood to be + * considered, must be suitable to the distance function specified. + */ + public static final OptionID RMAX_ID = new OptionID("loci.rmax", "The maximum radius of the neighborhood to be considered."); + + /** + * Parameter to specify the minimum neighborhood size + */ + public static final OptionID NMIN_ID = new OptionID("loci.nmin", "Minimum neighborhood size to be considered."); + + /** + * Parameter to specify the averaging neighborhood scaling. + */ + public static final OptionID ALPHA_ID = new OptionID("loci.alpha", "Scaling factor for averaging neighborhood"); + + /** + * Maximum radius. + */ protected double rmax; + /** + * Minimum neighborhood size. + */ protected int nmin = 0; + /** + * Scaling of averaging neighborhood. + */ protected double alpha = 0.5; @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LOF.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LOF.java index 87b1be8c..52fbeafc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LOF.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LOF.java @@ -87,6 +87,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * * @author Erich Schubert * @author Elke Achtert + * @since 0.2 * * @apiviz.has KNNQuery * @@ -98,7 +99,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; title = "LOF: Identifying Density-Based Local Outliers", // booktitle = "Proc. 2nd ACM SIGMOD Int. Conf. on Management of Data (SIGMOD '00), Dallas, TX, 2000", // url = "http://dx.doi.org/10.1145/342009.335388") -@Alias({ "de.lmu.ifi.dbs.elki.algorithm.outlier.LOF", "LOF" }) +@Alias("de.lmu.ifi.dbs.elki.algorithm.outlier.LOF") public class LOF<O> extends AbstractDistanceBasedAlgorithm<O, OutlierResult> implements OutlierAlgorithm { /** * The logger for this class. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LoOP.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LoOP.java index 48589698..16f46a33 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LoOP.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/LoOP.java @@ -90,6 +90,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; * </ul> * * @author Erich Schubert + * @since 0.3 * * @apiviz.has KNNQuery * @@ -101,7 +102,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; title = "LoOP: Local Outlier Probabilities", // booktitle = "Proceedings of the 18th International Conference on Information and Knowledge Management (CIKM), Hong Kong, China, 2009", // url = "http://dx.doi.org/10.1145/1645953.1646195") -@Alias({ "de.lmu.ifi.dbs.elki.algorithm.outlier.LoOP", "LoOP" }) +@Alias("de.lmu.ifi.dbs.elki.algorithm.outlier.LoOP") public class LoOP<O> extends AbstractAlgorithm<OutlierResult> implements OutlierAlgorithm { /** * The logger for this class. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/OnlineLOF.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/OnlineLOF.java index 715d3c0e..6a9344b3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/OnlineLOF.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/OnlineLOF.java @@ -53,6 +53,7 @@ import de.lmu.ifi.dbs.elki.logging.progress.StepProgress; import de.lmu.ifi.dbs.elki.math.DoubleMinMax; import de.lmu.ifi.dbs.elki.result.outlier.BasicOutlierScoreMeta; import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization; import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; @@ -63,10 +64,12 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; * BUG: this currently does not appear to work. * * @author Elke Achtert + * @since 0.2 * * @apiviz.has FlexibleLOF.LOFResult oneway - - updates */ // TODO: related to publication? +@Alias("de.lmu.ifi.dbs.elki.algorithm.outlier.OnlineLOF") public class OnlineLOF<O> extends FlexibleLOF<O> { /** * The logger for this class. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/SimpleKernelDensityLOF.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/SimpleKernelDensityLOF.java index af32988e..80c41e57 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/SimpleKernelDensityLOF.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/SimpleKernelDensityLOF.java @@ -54,6 +54,7 @@ import de.lmu.ifi.dbs.elki.math.statistics.kernelfunctions.KernelDensityFunction import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; import de.lmu.ifi.dbs.elki.result.outlier.OutlierScoreMeta; import de.lmu.ifi.dbs.elki.result.outlier.QuotientOutlierScoreMeta; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.DatabaseUtil; import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; import de.lmu.ifi.dbs.elki.utilities.optionhandling.constraints.CommonConstraints; @@ -66,12 +67,14 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * estimation instead of the local reachability density. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has KNNQuery * @apiviz.has KernelDensityFunction * * @param <O> the type of objects handled by this Algorithm */ +@Alias("de.lmu.ifi.dbs.elki.algorithm.outlier.SimpleKernelDensityLOF") public class SimpleKernelDensityLOF<O extends NumberVector> extends AbstractDistanceBasedAlgorithm<O, OutlierResult> implements OutlierAlgorithm { /** * The logger for this class. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/SimplifiedLOF.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/SimplifiedLOF.java index 17ebdabf..5705e7aa 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/SimplifiedLOF.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/SimplifiedLOF.java @@ -68,6 +68,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has KNNQuery * @@ -77,7 +78,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; title = "Local Outlier Detection Reconsidered: a Generalized View on Locality with Applications to Spatial, Video, and Network Outlier Detection", // booktitle = "Data Mining and Knowledge Discovery, 28(1): 190–237, 2014.", // url = "http://dx.doi.org/10.1007/s10618-012-0300-z") -@Alias({ "SimplifiedLOF", "outlier.SimplifiedLOF", "de.lmu.ifi.dbs.elki.algorithm.outlier.SimplifiedLOF" }) +@Alias("de.lmu.ifi.dbs.elki.algorithm.outlier.SimpleLOF") public class SimplifiedLOF<O> extends AbstractDistanceBasedAlgorithm<O, OutlierResult> implements OutlierAlgorithm { /** * The logger for this class. @@ -172,7 +173,7 @@ public class SimplifiedLOF<O> extends AbstractDistanceBasedAlgorithm<O, OutlierR * @param lofminmax Minimum and maximum scores */ private void computeSimplifiedLOFs(DBIDs ids, KNNQuery<O> knnq, WritableDoubleDataStore slrds, WritableDoubleDataStore lofs, DoubleMinMax lofminmax) { - FiniteProgress progressLOFs = LOG.isVerbose() ? new FiniteProgress("Simplified LOF scores.", ids.size(), LOG) : null; + FiniteProgress progressLOFs = LOG.isVerbose() ? new FiniteProgress("Simplified LOF scores", ids.size(), LOG) : null; for(DBIDIter iter = ids.iter(); iter.valid(); iter.advance()) { final double lof; final double lrdp = slrds.doubleValue(iter); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/VarianceOfVolume.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/VarianceOfVolume.java index 3dffe213..93f62bea 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/VarianceOfVolume.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/VarianceOfVolume.java @@ -77,6 +77,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has KNNQuery * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/LOFProcessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/LOFProcessor.java index 095a1b5b..c6c7b315 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/LOFProcessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/LOFProcessor.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.parallel.variables.SharedDouble; * Processor for computing the LOF. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has Instance */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/LRDProcessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/LRDProcessor.java index e9c48cbf..c21a45af 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/LRDProcessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/LRDProcessor.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.parallel.variables.SharedDouble; * Processor for the "local reachability density" of LOF. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has Instance */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelLOF.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelLOF.java index 59b69931..04b7f1da 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelLOF.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelLOF.java @@ -71,6 +71,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has LRDProcessor * @apiviz.has LOFProcessor diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelSimplifiedLOF.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelSimplifiedLOF.java index 9be38c34..d57972e3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelSimplifiedLOF.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/ParallelSimplifiedLOF.java @@ -70,6 +70,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has SimplifiedLRDProcessor * @apiviz.has LOFProcessor diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/SimplifiedLRDProcessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/SimplifiedLRDProcessor.java index 0ee9a862..c075c674 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/SimplifiedLRDProcessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/lof/parallel/SimplifiedLRDProcessor.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.parallel.variables.SharedDouble; * Note: we compute 1/lrd, the local reachability distance. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has Instance */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/ExternalDoubleOutlierScore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/ExternalDoubleOutlierScore.java index 2791b800..63226bc9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/ExternalDoubleOutlierScore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/ExternalDoubleOutlierScore.java @@ -73,6 +73,7 @@ import de.lmu.ifi.dbs.elki.utilities.scaling.outlier.OutlierScalingFunction; * score specified with an algorithm-specific prefix. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has ScalingFunction * @apiviz.has File diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/FeatureBagging.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/FeatureBagging.java index 6a7a41f3..1354b5c0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/FeatureBagging.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/FeatureBagging.java @@ -79,6 +79,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; * * @author Erich Schubert * @author Remigius Wojdanowski + * @since 0.4.0 */ @Title("Feature Bagging for Outlier Detection") @Reference(title = "Feature Bagging for Outlier Detection", authors = "A. Lazarevic, V. Kumar", booktitle = "Proc. of the 11th ACM SIGKDD international conference on Knowledge discovery in data mining", url = "http://dx.doi.org/10.1145/1081870.1081891") diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/HiCS.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/HiCS.java index 4dcf83ec..e38dd7aa 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/HiCS.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/HiCS.java @@ -94,6 +94,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * * @author Jan Brusis * @author Erich Schubert + * @since 0.5.0 * * @apiviz.composedOf GoodnessOfFitTest * @apiviz.composedOf OutlierAlgorithm diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/RescaleMetaOutlierAlgorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/RescaleMetaOutlierAlgorithm.java index f6f3fabc..fa940477 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/RescaleMetaOutlierAlgorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/RescaleMetaOutlierAlgorithm.java @@ -56,6 +56,7 @@ import de.lmu.ifi.dbs.elki.workflow.AlgorithmStep; * Scale another outlier score using the given scaling function. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf OutlierAlgorithm */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/SimpleOutlierEnsemble.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/SimpleOutlierEnsemble.java index 591ab776..16d07d05 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/SimpleOutlierEnsemble.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/meta/SimpleOutlierEnsemble.java @@ -64,6 +64,7 @@ import de.lmu.ifi.dbs.elki.workflow.AlgorithmStep; * Simple outlier ensemble method. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.composedOf EnsembleVoting * @apiviz.uses OutlierResult oneway - - reads diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/AbstractDistanceBasedSpatialOutlier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/AbstractDistanceBasedSpatialOutlier.java index 829c9010..3ee1d13e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/AbstractDistanceBasedSpatialOutlier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/AbstractDistanceBasedSpatialOutlier.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Abstract base class for distance-based spatial outlier detection methods. * * @author Ahmed Hettab + * @since 0.4.0 * * @param <N> Object type for neighborhood * @param <O> Non-spatial object type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/AbstractNeighborhoodOutlier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/AbstractNeighborhoodOutlier.java index 2be79793..0fed345b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/AbstractNeighborhoodOutlier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/AbstractNeighborhoodOutlier.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * neighborhood. * * @author Ahmed Hettab + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuGLSBackwardSearchAlgorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuGLSBackwardSearchAlgorithm.java index 70f0eddb..13499720 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuGLSBackwardSearchAlgorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuGLSBackwardSearchAlgorithm.java @@ -79,6 +79,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; * that make the optimization problem convex. * * @author Ahmed Hettab + * @since 0.4.0 * * @param <V> Vector type to use for distances */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuMeanMultipleAttributes.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuMeanMultipleAttributes.java index f0783700..2322205f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuMeanMultipleAttributes.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuMeanMultipleAttributes.java @@ -69,6 +69,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Ahmed Hettab + * @since 0.4.0 * * @param <N> Spatial Vector * @param <O> Attribute Vector diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuMedianAlgorithm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuMedianAlgorithm.java index a5cb7423..cae611b8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuMedianAlgorithm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuMedianAlgorithm.java @@ -65,6 +65,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * Outliers. * * @author Ahmed Hettab + * @since 0.4.0 * * @param <N> Neighborhood type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuMedianMultipleAttributes.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuMedianMultipleAttributes.java index 1093b449..9af83939 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuMedianMultipleAttributes.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuMedianMultipleAttributes.java @@ -70,6 +70,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Ahmed Hettab + * @since 0.4.0 * * @param <N> Spatial Vector * @param <O> Non Spatial Vector diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuMoranScatterplotOutlier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuMoranScatterplotOutlier.java index 5e8a7086..78e7fbd4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuMoranScatterplotOutlier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuMoranScatterplotOutlier.java @@ -67,6 +67,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * upper left or lower right are Spatial Outliers. * * @author Ahmed Hettab + * @since 0.4.0 * * @param <N> Neighborhood type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuRandomWalkEC.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuRandomWalkEC.java index 6892200c..793b6977 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuRandomWalkEC.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuRandomWalkEC.java @@ -75,6 +75,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Ahmed Hettab + * @since 0.4.0 * * @param <P> Spatial Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuScatterplotOutlier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuScatterplotOutlier.java index 16cd6625..b0a31a2c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuScatterplotOutlier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuScatterplotOutlier.java @@ -69,6 +69,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * </p> * * @author Ahmed Hettab + * @since 0.4.0 * * @param <N> Neighborhood object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuZTestOutlier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuZTestOutlier.java index ba93c79c..13f7488d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuZTestOutlier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/CTLuZTestOutlier.java @@ -69,6 +69,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * </p> * * @author Ahmed Hettab + * @since 0.4.0 * * @param <N> Neighborhood type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/SLOM.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/SLOM.java index c18c69e0..ff2a671d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/SLOM.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/SLOM.java @@ -62,6 +62,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * still not be too useful then), which will result in divisions by zero. * * @author Ahmed Hettab + * @since 0.4.0 * * @param <N> the type the spatial neighborhood is defined over * @param <O> the type of objects handled by the algorithm diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/SOF.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/SOF.java index 31083439..32747bf3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/SOF.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/SOF.java @@ -62,6 +62,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * A LOF variation simplified with reachDist(o,p) == dist(o,p). * * @author Ahmed Hettab + * @since 0.4.0 * * @param <N> Neighborhood object type * @param <O> Attribute object type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/TrimmedMeanApproach.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/TrimmedMeanApproach.java index 6581bb82..2e5b305b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/TrimmedMeanApproach.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/TrimmedMeanApproach.java @@ -74,6 +74,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * </p> * * @author Ahmed Hettab + * @since 0.4.0 * @param <N> Neighborhood object type */ @Title("A Trimmed Mean Approach to Finding Spatial Outliers") diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/AbstractPrecomputedNeighborhood.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/AbstractPrecomputedNeighborhood.java index abf42e98..da5c3d5c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/AbstractPrecomputedNeighborhood.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/AbstractPrecomputedNeighborhood.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * Abstract base class for precomputed neighborhoods. * * @author Erich Schubert + * @since 0.4.0 */ public abstract class AbstractPrecomputedNeighborhood implements NeighborSetPredicate { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/ExtendedNeighborhood.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/ExtendedNeighborhood.java index ba37400b..8284ace8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/ExtendedNeighborhood.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/ExtendedNeighborhood.java @@ -49,6 +49,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * neighborhood. * * @author Erich Schubert + * @since 0.4.0 */ public class ExtendedNeighborhood extends AbstractPrecomputedNeighborhood { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/ExternalNeighborhood.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/ExternalNeighborhood.java index 7881633c..4d0dd24a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/ExternalNeighborhood.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/ExternalNeighborhood.java @@ -59,6 +59,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.FileParameter; * A precomputed neighborhood, loaded from an external file. * * @author Erich Schubert + * @since 0.4.0 */ public class ExternalNeighborhood extends AbstractPrecomputedNeighborhood { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/NeighborSetPredicate.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/NeighborSetPredicate.java index d953ece1..9ae428e6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/NeighborSetPredicate.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/NeighborSetPredicate.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.result.Result; * Predicate to obtain the neighbors of a reference object as set. * * @author Erich Schubert + * @since 0.4.0 */ public interface NeighborSetPredicate extends Result { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/PrecomputedKNearestNeighborNeighborhood.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/PrecomputedKNearestNeighborNeighborhood.java index 923cd39d..0a70ae85 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/PrecomputedKNearestNeighborNeighborhood.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/PrecomputedKNearestNeighborNeighborhood.java @@ -49,6 +49,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Neighborhoods based on k nearest neighbors. * * @author Ahmed Hettab + * @since 0.4.0 */ public class PrecomputedKNearestNeighborNeighborhood extends AbstractPrecomputedNeighborhood { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/weighted/LinearWeightedExtendedNeighborhood.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/weighted/LinearWeightedExtendedNeighborhood.java index b45fd3cc..54753e17 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/weighted/LinearWeightedExtendedNeighborhood.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/weighted/LinearWeightedExtendedNeighborhood.java @@ -53,6 +53,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * TODO: make actual weighting parameterizable? * * @author Erich Schubert + * @since 0.4.0 */ public class LinearWeightedExtendedNeighborhood implements WeightedNeighborSetPredicate { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/weighted/UnweightedNeighborhoodAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/weighted/UnweightedNeighborhoodAdapter.java index 5476791d..def719cf 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/weighted/UnweightedNeighborhoodAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/weighted/UnweightedNeighborhoodAdapter.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * weighted neighborhoods. * * @author Erich Schubert + * @since 0.4.0 */ public class UnweightedNeighborhoodAdapter implements WeightedNeighborSetPredicate { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/weighted/WeightedNeighborSetPredicate.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/weighted/WeightedNeighborSetPredicate.java index aeb91741..3e9a301c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/weighted/WeightedNeighborSetPredicate.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/spatial/neighborhood/weighted/WeightedNeighborSetPredicate.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * Neighbor predicate with weight support. * * @author Erich Schubert + * @since 0.4.0 */ public interface WeightedNeighborSetPredicate { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AbstractAggarwalYuOutlier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AbstractAggarwalYuOutlier.java index 54fc9853..63e58864 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AbstractAggarwalYuOutlier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AbstractAggarwalYuOutlier.java @@ -63,6 +63,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.IntIntPair; * * @author Ahmed Hettab * @author Erich Schubert + * @since 0.4.0 * * @param <V> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AggarwalYuEvolutionary.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AggarwalYuEvolutionary.java index 829347dc..e856ce62 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AggarwalYuEvolutionary.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AggarwalYuEvolutionary.java @@ -23,8 +23,6 @@ package de.lmu.ifi.dbs.elki.algorithm.outlier.subspace; along with this program. If not, see <http://www.gnu.org/licenses/>. */ -import gnu.trove.iterator.TIntIterator; -import gnu.trove.list.array.TIntArrayList; import java.util.ArrayList; import java.util.Arrays; @@ -50,6 +48,7 @@ import de.lmu.ifi.dbs.elki.math.random.RandomFactory; import de.lmu.ifi.dbs.elki.result.outlier.InvertedOutlierScoreMeta; import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; import de.lmu.ifi.dbs.elki.result.outlier.OutlierScoreMeta; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.datastructures.heap.Heap; import de.lmu.ifi.dbs.elki.utilities.datastructures.heap.TopBoundedHeap; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; @@ -61,6 +60,8 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; +import gnu.trove.iterator.TIntIterator; +import gnu.trove.list.array.TIntArrayList; /** * Evolutionary variant (EAFOD) of the high-dimensional outlier detection @@ -75,6 +76,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; * * @author Ahmed Hettab * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has EvolutionarySearch oneway - - runs * @apiviz.has Individuum oneway - - obtains @@ -85,6 +87,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; @Title("EAFOD: the evolutionary outlier detection algorithm") @Description("Outlier detection for high dimensional data") @Reference(authors = "C.C. Aggarwal, P. S. Yu", title = "Outlier detection for high dimensional data", booktitle = "Proc. ACM SIGMOD Int. Conf. on Management of Data (SIGMOD 2001), Santa Barbara, CA, 2001", url = "http://dx.doi.org/10.1145/375663.375668") +@Alias("de.lmu.ifi.dbs.elki.algorithm.outlier.AggarwalYuEvolutionary") public class AggarwalYuEvolutionary<V extends NumberVector> extends AbstractAggarwalYuOutlier<V> { /** * The logger for this class. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AggarwalYuNaive.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AggarwalYuNaive.java index e141ad48..3c601dda 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AggarwalYuNaive.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/AggarwalYuNaive.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.math.DoubleMinMax; import de.lmu.ifi.dbs.elki.result.outlier.InvertedOutlierScoreMeta; import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; import de.lmu.ifi.dbs.elki.result.outlier.OutlierScoreMeta; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; import de.lmu.ifi.dbs.elki.utilities.documentation.Title; @@ -64,6 +65,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.IntIntPair; * * @author Ahmed Hettab * @author Erich Schubert + * @since 0.4.0 * * @param <V> Vector type */ @@ -71,6 +73,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.IntIntPair; @Title("BruteForce: Outlier detection for high dimensional data") @Description("Examines all possible sets of k dimensional projections") @Reference(authors = "C.C. Aggarwal, P. S. Yu", title = "Outlier detection for high dimensional data", booktitle = "Proc. ACM SIGMOD Int. Conf. on Management of Data (SIGMOD 2001), Santa Barbara, CA, 2001", url = "http://dx.doi.org/10.1145/375663.375668") +@Alias("de.lmu.ifi.dbs.elki.algorithm.outlier.AggarwalYuNaive") public class AggarwalYuNaive<V extends NumberVector> extends AbstractAggarwalYuOutlier<V> { /** * The logger for this class. @@ -188,4 +191,4 @@ public class AggarwalYuNaive<V extends NumberVector> extends AbstractAggarwalYuO return new AggarwalYuNaive<>(k, phi); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/OUTRES.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/OUTRES.java index 6f7ee1f4..66d8ef5f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/OUTRES.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/OUTRES.java @@ -83,6 +83,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * * @author Viktoria Pleintinger * @author Erich Schubert + * @since 0.5.0 * * @apiviz.composedOf KernelDensityEstimator * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/OutRankS1.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/OutRankS1.java index 54047472..4ba34c10 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/OutRankS1.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/OutRankS1.java @@ -71,6 +71,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Erich Schubert + * @since 0.5.0 */ @Title("OutRank: ranking outliers in high dimensional data") @Description("Ranking outliers in high dimensional data - score 1") diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/SOD.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/SOD.java index db1a969c..8b0ac7c7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/SOD.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/subspace/SOD.java @@ -57,6 +57,7 @@ import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; import de.lmu.ifi.dbs.elki.result.outlier.OutlierScoreMeta; import de.lmu.ifi.dbs.elki.result.textwriter.TextWriteable; import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterStream; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.BitsUtil; import de.lmu.ifi.dbs.elki.utilities.datastructures.heap.Heap; import de.lmu.ifi.dbs.elki.utilities.datastructures.heap.TiedTopBoundedHeap; @@ -85,6 +86,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Arthur Zimek + * @since 0.2 * * @apiviz.has SODModel oneway - - computes * @apiviz.has SharedNearestNeighborSimilarityFunction @@ -94,6 +96,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; @Title("SOD: Subspace outlier degree") @Description("Outlier Detection in Axis-Parallel Subspaces of High Dimensional Data") @Reference(authors = "H.-P. Kriegel, P. Kröger, E. Schubert, A. Zimek", title = "Outlier Detection in Axis-Parallel Subspaces of High Dimensional Data", booktitle = "Proceedings of the 13th Pacific-Asia Conference on Knowledge Discovery and Data Mining (PAKDD), Bangkok, Thailand, 2009", url = "http://dx.doi.org/10.1007/978-3-642-01307-2") +@Alias("de.lmu.ifi.dbs.elki.algorithm.outlier.SOD") public class SOD<V extends NumberVector> extends AbstractAlgorithm<OutlierResult> implements OutlierAlgorithm { /** * The logger for this class. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/ByLabelOutlier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/ByLabelOutlier.java index dfd35c78..6c2fc6c2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/ByLabelOutlier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/ByLabelOutlier.java @@ -53,6 +53,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.PatternParameter; * reference algorithm in comparisons. * * @author Erich Schubert + * @since 0.4.0 */ public class ByLabelOutlier extends AbstractAlgorithm<OutlierResult> implements OutlierAlgorithm { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/TrivialAllOutlier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/TrivialAllOutlier.java index 5ef77e12..3a8d1528 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/TrivialAllOutlier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/TrivialAllOutlier.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.result.outlier.ProbabilisticOutlierScore; * reference algorithm in comparisons. * * @author Erich Schubert + * @since 0.4.0 */ public class TrivialAllOutlier extends AbstractAlgorithm<OutlierResult> implements OutlierAlgorithm { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/TrivialAverageCoordinateOutlier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/TrivialAverageCoordinateOutlier.java index 4fe722a2..06da97e3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/TrivialAverageCoordinateOutlier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/TrivialAverageCoordinateOutlier.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.result.outlier.OutlierScoreMeta; * convert a 1d data set into a score, e.g. in geodata. * * @author Erich Schubert + * @since 0.4.0 */ public class TrivialAverageCoordinateOutlier extends AbstractAlgorithm<OutlierResult> implements OutlierAlgorithm { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/TrivialGeneratedOutlier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/TrivialGeneratedOutlier.java index c837e246..82155c2b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/TrivialGeneratedOutlier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/TrivialGeneratedOutlier.java @@ -64,6 +64,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * generator model information is still available. * * @author Erich Schubert + * @since 0.5.0 */ public class TrivialGeneratedOutlier extends AbstractAlgorithm<OutlierResult> implements OutlierAlgorithm { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/TrivialNoOutlier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/TrivialNoOutlier.java index e25c35f5..d5df4573 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/TrivialNoOutlier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/outlier/trivial/TrivialNoOutlier.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.result.outlier.ProbabilisticOutlierScore; * algorithm in comparisons. * * @author Erich Schubert + * @since 0.4.0 */ public class TrivialNoOutlier extends AbstractAlgorithm<OutlierResult> implements OutlierAlgorithm { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/AddSingleScale.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/AddSingleScale.java index 6f243996..9e15127e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/AddSingleScale.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/AddSingleScale.java @@ -49,6 +49,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleListParamet * FIXME: this should become part of relation metadata. * * @author Erich Schubert + * @since 0.5.0 */ @Description("Setup a scaling so that all dimensions are scaled equally in visualization.") public class AddSingleScale implements Algorithm { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/AveragePrecisionAtK.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/AveragePrecisionAtK.java index a5a9291e..8a31f956 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/AveragePrecisionAtK.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/AveragePrecisionAtK.java @@ -59,6 +59,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * at k, when ranking the objects by distance. * * @author Erich Schubert + * @since 0.5.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/DistanceQuantileSampler.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/DistanceQuantileSampler.java index 5f0ae42a..fe7b98f0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/DistanceQuantileSampler.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/DistanceQuantileSampler.java @@ -58,6 +58,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * algorithms. * * @author Erich Schubert + * @since 0.7.0 * * @param <O> Object type */ @@ -164,6 +165,8 @@ public class DistanceQuantileSampler<O> extends AbstractDistanceBasedAlgorithm<O * @author Erich Schubert * * @param <O> Object type + * + * @apiviz.exclude */ public static class Parameterizer<O> extends AbstractDistanceBasedAlgorithm.Parameterizer<O> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/DistanceStatisticsWithClasses.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/DistanceStatisticsWithClasses.java index 4cc4a35c..bb3808b8 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/DistanceStatisticsWithClasses.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/DistanceStatisticsWithClasses.java @@ -73,6 +73,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * set. * * @author Erich Schubert + * @since 0.2 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/EstimateIntrinsicDimensionality.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/EstimateIntrinsicDimensionality.java index 8bc0cfe8..f78ff82c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/EstimateIntrinsicDimensionality.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/EstimateIntrinsicDimensionality.java @@ -55,6 +55,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Note: this algorithm does not produce a result, but only logs statistics. * * @author Erich Schubert + * @since 0.7.0 * * @param <O> Data type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/EvaluateRankingQuality.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/EvaluateRankingQuality.java index 27c9d1ed..8c1ff8e3 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/EvaluateRankingQuality.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/EvaluateRankingQuality.java @@ -82,6 +82,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * TODO: Add sampling * * @author Erich Schubert + * @since 0.2 * @param <V> Vector type */ @Title("Evaluate Ranking Quality") diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/EvaluateRetrievalPerformance.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/EvaluateRetrievalPerformance.java index 6ca75b0c..ec70970a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/EvaluateRetrievalPerformance.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/EvaluateRetrievalPerformance.java @@ -64,6 +64,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * distance. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.has RetrievalPerformanceResult * @apiviz.composedOf KNNEvaluator diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/HopkinsStatisticClusteringTendency.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/HopkinsStatisticClusteringTendency.java index 7ce4e428..e41b77df 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/HopkinsStatisticClusteringTendency.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/HopkinsStatisticClusteringTendency.java @@ -78,6 +78,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * * @author Lisa Reichert * @author Erich Schubert + * @since 0.7.0 */ // TODO: allow using more than one k @Reference(authors = "B. Hopkins and J. G. Skellam", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/RangeQuerySelectivity.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/RangeQuerySelectivity.java index 5fb7d785..cf6294d0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/RangeQuerySelectivity.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/RangeQuerySelectivity.java @@ -54,6 +54,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * TODO: Add sampling * * @author Erich Schubert + * @since 0.7.0 * @param <V> Vector type */ public class RangeQuerySelectivity<V extends NumberVector> extends AbstractDistanceBasedAlgorithm<V, Result> { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/RankingQualityHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/RankingQualityHistogram.java index bfdf190a..d009628f 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/RankingQualityHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/algorithm/statistics/RankingQualityHistogram.java @@ -65,6 +65,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * TODO: Add sampling * * @author Erich Schubert + * @since 0.2 * @param <O> Object type */ @Title("Ranking Quality Histogram") diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/AbstractApplication.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/AbstractApplication.java index 167b2991..f0ba3652 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/AbstractApplication.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/AbstractApplication.java @@ -30,7 +30,6 @@ import java.util.Properties; import de.lmu.ifi.dbs.elki.logging.Logging; import de.lmu.ifi.dbs.elki.logging.Logging.Level; import de.lmu.ifi.dbs.elki.logging.LoggingConfiguration; -import de.lmu.ifi.dbs.elki.logging.LoggingUtil; import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; import de.lmu.ifi.dbs.elki.utilities.FormatUtil; import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; @@ -41,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionUtil; import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; import de.lmu.ifi.dbs.elki.utilities.optionhandling.UnspecifiedParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.SerializedParameterization; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.TrackParameters; @@ -59,6 +59,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.StringParameter; * * @author Elke Achtert * @author Erich Schubert + * @since 0.2 * * @apiviz.uses LoggingConfiguration oneway * @apiviz.excludeSubtypes @@ -152,7 +153,7 @@ public abstract class AbstractApplication { return; } if(debugP.isDefined()) { - LoggingUtil.parseDebugParameter(debugP); + Parameterizer.parseDebugParameter(debugP); } } catch(Exception e) { @@ -375,6 +376,40 @@ public abstract class AbstractApplication { } return null; } + + /** + * Parse the option string to configure logging. + * + * @param param Parameter to process. + * + * @throws WrongParameterValueException On parsing errors + */ + public static final void parseDebugParameter(StringParameter param) throws WrongParameterValueException { + String[] opts = param.getValue().split(","); + for(String opt : opts) { + try { + String[] chunks = opt.split("="); + if(chunks.length == 1) { + try { + java.util.logging.Level level = Level.parse(chunks[0]); + LoggingConfiguration.setDefaultLevel(level); + } + catch(IllegalArgumentException e) { + LoggingConfiguration.setLevelFor(chunks[0], Level.FINEST.getName()); + } + } + else if(chunks.length == 2) { + LoggingConfiguration.setLevelFor(chunks[0], chunks[1]); + } + else { + throw new WrongParameterValueException(param, param.getValue(), "More than one '=' in debug parameter."); + } + } + catch(IllegalArgumentException e) { + throw (new WrongParameterValueException(param, param.getValue(), "Could not process value.", e)); + } + } + } @Override protected abstract AbstractApplication makeInstance(); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/ClassifierHoldoutEvaluationTask.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/ClassifierHoldoutEvaluationTask.java index c49c42c5..91570cee 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/ClassifierHoldoutEvaluationTask.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/ClassifierHoldoutEvaluationTask.java @@ -83,6 +83,7 @@ import de.lmu.ifi.dbs.elki.workflow.AlgorithmStep; * TODO: add support for predefined test and training pairs! * * @author Erich Schubert + * @since 0.7.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/ConvertToBundleApplication.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/ConvertToBundleApplication.java index ad7d17dc..55057b05 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/ConvertToBundleApplication.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/ConvertToBundleApplication.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Convert an input file to the more efficient ELKI bundle format. * * @author Erich Schubert + * @since 0.5.5 */ public class ConvertToBundleApplication extends AbstractApplication { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/ELKILauncher.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/ELKILauncher.java index 6d23d902..5830a601 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/ELKILauncher.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/ELKILauncher.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.ELKIServiceRegistry; * Class to launch ELKI. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.uses AbstractApplication */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/GeneratorXMLSpec.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/GeneratorXMLSpec.java index 45e97e9f..e6a1b18a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/GeneratorXMLSpec.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/GeneratorXMLSpec.java @@ -54,6 +54,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * Generate a data set based on a specified model (using an XML specification) * * @author Erich Schubert + * @since 0.2 * * @apiviz.composedOf GeneratorXMLDatabaseConnection */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/KDDCLIApplication.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/KDDCLIApplication.java index 7138d7f4..bd5740b5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/KDDCLIApplication.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/KDDCLIApplication.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.workflow.OutputStep; * {@link de.lmu.ifi.dbs.elki.datasource.DatabaseConnection DatabaseConnection}. * * @author Arthur Zimek + * @since 0.3 * * @apiviz.composedOf KDDTask */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/cache/CacheDoubleDistanceInOnDiskMatrix.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/cache/CacheDoubleDistanceInOnDiskMatrix.java index 56b1f377..6994cac9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/cache/CacheDoubleDistanceInOnDiskMatrix.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/cache/CacheDoubleDistanceInOnDiskMatrix.java @@ -49,6 +49,7 @@ import de.lmu.ifi.dbs.elki.workflow.InputStep; * Precompute an on-disk distance matrix, using double precision. * * @author Erich Schubert + * @since 0.2 * * @apiviz.has OnDiskUpperTriangleMatrix * @apiviz.has DistanceFunction diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/cache/CacheDoubleDistanceKNNLists.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/cache/CacheDoubleDistanceKNNLists.java index dc1df9e5..d6cfc429 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/cache/CacheDoubleDistanceKNNLists.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/cache/CacheDoubleDistanceKNNLists.java @@ -56,6 +56,7 @@ import de.lmu.ifi.dbs.elki.workflow.InputStep; * Precompute the k nearest neighbors in a disk cache. * * @author Erich Schubert + * @since 0.2 * * @apiviz.has DistanceFunction * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/cache/CacheDoubleDistanceRangeQueries.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/cache/CacheDoubleDistanceRangeQueries.java index 4ccba594..6b42b27c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/cache/CacheDoubleDistanceRangeQueries.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/cache/CacheDoubleDistanceRangeQueries.java @@ -57,6 +57,7 @@ import de.lmu.ifi.dbs.elki.workflow.InputStep; * Precompute the k nearest neighbors in a disk cache. * * @author Erich Schubert + * @since 0.2 * * @apiviz.has DistanceFunction * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/cache/CacheFloatDistanceInOnDiskMatrix.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/cache/CacheFloatDistanceInOnDiskMatrix.java index f9d7a2c2..a12b13cb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/cache/CacheFloatDistanceInOnDiskMatrix.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/cache/CacheFloatDistanceInOnDiskMatrix.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.workflow.InputStep; * Precompute an on-disk distance matrix, using float precision. * * @author Erich Schubert + * @since 0.2 * * @apiviz.has OnDiskUpperTriangleMatrix * @apiviz.has DistanceFunction diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/experiments/EvaluateIntrinsicDimensionalityEstimators.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/experiments/EvaluateIntrinsicDimensionalityEstimators.java index 27784179..3dea86bc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/experiments/EvaluateIntrinsicDimensionalityEstimators.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/experiments/EvaluateIntrinsicDimensionalityEstimators.java @@ -55,6 +55,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * estimators. * * @author Erich Schubert + * @since 0.7.0 */ public class EvaluateIntrinsicDimensionalityEstimators extends AbstractApplication { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/geo/VisualizeGeodesicDistances.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/geo/VisualizeGeodesicDistances.java index 4ecbe8c3..76776eb0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/geo/VisualizeGeodesicDistances.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/geo/VisualizeGeodesicDistances.java @@ -50,6 +50,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * * @author Niels Dörre * @author Erich Schubert + * @since 0.5.5 */ public class VisualizeGeodesicDistances extends AbstractApplication { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/greedyensemble/ComputeKNNOutlierScores.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/greedyensemble/ComputeKNNOutlierScores.java index 934255b4..d89d535f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/greedyensemble/ComputeKNNOutlierScores.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/greedyensemble/ComputeKNNOutlierScores.java @@ -105,6 +105,7 @@ import de.lmu.ifi.dbs.elki.workflow.InputStep; * </p> * * @author Erich Schubert + * @since 0.5.0 * * @param <O> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/greedyensemble/EvaluatePrecomputedOutlierScores.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/greedyensemble/EvaluatePrecomputedOutlierScores.java index 94abafa1..0107dc64 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/greedyensemble/EvaluatePrecomputedOutlierScores.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/greedyensemble/EvaluatePrecomputedOutlierScores.java @@ -77,6 +77,7 @@ import de.lmu.ifi.dbs.elki.workflow.InputStep; * * @author Erich Schubert * @author Guilherme Oliveira Campos + * @since 0.7.0 */ public class EvaluatePrecomputedOutlierScores extends AbstractApplication { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/greedyensemble/GreedyEnsembleExperiment.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/greedyensemble/GreedyEnsembleExperiment.java index d36da97b..6a614f99 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/greedyensemble/GreedyEnsembleExperiment.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/greedyensemble/GreedyEnsembleExperiment.java @@ -97,6 +97,7 @@ import de.lmu.ifi.dbs.elki.workflow.InputStep; * </p> * * @author Erich Schubert + * @since 0.5.0 */ @Reference(authors = "E. Schubert, R. Wojdanowski, A. Zimek, H.-P. Kriegel", // title = "On Evaluation of Outlier Rankings and Outlier Scores", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/internal/CheckELKIServices.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/internal/CheckELKIServices.java index e18bd633..b0e17e6d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/internal/CheckELKIServices.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/internal/CheckELKIServices.java @@ -58,6 +58,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * implementations. * * @author Erich Schubert + * @since 0.2 * * @apiviz.uses ELKIServiceLoader */ @@ -243,6 +244,7 @@ public class CheckELKIServices { if(parts.length > 1) { StringBuilder buf = new StringBuilder(); buf.append("Class ").append(classname); + buf.append(" in ").append(parent.getCanonicalName()); buf.append(" has the following extraneous aliases:"); for(int i = 1; i < parts.length; i++) { buf.append(' ').append(parts[i]); @@ -261,6 +263,7 @@ public class CheckELKIServices { if(buf == null) { buf = new StringBuilder(); buf.append("Class ").append(classname); + buf.append(" in ").append(parent.getCanonicalName()); buf.append(" is missing the following aliases:"); } buf.append(' ').append(a); @@ -274,6 +277,7 @@ public class CheckELKIServices { buf.append('\n'); } buf.append("Class ").append(classname); + buf.append(" in ").append(parent.getCanonicalName()); buf.append(" has the following extraneous aliases:"); for(String a : aliases) { buf.append(' ').append(a); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/internal/CheckParameterizables.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/internal/CheckParameterizables.java index a278f287..4c106f83 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/internal/CheckParameterizables.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/internal/CheckParameterizables.java @@ -52,6 +52,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * interface. * * @author Erich Schubert + * @since 0.3 * * @apiviz.landmark * @apiviz.uses AbstractParameterizer diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/internal/DocumentParameters.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/internal/DocumentParameters.java index eea3dad6..8325872b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/internal/DocumentParameters.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/internal/DocumentParameters.java @@ -57,6 +57,7 @@ import de.lmu.ifi.dbs.elki.application.AbstractApplication; import de.lmu.ifi.dbs.elki.logging.Logging; import de.lmu.ifi.dbs.elki.logging.Logging.Level; import de.lmu.ifi.dbs.elki.logging.LoggingConfiguration; +import de.lmu.ifi.dbs.elki.math.random.RandomFactory; import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; import de.lmu.ifi.dbs.elki.utilities.ELKIServiceRegistry; import de.lmu.ifi.dbs.elki.utilities.ELKIServiceScanner; @@ -70,6 +71,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.UnParameter import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ClassListParameter; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ClassParameter; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; import de.lmu.ifi.dbs.elki.utilities.xml.HTMLUtil; @@ -78,6 +80,7 @@ import de.lmu.ifi.dbs.elki.utilities.xml.HTMLUtil; * {@link Parameter}s. Used in documentation generation only. * * @author Erich Schubert + * @since 0.2 * * @apiviz.uses Parameter */ @@ -182,7 +185,7 @@ public class DocumentParameters { throw new RuntimeException(e); } try { - PrintStream byclassstream = new PrintStream(new BufferedOutputStream(byclassfo)); + PrintStream byclassstream = new PrintStream(new BufferedOutputStream(byclassfo), false, "UTF-8"); makeByClassOverviewWiki(byclass, new WikiStream(byclassstream)); byclassstream.flush(); byclassstream.close(); @@ -245,7 +248,9 @@ public class DocumentParameters { private static void buildParameterIndex(Map<Class<?>, List<Parameter<?>>> byclass, Map<OptionID, List<Pair<Parameter<?>, Class<?>>>> byopt) { final ArrayList<TrackedParameter> options = new ArrayList<>(); ExecutorService es = Executors.newSingleThreadExecutor(); - for(final Class<?> cls : ELKIServiceRegistry.findAllImplementations(Object.class, false, true)) { + List<Class<?>> objs = ELKIServiceRegistry.findAllImplementations(Object.class, false, true); + Collections.sort(objs, new ELKIServiceScanner.ClassSorter()); + for(final Class<?> cls : objs) { // Doesn't have a proper name? if(cls.getCanonicalName() == null) { continue; @@ -720,9 +725,18 @@ public class DocumentParameters { Element maindl = htmldoc.createElement(HTMLUtil.HTML_DL_TAG); body.appendChild(maindl); - List<OptionID> opts = new ArrayList<>(byopt.keySet()); - Collections.sort(opts, new SortByOption()); + final Comparator<OptionID> osort = new SortByOption(); + final Comparator<Class<?>> csort = new ELKIServiceScanner.ClassSorter(); + Comparator<Pair<Parameter<?>, Class<?>>> psort = new Comparator<Pair<Parameter<?>, Class<?>>>() { + @Override + public int compare(Pair<Parameter<?>, Class<?>> o1, Pair<Parameter<?>, Class<?>> o2) { + int c = osort.compare(o1.first.getOptionID(), o2.first.getOptionID()); + return (c != 0) ? c : csort.compare(o1.second, o2.second); + } + }; + List<OptionID> opts = new ArrayList<>(byopt.keySet()); + Collections.sort(opts, osort); for(OptionID oid : opts) { final Parameter<?> firstopt = byopt.get(oid).get(0).getFirst(); // DT = definition term @@ -787,7 +801,9 @@ public class DocumentParameters { optdd.appendChild(p); } optdd.appendChild(classesul); - for(Pair<Parameter<?>, Class<?>> clinst : byopt.get(oid)) { + List<Pair<Parameter<?>, Class<?>>> plist = byopt.get(oid); + Collections.sort(plist, psort); + for(Pair<Parameter<?>, Class<?>> clinst : plist) { // DT definition term: option name, in TT for typewriter optics Element classli = htmldoc.createElement(HTMLUtil.HTML_LI_TAG); @@ -1020,9 +1036,11 @@ public class DocumentParameters { if(par instanceof ClassParameter<?>) { appendDefaultClassLink(htmldoc, par, p); } + else if(par instanceof RandomParameter && par.getDefaultValue() == RandomFactory.DEFAULT) { + p.appendChild(htmldoc.createTextNode("use global random seed")); + } else { - Object def = par.getDefaultValue(); - p.appendChild(htmldoc.createTextNode(def.toString())); + p.appendChild(htmldoc.createTextNode(par.getDefaultValueAsString())); } optdd.appendChild(p); } @@ -1047,9 +1065,11 @@ public class DocumentParameters { final Class<?> name = ((ClassParameter<?>) par).getDefaultValue(); out.javadocLink(name, null); } + else if(par instanceof RandomParameter && par.getDefaultValue() == RandomFactory.DEFAULT) { + out.print("use global random seed"); + } else { - Object def = par.getDefaultValue(); - out.print(def.toString()); + out.print(par.getDefaultValueAsString()); } out.println(); } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/internal/DocumentReferences.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/internal/DocumentReferences.java index 7d448fca..66f2bda8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/internal/DocumentReferences.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/internal/DocumentReferences.java @@ -60,6 +60,7 @@ import de.lmu.ifi.dbs.elki.utilities.xml.HTMLUtil; * Build a reference documentation for all available parameters. * * @author Erich Schubert + * @since 0.3 * * @apiviz.uses Reference */ @@ -105,7 +106,7 @@ public class DocumentReferences { try { File refwiki = new File(args[1]); FileOutputStream reffow = new FileOutputStream(refwiki); - PrintStream refstreamW = new PrintStream(reffow); + PrintStream refstreamW = new PrintStream(reffow, false, "UTF-8"); documentReferencesWiki(refs, refstreamW); refstreamW.flush(); refstreamW.close(); @@ -330,7 +331,28 @@ public class DocumentReferences { @Override public int compare(Pair<Reference, TreeSet<Object>> p1, Pair<Reference, TreeSet<Object>> p2) { final Object o1 = p1.second.first(), o2 = p2.second.first(); - return COMPARATOR.compare(o1, o2); + int c = COMPARATOR.compare(o1, o2); + if(c == 0) { + Reference r1 = p1.first, r2 = p2.first; + c = compareNull(r1.title(), r2.title()); + c = (c != 0) ? c : compareNull(r1.authors(), r2.authors()); + c = (c != 0) ? c : compareNull(r1.booktitle(), r2.booktitle()); + } + return c; + } + + /** + * Null-tolerant String comparison. + * + * @param s1 First string + * @param s2 Second string + * @return Order + */ + private int compareNull(String s1, String s2) { + return (s1 == s2) ? 0 // + : (s1 == null) ? -1 // + : (s2 == null) ? +1 // + : s1.compareTo(s2); } }); return refs; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/jsmap/JSONBuffer.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/jsmap/JSONBuffer.java index 740f3856..418771c2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/jsmap/JSONBuffer.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/jsmap/JSONBuffer.java @@ -29,6 +29,7 @@ import java.util.Stack; * Helper class to produce JSON output. Try hard to ensure validity of the output. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf StringBuilder * @apiviz.has JSONBuffer.JSONException diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/jsmap/JSONResultHandler.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/jsmap/JSONResultHandler.java index 316c7950..14c0b77f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/jsmap/JSONResultHandler.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/jsmap/JSONResultHandler.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * Handle results by serving them via a web server to mapping applications. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf JSONWebServer */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/jsmap/JSONWebServer.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/jsmap/JSONWebServer.java index e133e3ab..6e216e81 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/application/jsmap/JSONWebServer.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/application/jsmap/JSONWebServer.java @@ -61,6 +61,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * A simple web server to serve data base contents to a JavaScript client. * * @author Erich Schubert + * @since 0.4.0 * * TODO: use Jetty or something similar on the long run. * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/AbstractNumberVector.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/AbstractNumberVector.java index cffa3de9..4a228c0e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/AbstractNumberVector.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/AbstractNumberVector.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.ArrayLikeUtil; * AbstractNumberVector is an abstract implementation of FeatureVector. * * @author Arthur Zimek + * @since 0.2 */ public abstract class AbstractNumberVector implements NumberVector { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/Bit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/Bit.java index 46e85cac..13a39e37 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/Bit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/Bit.java @@ -29,6 +29,7 @@ import java.util.regex.Pattern; * A boolean number type. * * @author Arthur Zimek + * @since 0.2 */ public class Bit extends Number { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/BitVector.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/BitVector.java index 914bd5cc..ef6deeac 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/BitVector.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/BitVector.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Vector using a dense bit set encoding, based on {@code long[]} storage. * * @author Arthur Zimek + * @since 0.2 * * @apiviz.composedOf Bit */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ByteVector.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ByteVector.java index c5e296c6..a77733b1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ByteVector.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ByteVector.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Vector using {@code byte[]} storage. * * @author Erich Schubert + * @since 0.2 */ public class ByteVector extends AbstractNumberVector { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ClassLabel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ClassLabel.java index 03d4743c..7bc2f257 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ClassLabel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ClassLabel.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.data.type.SimpleTypeInformation; * other classes by a classifier. * * @author Arthur Zimek + * @since 0.2 */ public abstract class ClassLabel implements Comparable<ClassLabel> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/Cluster.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/Cluster.java index fd2d1f68..6cd1a286 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/Cluster.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/Cluster.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterStream; * @param <M> Model object type * * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/Clustering.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/Clustering.java index 928ca7e3..f61bf17b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/Clustering.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/Clustering.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.hierarchy.ModifiableHierarch * or getAllClusters(). * * @author Erich Schubert + * @since 0.2 * * @apiviz.composedOf Cluster oneway - n * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/DoubleVector.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/DoubleVector.java index 7c8a7dbc..3824dfbb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/DoubleVector.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/DoubleVector.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Vector type using {@code double[]} storage for real numbers. * * @author Arthur Zimek + * @since 0.2 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ExternalID.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ExternalID.java index 9b5fbd94..e8912070 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ExternalID.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ExternalID.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.data; * External ID objects. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf String */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/FeatureVector.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/FeatureVector.java index e3a74300..e4dc4808 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/FeatureVector.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/FeatureVector.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteBufferSerializer; * actually store numerical features. * * @author Erich Schubert + * @since 0.2 */ public interface FeatureVector<D> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/FloatVector.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/FloatVector.java index 657102c7..4cc3ca21 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/FloatVector.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/FloatVector.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * much memory as {@link DoubleVector}. * * @author Elke Achtert + * @since 0.2 */ public class FloatVector extends AbstractNumberVector { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/HierarchicalClassLabel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/HierarchicalClassLabel.java index 8c911a0f..79640642 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/HierarchicalClassLabel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/HierarchicalClassLabel.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.data.type.SimpleTypeInformation; * of classes. * * @author Arthur Zimek + * @since 0.2 * * @apiviz.composedOf Comparable */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/HyperBoundingBox.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/HyperBoundingBox.java index 903249ca..33de8fd1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/HyperBoundingBox.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/HyperBoundingBox.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.FormatUtil; * HyperBoundingBox represents a hyperrectangle in the multidimensional space. * * @author Elke Achtert + * @since 0.2 */ public class HyperBoundingBox implements SpatialComparable, Externalizable { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/IntegerVector.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/IntegerVector.java index 5d724171..e91b0bd1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/IntegerVector.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/IntegerVector.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Vector type using {@code int[]} storage. * * @author Erich Schubert + * @since 0.2 */ public class IntegerVector extends AbstractNumberVector { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/LabelList.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/LabelList.java index 6b5850da..72ec61fe 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/LabelList.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/LabelList.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteBufferSerializer; * A list of string labels. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf String */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ModifiableHyperBoundingBox.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ModifiableHyperBoundingBox.java index d9a2d1c9..a117c6f4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ModifiableHyperBoundingBox.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ModifiableHyperBoundingBox.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.logging.LoggingConfiguration; * MBR class allowing modifications (as opposed to {@link HyperBoundingBox}). * * @author Marisa Thoma + * @since 0.3 */ public class ModifiableHyperBoundingBox extends HyperBoundingBox { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/NumberVector.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/NumberVector.java index 60a0036e..a946285b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/NumberVector.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/NumberVector.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.NumberArrayAdapter * Object that is element of a real vector space of type N. * * @author Arthur Zimek + * @since 0.2 * * @apiviz.landmark * @apiviz.has Vector diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/OneDimensionalDoubleVector.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/OneDimensionalDoubleVector.java index d50bcc85..5c044a0f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/OneDimensionalDoubleVector.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/OneDimensionalDoubleVector.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * as we want to implement the interface. * * @author Erich Schubert + * @since 0.4.0 */ public class OneDimensionalDoubleVector extends AbstractNumberVector { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ShortVector.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ShortVector.java index 02711118..9d275842 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ShortVector.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/ShortVector.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Vector type using {@code short[]} storage. * * @author Erich Schubert + * @since 0.2 */ public class ShortVector extends AbstractNumberVector { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SimpleClassLabel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SimpleClassLabel.java index 13ccc4a7..56df7df6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SimpleClassLabel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SimpleClassLabel.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteBufferSerializer; * A simple class label casting a String as it is as label. * * @author Arthur Zimek + * @since 0.2 * * @apiviz.composedOf String */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseByteVector.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseByteVector.java index 53ebc1e2..dc97e6c6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseByteVector.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseByteVector.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * value (limited to -128..+127). * * @author Arthur Zimek + * @since 0.2 */ public class SparseByteVector extends AbstractNumberVector implements SparseNumberVector { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseDoubleVector.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseDoubleVector.java index 358763d7..44158a88 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseDoubleVector.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseDoubleVector.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * value. * * @author Arthur Zimek + * @since 0.2 */ public class SparseDoubleVector extends AbstractNumberVector implements SparseNumberVector { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseFeatureVector.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseFeatureVector.java index b0eee337..ba82b56f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseFeatureVector.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseFeatureVector.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.data; * Extended interface for sparse feature vector types. * * @author Erich Schubert + * @since 0.4.0 * */ public interface SparseFeatureVector<D> extends FeatureVector<D> { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseFloatVector.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseFloatVector.java index 90613041..108210ce 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseFloatVector.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseFloatVector.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * value. * * @author Arthur Zimek + * @since 0.2 */ public class SparseFloatVector extends AbstractNumberVector implements SparseNumberVector { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseIntegerVector.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseIntegerVector.java index cb2ee455..aa561714 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseIntegerVector.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseIntegerVector.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * integer value. * * @author Arthur Zimek + * @since 0.2 */ public class SparseIntegerVector extends AbstractNumberVector implements SparseNumberVector { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseNumberVector.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseNumberVector.java index bbacaba0..f3252f24 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseNumberVector.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseNumberVector.java @@ -29,6 +29,7 @@ import gnu.trove.map.TIntDoubleMap; * Combines the SparseFeatureVector and NumberVector. * * @author Erich Schubert + * @since 0.4.0 */ public interface SparseNumberVector extends NumberVector, SparseFeatureVector<Number> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseShortVector.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseShortVector.java index 17624a6b..1864788e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseShortVector.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/SparseShortVector.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * value. * * @author Arthur Zimek + * @since 0.2 */ public class SparseShortVector extends AbstractNumberVector implements SparseNumberVector { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/Subspace.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/Subspace.java index 96d86a41..c18d9bb3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/Subspace.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/Subspace.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.BitsUtil; * Represents a subspace of the original data space. * * @author Elke Achtert + * @since 0.2 * * @apiviz.owns de.lmu.ifi.dbs.elki.data.Subspace.DimensionComparator */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/VectorUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/VectorUtil.java index 2e42b498..5959d64c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/VectorUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/VectorUtil.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.QuickSelect; * Note: obviously, many functions are class methods or database related. * * @author Erich Schubert + * @since 0.3 * * @apiviz.uses NumberVector */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/AbstractModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/AbstractModel.java index 7d825480..db1c52c4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/AbstractModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/AbstractModel.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterStream; * Abstract base class for Cluster Models. * * @author Erich Schubert + * @since 0.2 */ public abstract class AbstractModel implements Model { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/BiclusterModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/BiclusterModel.java index 81b3f5bf..53b49d2e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/BiclusterModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/BiclusterModel.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.data.model; * Wrapper class to provide the basic properties of a Bicluster. * * @author Arthur Zimek + * @since 0.2 */ public class BiclusterModel implements Model { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/BiclusterWithInversionsModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/BiclusterWithInversionsModel.java index bc6ae177..721b9ffe 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/BiclusterWithInversionsModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/BiclusterWithInversionsModel.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDs; * have inverted rows. * * @author Erich Schubert + * @since 0.3 */ public class BiclusterWithInversionsModel extends BiclusterModel { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/ClusterModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/ClusterModel.java index 5081c9b5..26fb91ee 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/ClusterModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/ClusterModel.java @@ -29,6 +29,7 @@ package de.lmu.ifi.dbs.elki.data.model; * static {@link #CLUSTER} object. * * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/CoreObjectsModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/CoreObjectsModel.java index cc99f84d..7d476382 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/CoreObjectsModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/CoreObjectsModel.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterStream; * DBSCAN implementation when the {@code -gdbscan.core-model} flag is set. * * @author Erich Schubert + * @since 0.3 */ public class CoreObjectsModel extends AbstractModel implements TextWriteable { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/CorrelationAnalysisSolution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/CorrelationAnalysisSolution.java index 7a0b4901..d2408775 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/CorrelationAnalysisSolution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/CorrelationAnalysisSolution.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterStream; * dependencies. * * @author Arthur Zimek + * @since 0.2 * * @apiviz.composedOf LinearEquationSystem * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/CorrelationModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/CorrelationModel.java index 9b6dfcde..1e638497 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/CorrelationModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/CorrelationModel.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.FormatUtil; * Cluster model using a filtered PCA result and an centroid. * * @author Erich Schubert + * @since 0.2 * * @apiviz.composedOf PCAFilteredResult * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/DendrogramModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/DendrogramModel.java index 1a339677..e129b4f3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/DendrogramModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/DendrogramModel.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterStream; * Model for dendrograms, provides the distance to the child cluster. * * @author Elke Achtert + * @since 0.4.0 */ // TODO: comments public class DendrogramModel extends AbstractModel { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/DimensionModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/DimensionModel.java index e867fede..5b8a978f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/DimensionModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/DimensionModel.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterStream; * Cluster model just providing a cluster dimensionality. * * @author Erich Schubert + * @since 0.2 */ public class DimensionModel extends AbstractModel implements TextWriteable { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/EMModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/EMModel.java index eabffce7..1b91e405 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/EMModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/EMModel.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterStream; * Matrix. * * @author Erich Schubert + * @since 0.2 */ public class EMModel extends MeanModel { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/KMeansModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/KMeansModel.java index eef678cc..3bcb24c2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/KMeansModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/KMeansModel.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; * produced by k-means (so the Voronoi cell visualization is sensible). * * @author Erich Schubert + * @since 0.2 */ public class KMeansModel extends MeanModel { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/LinearEquationModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/LinearEquationModel.java index 0c6f9871..afa56261 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/LinearEquationModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/LinearEquationModel.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterStream; * Cluster model containing a linear equation system for the cluster. * * @author Erich Schubert + * @since 0.2 * * @apiviz.composedOf LinearEquationSystem */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/MeanModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/MeanModel.java index 7a5c71b9..350a8678 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/MeanModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/MeanModel.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriteable; * Cluster model that stores a mean for the cluster. * * @author Erich Schubert + * @since 0.3 */ public class MeanModel extends PrototypeModel<Vector> implements TextWriteable { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/MedoidModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/MedoidModel.java index 1654490a..add3fe2b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/MedoidModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/MedoidModel.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriteable; * Cluster model that stores a mean for the cluster. * * @author Erich Schubert + * @since 0.3 */ public class MedoidModel extends PrototypeModel<DBID> implements TextWriteable { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/Model.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/Model.java index d30eddfd..369688e1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/Model.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/Model.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.data.model; * Base interface for Model classes. * * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/ModelUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/ModelUtil.java index 16b6ca27..891bc733 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/ModelUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/ModelUtil.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.ArrayLikeUtil; * Utility classes for dealing with cluster models. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.uses Model * @apiviz.uses NumberVector diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/OPTICSModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/OPTICSModel.java index 96e56f2e..02b21a30 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/OPTICSModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/OPTICSModel.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.data.model; * Model for an OPTICS cluster * * @author Erich Schubert + * @since 0.4.0 */ public class OPTICSModel extends AbstractModel { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/PrototypeModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/PrototypeModel.java index d8f836fa..8ce14e0d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/PrototypeModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/PrototypeModel.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterStream; * Cluster model that stores a prototype for each cluster. * * @author Erich Schubert + * @since 0.3 */ public class PrototypeModel<V> extends AbstractModel implements TextWriteable { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/SubspaceModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/SubspaceModel.java index 38064c8f..bfc30205 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/SubspaceModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/model/SubspaceModel.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterStream; * * @author Erich Schubert * @author Elke Achtert + * @since 0.3 * * @apiviz.composedOf Subspace */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/FeatureSelection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/FeatureSelection.java index d3c0abfe..eab1f1ea 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/FeatureSelection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/FeatureSelection.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntListParameter; * Projection class for number vectors. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.uses FeatureVector * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/LatLngToECEFProjection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/LatLngToECEFProjection.java index 3b63e257..5549dd26 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/LatLngToECEFProjection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/LatLngToECEFProjection.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * coordinates to ECEF (earth-centered earth-fixed). * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf EarthModel * @apiviz.uses NumberVector diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/LngLatToECEFProjection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/LngLatToECEFProjection.java index 56316949..22448c73 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/LngLatToECEFProjection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/LngLatToECEFProjection.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * coordinates to ECEF (earth-centered earth-fixed). * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf EarthModel * @apiviz.uses NumberVector diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/NumericalFeatureSelection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/NumericalFeatureSelection.java index caeb9de9..77cf5e47 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/NumericalFeatureSelection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/NumericalFeatureSelection.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntListParameter; * Projection class for number vectors. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.uses NumberVector * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/Projection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/Projection.java index aa057fe0..b88c4bb6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/Projection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/Projection.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.data.type.TypeInformation; * Projection interface. * * @author Erich Schubert + * @since 0.4.0 * * @param <IN> Input data type * @param <OUT> Output data type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/RandomProjection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/RandomProjection.java index 6318ce10..04fe210f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/RandomProjection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/projection/RandomProjection.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * suggested for locality sensitive hashing (LSH). * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.uses NumberVector * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/Polygon.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/Polygon.java index b574645c..cd58ed8d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/Polygon.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/Polygon.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.iterator.ArrayListIter; * polygons are simple. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf Vector */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/PolygonsObject.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/PolygonsObject.java index 98aae9cf..fdee5f60 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/PolygonsObject.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/PolygonsObject.java @@ -31,6 +31,7 @@ import java.util.Iterator; * Object representation consisting of (multiple) polygons. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has Polygon */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialComparable.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialComparable.java index 999c24a1..4d605472 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialComparable.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialComparable.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.data.spatial; * Defines the required methods needed for comparison of spatial objects. * * @author Elke Achtert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.excludeSubtypes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialSingleMaxComparator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialSingleMaxComparator.java index c773cde6..04e6d351 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialSingleMaxComparator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialSingleMaxComparator.java @@ -29,6 +29,7 @@ import java.util.Comparator; * dimension. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses SpatialComparable */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialSingleMeanComparator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialSingleMeanComparator.java index 2992d901..5b7b14ac 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialSingleMeanComparator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialSingleMeanComparator.java @@ -29,6 +29,7 @@ import java.util.Comparator; * dimension. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses SpatialComparable */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialSingleMinComparator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialSingleMinComparator.java index 2bf1f0e5..6ae90d64 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialSingleMinComparator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialSingleMinComparator.java @@ -29,6 +29,7 @@ import java.util.Comparator; * dimension. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses SpatialComparable */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialUtil.java index 59d1c282..864ef7fc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/spatial/SpatialUtil.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.ArrayAdapter; * Utility class with spatial functions. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorInterface.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorInterface.java index f7521c67..1b3175d1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorInterface.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorInterface.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.UnableToComplyException; * Interface for cluster generators * * @author Erich Schubert + * @since 0.2 */ public interface GeneratorInterface { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorInterfaceDynamic.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorInterfaceDynamic.java index 4898319a..1a9ed0f0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorInterfaceDynamic.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorInterfaceDynamic.java @@ -30,6 +30,7 @@ package de.lmu.ifi.dbs.elki.data.synthetic.bymodel; * and the generation of additional new points. * * @author Erich Schubert + * @since 0.2 */ public interface GeneratorInterfaceDynamic extends GeneratorInterface { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorMain.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorMain.java index 9db74eb7..ad5c6e67 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorMain.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorMain.java @@ -65,6 +65,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.UnableToComplyException; * be as expected. * * @author Erich Schubert + * @since 0.2 * * @apiviz.has GeneratorInterface */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorSingleCluster.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorSingleCluster.java index 850cfbcc..b4add21d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorSingleCluster.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorSingleCluster.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.UnableToComplyException; * according to the same model) * * @author Erich Schubert + * @since 0.2 * * @apiviz.composedOf Distribution * @apiviz.composedOf AffineTransformation diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorStatic.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorStatic.java index 9b25c7fb..8cf4b241 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorStatic.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/synthetic/bymodel/GeneratorStatic.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; * that will return only a given set of points. * * @author Erich Schubert + * @since 0.2 */ public class GeneratorStatic implements GeneratorInterface { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/AlternativeTypeInformation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/AlternativeTypeInformation.java index 7bad02cb..14083bac 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/AlternativeTypeInformation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/AlternativeTypeInformation.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.data.type; * operator. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf TypeInformation */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/CombinedTypeInformation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/CombinedTypeInformation.java index 839b65d7..7af7532e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/CombinedTypeInformation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/CombinedTypeInformation.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.data.type; * Class that combines multiple type restrictions into one using an "and" operator. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf TypeInformation */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/FieldTypeInformation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/FieldTypeInformation.java index 00ce847b..b0375996 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/FieldTypeInformation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/FieldTypeInformation.java @@ -29,6 +29,7 @@ package de.lmu.ifi.dbs.elki.data.type; * TODO: implement polygon and rectangle types! * * @author Erich Schubert + * @since 0.6.0 */ public interface FieldTypeInformation extends TypeInformation { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/MultivariateSeriesTypeInformation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/MultivariateSeriesTypeInformation.java index 72c017c5..16372da1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/MultivariateSeriesTypeInformation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/MultivariateSeriesTypeInformation.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteBufferSerializer; * Type information for multi-variate time series. * * @author Sebastian Hollizeck + * @since 0.7.0 * * @param <V> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/NoSupportedDataTypeException.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/NoSupportedDataTypeException.java index 9ab4141e..1e899f5f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/NoSupportedDataTypeException.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/NoSupportedDataTypeException.java @@ -29,6 +29,7 @@ import java.util.Collection; * Exception thrown when no supported data type was found. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses TypeInformation oneway - - */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/SimpleTypeInformation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/SimpleTypeInformation.java index 36633198..4ff6fbae 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/SimpleTypeInformation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/SimpleTypeInformation.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteBufferSerializer; * Class wrapping a particular data type. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf ByteBufferSerializer * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/TypeInformation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/TypeInformation.java index dfbc74e4..bb1fbd08 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/TypeInformation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/TypeInformation.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.data.type; * Class wrapping a particular data type. * * @author Erich Schubert + * @since 0.4.0 */ public interface TypeInformation { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/TypeInformationSerializer.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/TypeInformationSerializer.java index 9a8d74ae..c9661419 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/TypeInformationSerializer.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/TypeInformationSerializer.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteBufferSerializer; * possible. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.composedOf SimpleTypeSerializer * @apiviz.composedOf VectorTypeSerializer diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/TypeUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/TypeUtil.java index 85c0abf7..4a6eb8d7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/TypeUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/TypeUtil.java @@ -53,6 +53,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteArrayUtil; * Utility package containing various common types. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has TypeInformation oneway - - * @apiviz.landmark diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/VectorFieldTypeInformation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/VectorFieldTypeInformation.java index e6526c61..efcb8dd7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/VectorFieldTypeInformation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/VectorFieldTypeInformation.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteBufferSerializer; * Type information to specify that a type has a fixed dimensionality. * * @author Erich Schubert + * @since 0.4.0 * * @param <V> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/VectorTypeInformation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/VectorTypeInformation.java index c193a3fd..12276165 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/VectorTypeInformation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/type/VectorTypeInformation.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteBufferSerializer; * Construct a type information for vector spaces with fixed dimensionality. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has FeatureVector * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/AbstractUncertainObject.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/AbstractUncertainObject.java index ed5bab03..766740f9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/AbstractUncertainObject.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/AbstractUncertainObject.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.data.spatial.SpatialComparable; * * @author Alexander Koos * @author Erich Schubert + * @since 0.7.0 */ public abstract class AbstractUncertainObject implements UncertainObject { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/DiscreteUncertainObject.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/DiscreteUncertainObject.java index 5d7cfc22..c29ab470 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/DiscreteUncertainObject.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/DiscreteUncertainObject.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.data.DoubleVector; * (possibly weighted) number of samples. * * @author Erich Schubert + * @since 0.7.0 */ public interface DiscreteUncertainObject extends UncertainObject { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/SimpleGaussianContinuousUncertainObject.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/SimpleGaussianContinuousUncertainObject.java index d3958f36..bf60cd39 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/SimpleGaussianContinuousUncertainObject.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/SimpleGaussianContinuousUncertainObject.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteBufferSerializer; * TODO: currently, only a 3 sigma bounding box is supported. * * @author Erich Schubert + * @since 0.7.0 */ public class SimpleGaussianContinuousUncertainObject extends AbstractUncertainObject { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/UncertainObject.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/UncertainObject.java index ea1dfa3d..a96452b6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/UncertainObject.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/UncertainObject.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.data.spatial.SpatialComparable; * TODO: Eventually allow float precision, too. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has DoubleVector oneway - «contains/produces» */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/UniformContinuousUncertainObject.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/UniformContinuousUncertainObject.java index 7c236f70..868a745c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/UniformContinuousUncertainObject.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/UniformContinuousUncertainObject.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteBufferSerializer; * * @author Alexander Koos * @author Erich Schubert + * @since 0.7.0 */ public class UniformContinuousUncertainObject extends AbstractUncertainObject { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/UnweightedDiscreteUncertainObject.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/UnweightedDiscreteUncertainObject.java index 877361fa..6b527e4e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/UnweightedDiscreteUncertainObject.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/UnweightedDiscreteUncertainObject.java @@ -57,6 +57,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteBufferSerializer; * * @author Alexander Koos * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "N. Dalvi, C. Ré, D. Suciu", // title = "Probabilistic databases: diamonds in the dirt", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/WeightedDiscreteUncertainObject.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/WeightedDiscreteUncertainObject.java index 0b08dcbc..8657720f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/WeightedDiscreteUncertainObject.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/WeightedDiscreteUncertainObject.java @@ -73,6 +73,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteBufferSerializer; * * @author Alexander Koos * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "O. Benjelloun, A. D. Sarma, A. Halevy, J. Widom", // title = "ULDBs: Databases with uncertainty and lineage", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/AbstractDiscreteUncertainifier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/AbstractDiscreteUncertainifier.java index 4ee534cc..190ccc6a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/AbstractDiscreteUncertainifier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/AbstractDiscreteUncertainifier.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Factory class for discrete uncertain objects. * * @author Erich Schubert + * @since 0.7.0 * * @param <UO> Uncertain object type. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/SimpleGaussianUncertainifier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/SimpleGaussianUncertainifier.java index 0e7c01df..0056d687 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/SimpleGaussianUncertainifier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/SimpleGaussianUncertainifier.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag; * Vector factory * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has SimpleGaussianContinuousUncertainObject */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/Uncertainifier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/Uncertainifier.java index 02a7b537..6bd584e4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/Uncertainifier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/Uncertainifier.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; * Class to derive uncertain object from exact vectors. * * @author Erich Schubert + * @since 0.7.0 * * @param <UO> Object type * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/UniformUncertainifier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/UniformUncertainifier.java index 96153685..3e141b05 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/UniformUncertainifier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/UniformUncertainifier.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag; * Factory class. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has UniformContinuousUncertainObject */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/UnweightedDiscreteUncertainifier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/UnweightedDiscreteUncertainifier.java index 632c58f9..17c3d812 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/UnweightedDiscreteUncertainifier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/UnweightedDiscreteUncertainifier.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.NumberArrayAdapter * {@link SimpleGaussianUncertainifier}). * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has UnweightedDiscreteUncertainObject */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/WeightedDiscreteUncertainifier.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/WeightedDiscreteUncertainifier.java index fb63a992..3b499de4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/WeightedDiscreteUncertainifier.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/data/uncertain/uncertainifier/WeightedDiscreteUncertainifier.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.NumberArrayAdapter * {@link SimpleGaussianUncertainifier}). * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has WeightedDiscreteUncertainObject */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/AbstractDatabase.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/AbstractDatabase.java index 0c038369..b9424041 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/AbstractDatabase.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/AbstractDatabase.java @@ -56,6 +56,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; * <tt>-enableDebug de.lmu.ifi.dbs.elki.database=FINEST</tt> * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf DatabaseEventManager * @apiviz.has IndexFactory diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/Database.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/Database.java index d553da17..4a008919 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/Database.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/Database.java @@ -47,6 +47,7 @@ import de.lmu.ifi.dbs.elki.result.HierarchicalResult; * parameters for dynamic instantiation. * * @author Elke Achtert + * @since 0.2 * * @apiviz.landmark * @apiviz.has DistanceQuery oneway - - provides diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/DatabaseEventManager.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/DatabaseEventManager.java index 3ddba18e..5251366c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/DatabaseEventManager.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/DatabaseEventManager.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.result.ResultListener; * Class to manage database events such as insertions and removals. * * @author Elke Achtert + * @since 0.4.0 * @apiviz.has ResultListener */ public class DatabaseEventManager { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/HashmapDatabase.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/HashmapDatabase.java index 90fd55ea..56ec0706 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/HashmapDatabase.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/HashmapDatabase.java @@ -60,6 +60,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * * @author Arthur Zimek * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark * @apiviz.composedOf HashSetModifiableDBIDs diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ProxyDatabase.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ProxyDatabase.java index eb8dd05b..5c635f96 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ProxyDatabase.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ProxyDatabase.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * A proxy database to use e.g. for projections and partitions. * * @author Erich Schubert + * @since 0.4.0 */ public class ProxyDatabase extends AbstractDatabase { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/QueryUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/QueryUtil.java index 26262575..a3bfd071 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/QueryUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/QueryUtil.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.distance.similarityfunction.SimilarityFunction; * Static class with utilities related to querying a database. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/StaticArrayDatabase.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/StaticArrayDatabase.java index da13c5fa..cc889e6f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/StaticArrayDatabase.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/StaticArrayDatabase.java @@ -55,6 +55,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * * @author Arthur Zimek * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark * @apiviz.composedOf ArrayStaticDBIDs diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/UpdatableDatabase.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/UpdatableDatabase.java index 45f7ad78..48333aab 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/UpdatableDatabase.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/UpdatableDatabase.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.UnableToComplyException; * that cannot be done in dynamic databases. * * @author Erich Schubert + * @since 0.4.0 */ public interface UpdatableDatabase extends Database { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DBIDDataStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DBIDDataStore.java index b79be1f4..8d9d08c8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DBIDDataStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DBIDDataStore.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDVar; * DBID-valued data store (avoids boxing/unboxing). * * @author Erich Schubert + * @since 0.4.0 */ public interface DBIDDataStore extends DataStore<DBID> { /** @@ -40,7 +41,7 @@ public interface DBIDDataStore extends DataStore<DBID> { */ @Override @Deprecated - public DBID get(DBIDRef id); + DBID get(DBIDRef id); /** * Retrieves an object from the storage. @@ -49,5 +50,5 @@ public interface DBIDDataStore extends DataStore<DBID> { * @param var Variable to update. * @return {@code var} */ - public DBIDVar assignVar(DBIDRef id, DBIDVar var); + DBIDVar assignVar(DBIDRef id, DBIDVar var); } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStore.java index 2c306486..e78fc591 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStore.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.result.Result; * Generic storage interface for objects indexed by {@link DBID}. * * @author Erich Schubert + * @since 0.4.0 * * @param <T> Data type */ @@ -41,5 +42,5 @@ public interface DataStore<T> extends Result { * @param id Database ID. * @return Object or {@code null} */ - public T get(DBIDRef id); + T get(DBIDRef id); }
\ No newline at end of file diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreEvent.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreEvent.java index 294a3a19..79afd440 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreEvent.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreEvent.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDs; * {@link DataStoreListener} of the change. * * @author Erich Schubert + * @since 0.4.0 * * @see DataStore * @see DataStoreListener diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreFactory.java index 63a12693..17c3221b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreFactory.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDs; * Use {@link #FACTORY} for a static instance. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.stereotype factory,interface * @apiviz.has WritableDataStore oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreIDMap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreIDMap.java index 70e0a3f6..c9501dd6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreIDMap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreIDMap.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; * Interface to map DBIDs to integer record ids for use in storage. * * @author Erich Schubert + * @since 0.4.0 */ public interface DataStoreIDMap { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreListener.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreListener.java index 60a1bc16..edf37bf9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreListener.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreListener.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.database.datastore; * {@link DataStore}. * * @author Elke Achtert + * @since 0.4.0 * * @apiviz.uses DataStoreEvent oneway - - listens * @apiviz.excludeSubtypes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreUtil.java index 5602e0d7..7976759b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DataStoreUtil.java @@ -26,14 +26,16 @@ package de.lmu.ifi.dbs.elki.database.datastore; import java.util.Comparator; 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.DBIDs; /** * Storage utility class. Mostly a shorthand for * {@link DataStoreFactory#FACTORY}. - * + * * @author Erich Schubert - * + * @since 0.4.0 + * * @apiviz.landmark * @apiviz.composedOf de.lmu.ifi.dbs.elki.database.datastore.DataStoreFactory */ @@ -41,7 +43,7 @@ public final class DataStoreUtil { /** * Make a new storage, to associate the given ids with an object of class * dataclass. - * + * * @param <T> stored data type * @param ids DBIDs to store data for * @param hints Hints for the storage manager @@ -55,7 +57,7 @@ public final class DataStoreUtil { /** * Make a new storage, to associate the given ids with an object of class * dataclass. - * + * * @param ids DBIDs to store data for * @param hints Hints for the storage manager * @return new data store @@ -67,7 +69,7 @@ public final class DataStoreUtil { /** * Make a new storage, to associate the given ids with an object of class * dataclass. - * + * * @param ids DBIDs to store data for * @param hints Hints for the storage manager * @return new data store @@ -79,7 +81,7 @@ public final class DataStoreUtil { /** * Make a new storage, to associate the given ids with an object of class * dataclass. - * + * * @param ids DBIDs to store data for * @param hints Hints for the storage manager * @param def Default value @@ -92,7 +94,7 @@ public final class DataStoreUtil { /** * Make a new storage, to associate the given ids with an object of class * dataclass. - * + * * @param ids DBIDs to store data for * @param hints Hints for the storage manager * @return new data store @@ -104,7 +106,7 @@ public final class DataStoreUtil { /** * Make a new storage, to associate the given ids with an object of class * dataclass. - * + * * @param ids DBIDs to store data for * @param hints Hints for the storage manager * @param def Default value @@ -117,7 +119,7 @@ public final class DataStoreUtil { /** * Make a new record storage, to associate the given ids with an object of * class dataclass. - * + * * @param ids DBIDs to store data for * @param hints Hints for the storage manager * @param dataclasses classes to store @@ -129,9 +131,9 @@ public final class DataStoreUtil { /** * Sort objects by a double relation - * + * * @author Erich Schubert - * + * * @apiviz.exclude */ public static class AscendingByDoubleDataStore implements Comparator<DBIDRef> { @@ -139,7 +141,7 @@ public final class DataStoreUtil { * Scores to use for sorting. */ private final DoubleDataStore scores; - + /** * Constructor. * @@ -158,9 +160,9 @@ public final class DataStoreUtil { /** * Sort objects by a double relation - * + * * @author Erich Schubert - * + * * @apiviz.exclude */ public static class DescendingByDoubleDataStore implements Comparator<DBIDRef> { @@ -168,7 +170,7 @@ public final class DataStoreUtil { * Scores to use for sorting. */ private final DoubleDataStore scores; - + /** * Constructor. * @@ -184,4 +186,64 @@ public final class DataStoreUtil { return Double.compare(scores.doubleValue(id2), scores.doubleValue(id1)); } } + + /** + * Sort objects by a double relation + * + * @author Erich Schubert + * + * @apiviz.exclude + */ + public static class AscendingByDoubleDataStoreAndId implements Comparator<DBIDRef> { + /** + * Scores to use for sorting. + */ + private final DoubleDataStore scores; + + /** + * Constructor. + * + * @param scores Scores for sorting + */ + public AscendingByDoubleDataStoreAndId(DoubleDataStore scores) { + super(); + this.scores = scores; + } + + @Override + public int compare(DBIDRef id1, DBIDRef id2) { + int c = Double.compare(scores.doubleValue(id1), scores.doubleValue(id2)); + return c != 0 ? c : DBIDUtil.compare(id1, id2); + } + } + + /** + * Sort objects by a double relation + * + * @author Erich Schubert + * + * @apiviz.exclude + */ + public static class DescendingByDoubleDataStoreAndId implements Comparator<DBIDRef> { + /** + * Scores to use for sorting. + */ + private final DoubleDataStore scores; + + /** + * Constructor. + * + * @param scores Scores for sorting + */ + public DescendingByDoubleDataStoreAndId(DoubleDataStore scores) { + super(); + this.scores = scores; + } + + @Override + public int compare(DBIDRef id1, DBIDRef id2) { + int c = Double.compare(scores.doubleValue(id2), scores.doubleValue(id1)); + return c != 0 ? c : DBIDUtil.compare(id1, id2); + } + } } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DoubleDataStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DoubleDataStore.java index 8cf6cdf1..8f52f996 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DoubleDataStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/DoubleDataStore.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; * Double-valued data store (avoids boxing/unboxing). * * @author Erich Schubert + * @since 0.4.0 */ public interface DoubleDataStore extends DataStore<Double> { /** @@ -38,7 +39,7 @@ public interface DoubleDataStore extends DataStore<Double> { */ @Override @Deprecated - public Double get(DBIDRef id); + Double get(DBIDRef id); /** * Retrieves an object from the storage. @@ -46,5 +47,5 @@ public interface DoubleDataStore extends DataStore<Double> { * @param id Database ID. * @return Double value */ - public double doubleValue(DBIDRef id); + double doubleValue(DBIDRef id); }
\ No newline at end of file diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/IntegerDataStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/IntegerDataStore.java index 986f4fc8..7747bcb3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/IntegerDataStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/IntegerDataStore.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; * Integer-valued data store (avoids boxing/unboxing). * * @author Erich Schubert + * @since 0.4.0 */ public interface IntegerDataStore extends DataStore<Integer> { /** @@ -38,7 +39,7 @@ public interface IntegerDataStore extends DataStore<Integer> { */ @Override @Deprecated - public Integer get(DBIDRef id); + Integer get(DBIDRef id); /** * Retrieves a value from the storage. @@ -46,5 +47,5 @@ public interface IntegerDataStore extends DataStore<Integer> { * @param id Database ID. * @return Double value */ - public int intValue(DBIDRef id); + int intValue(DBIDRef id); }
\ No newline at end of file diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/RecordStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/RecordStore.java index b98f4d13..be06aa13 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/RecordStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/RecordStore.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.database.datastore; * Represents a storage which stores multiple values per object in a record fashion. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has de.lmu.ifi.dbs.elki.database.datastore.DataStore oneway - - projectsTo */ @@ -40,5 +41,5 @@ public interface RecordStore { * @param datatype data class * @return writable storage */ - public <T> DataStore<T> getStorage(int col, Class<? super T> datatype); + <T> DataStore<T> getStorage(int col, Class<? super T> datatype); } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableDBIDDataStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableDBIDDataStore.java index 38fd8adb..df0001ec 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableDBIDDataStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableDBIDDataStore.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; * Data store specialized for doubles. Avoids boxing/unboxing. * * @author Erich Schubert + * @since 0.4.0 */ public interface WritableDBIDDataStore extends DBIDDataStore, WritableDataStore<DBID> { /** @@ -39,7 +40,7 @@ public interface WritableDBIDDataStore extends DBIDDataStore, WritableDataStore< */ @Override @Deprecated - public DBID put(DBIDRef id, DBID value); + DBID put(DBIDRef id, DBID value); /** * Associates the specified value with the specified id in this storage. If @@ -49,7 +50,7 @@ public interface WritableDBIDDataStore extends DBIDDataStore, WritableDataStore< * @param id Database ID. * @param value Value to store. */ - public void putDBID(DBIDRef id, DBIDRef value); + void putDBID(DBIDRef id, DBIDRef value); /** * Associates the specified value with the specified id in this storage. If @@ -59,5 +60,5 @@ public interface WritableDBIDDataStore extends DBIDDataStore, WritableDataStore< * @param id Database ID. * @param value Value to store. */ - public void put(DBIDRef id, DBIDRef value); + void put(DBIDRef id, DBIDRef value); }
\ No newline at end of file diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableDataStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableDataStore.java index 8baf622e..33f213b8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableDataStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableDataStore.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; * Writable data store. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @@ -44,13 +45,13 @@ public interface WritableDataStore<T> extends DataStore<T> { * @param value Value to store. * @return previous value */ - public T put(DBIDRef id, T value); + T put(DBIDRef id, T value); /** * Deallocate the storage, freeing the memory and notifies the registered * listeners. */ - public void destroy(); + void destroy(); /** * Delete the contents for a particular ID and notifies the registered @@ -58,5 +59,10 @@ public interface WritableDataStore<T> extends DataStore<T> { * * @param id Database ID. */ - public void delete(DBIDRef id); + void delete(DBIDRef id); + + /** + * Clear the storage (resetting it to the default value). + */ + void clear(); } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableDoubleDataStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableDoubleDataStore.java index 8a3f9e8a..ac7fa2f2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableDoubleDataStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableDoubleDataStore.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; * Data store specialized for doubles. Avoids boxing/unboxing. * * @author Erich Schubert + * @since 0.4.0 */ public interface WritableDoubleDataStore extends DoubleDataStore, WritableDataStore<Double> { /** @@ -38,7 +39,7 @@ public interface WritableDoubleDataStore extends DoubleDataStore, WritableDataSt */ @Override @Deprecated - public Double put(DBIDRef id, Double value); + Double put(DBIDRef id, Double value); /** * Associates the specified value with the specified id in this storage. If @@ -49,7 +50,7 @@ public interface WritableDoubleDataStore extends DoubleDataStore, WritableDataSt * @param value Value to store. * @return previous value */ - public double putDouble(DBIDRef id, double value); + double putDouble(DBIDRef id, double value); /** * Associates the specified value with the specified id in this storage. If @@ -60,8 +61,7 @@ public interface WritableDoubleDataStore extends DoubleDataStore, WritableDataSt * @param value Value to store. * @return previous value */ - public double put(DBIDRef id, double value); - + double put(DBIDRef id, double value); /** * Increment the specified value with the specified id in this storage. @@ -69,10 +69,5 @@ public interface WritableDoubleDataStore extends DoubleDataStore, WritableDataSt * @param id Database ID. * @param value Value to add to the previous value. */ - public void increment(DBIDRef id, double value); - - /** - * Reinitialize (reset to default value). - */ - public void clear(); + void increment(DBIDRef id, double value); }
\ No newline at end of file diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableIntegerDataStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableIntegerDataStore.java index 0303f45e..09bbc77f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableIntegerDataStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableIntegerDataStore.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; * Data store specialized for doubles. Avoids boxing/unboxing. * * @author Erich Schubert + * @since 0.4.0 */ public interface WritableIntegerDataStore extends IntegerDataStore, WritableDataStore<Integer> { /** @@ -38,7 +39,7 @@ public interface WritableIntegerDataStore extends IntegerDataStore, WritableData */ @Override @Deprecated - public Integer put(DBIDRef id, Integer value); + Integer put(DBIDRef id, Integer value); /** * Associates the specified value with the specified id in this storage. If @@ -49,7 +50,7 @@ public interface WritableIntegerDataStore extends IntegerDataStore, WritableData * @param value Value to store. * @return previous value */ - public int putInt(DBIDRef id, int value); + int putInt(DBIDRef id, int value); /** * Associates the specified value with the specified id in this storage. If @@ -60,7 +61,7 @@ public interface WritableIntegerDataStore extends IntegerDataStore, WritableData * @param value Value to store. * @return previous value */ - public int put(DBIDRef id, int value); + int put(DBIDRef id, int value); /** * Increment a value. @@ -68,5 +69,5 @@ public interface WritableIntegerDataStore extends IntegerDataStore, WritableData * @param id Database ID. * @param adjust Value to add to the previous value. */ - public void increment(DBIDRef id, int adjust); + void increment(DBIDRef id, int adjust); }
\ No newline at end of file diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableRecordStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableRecordStore.java index 73106b28..81148c63 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableRecordStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/WritableRecordStore.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; * Represents a storage which stores multiple values per object in a record fashion. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @@ -44,7 +45,7 @@ public interface WritableRecordStore extends RecordStore { * @return writable storage */ @Override - public <T> WritableDataStore<T> getStorage(int col, Class<? super T> datatype); + <T> WritableDataStore<T> getStorage(int col, Class<? super T> datatype); /** * Remove an object from the store, all columns. @@ -52,5 +53,5 @@ public interface WritableRecordStore extends RecordStore { * @param id object ID to remove * @return success code */ - public boolean remove(DBIDRef id); + boolean remove(DBIDRef id); } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayDBIDStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayDBIDStore.java index 2c73ada4..f557f529 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayDBIDStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayDBIDStore.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDVar; * A class to answer representation queries using the stored Array. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf de.lmu.ifi.dbs.elki.database.datastore.DataStoreIDMap */ @@ -60,7 +61,7 @@ public class ArrayDBIDStore implements WritableDBIDDataStore { this.data = DBIDUtil.newArray(size); // Initialize DBIDRef inv = DBIDUtil.invalid(); - for (int i = 0; i < size; i++) { + for(int i = 0; i < size; i++) { data.add(inv); } this.idmap = idmap; @@ -106,8 +107,19 @@ public class ArrayDBIDStore implements WritableDBIDDataStore { } @Override + public void clear() { + // Re-initialize + DBIDRef inv = DBIDUtil.invalid(); + final int size = data.size(); + data.clear(); + for(int i = 0; i < size; i++) { + data.add(inv); + } + } + + @Override public void delete(DBIDRef id) { - throw new UnsupportedOperationException("Can't delete from a static array storage."); + put(id, DBIDUtil.invalid()); } @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayDoubleStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayDoubleStore.java index d1a8672e..5f6d687d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayDoubleStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayDoubleStore.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; * A class to answer representation queries using the stored Array. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf de.lmu.ifi.dbs.elki.database.datastore.DataStoreIDMap */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayIntegerStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayIntegerStore.java index 6b6ac14a..b4a4d7fc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayIntegerStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayIntegerStore.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; * A class to answer representation queries using the stored Array. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf de.lmu.ifi.dbs.elki.database.datastore.DataStoreIDMap */ @@ -48,6 +49,11 @@ public class ArrayIntegerStore implements WritableIntegerDataStore { private DataStoreIDMap idmap; /** + * Default value (for {@link #clear()}). + */ + private int def; + + /** * Constructor. * * @param size Size @@ -67,6 +73,7 @@ public class ArrayIntegerStore implements WritableIntegerDataStore { public ArrayIntegerStore(int size, DataStoreIDMap idmap, int def) { super(); this.data = new int[size]; + this.def = def; if(def != 0) { Arrays.fill(this.data, def); } @@ -123,7 +130,12 @@ public class ArrayIntegerStore implements WritableIntegerDataStore { @Override public void delete(DBIDRef id) { - throw new UnsupportedOperationException("Can't delete from a static array storage."); + put(id, def); + } + + @Override + public void clear() { + Arrays.fill(data, def); } @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayRecordStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayRecordStore.java index 62f07448..deb949ff 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayRecordStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayRecordStore.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; * A class to answer representation queries using the stored Array. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf DataStoreIDMap * @apiviz.has ArrayRecordStore.StorageAccessor oneway - - projectsTo @@ -128,12 +129,17 @@ public class ArrayRecordStore implements WritableRecordStore { @Override public void destroy() { - throw new UnsupportedOperationException("ArrayStore record columns cannot be destroyed."); + throw new UnsupportedOperationException("ArrayStore record columns cannot (yet) be destroyed."); } @Override public void delete(DBIDRef id) { - throw new UnsupportedOperationException("ArrayStore record values cannot be deleted."); + put(id, null); + } + + @Override + public void clear() { + throw new UnsupportedOperationException("ArrayStore record columns cannot (yet) be cleared."); } @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayStore.java index 35871ed9..bbfa967f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/ArrayStore.java @@ -1,5 +1,7 @@ package de.lmu.ifi.dbs.elki.database.datastore.memory; +import java.util.Arrays; + /* This file is part of ELKI: Environment for Developing KDD-Applications Supported by Index-Structures @@ -33,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.ObjectNotFoundException; * A class to answer representation queries using the stored Array. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf de.lmu.ifi.dbs.elki.database.datastore.DataStoreIDMap * @@ -86,7 +89,12 @@ public class ArrayStore<T> implements WritableDataStore<T> { @Override public void delete(DBIDRef id) { - throw new UnsupportedOperationException("Can't delete from a static array storage."); + put(id, null); + } + + @Override + public void clear() { + Arrays.fill(data, null); } @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDDBIDStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDDBIDStore.java index 11b3cbb2..9016e6cf 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDDBIDStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDDBIDStore.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDVar; * Writable data store for double values. * * @author Erich Schubert + * @since 0.5.0 */ public class MapIntegerDBIDDBIDStore implements WritableDBIDDataStore { /** @@ -76,17 +77,6 @@ public class MapIntegerDBIDDBIDStore implements WritableDBIDDataStore { } @Override - public void destroy() { - map.clear(); - map = null; - } - - @Override - public void delete(DBIDRef id) { - map.remove(DBIDUtil.asInteger(id)); - } - - @Override public void put(DBIDRef id, DBIDRef value) { map.put(DBIDUtil.asInteger(id), DBIDUtil.asInteger(value)); } @@ -102,4 +92,20 @@ public class MapIntegerDBIDDBIDStore implements WritableDBIDDataStore { DBIDFactory.FACTORY.assignVar(var, val); return var; } + + @Override + public void delete(DBIDRef id) { + map.remove(DBIDUtil.asInteger(id)); + } + + @Override + public void destroy() { + map.clear(); + map = null; + } + + @Override + public void clear() { + map.clear(); + } } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDDoubleStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDDoubleStore.java index 5e21f6b4..4629a942 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDDoubleStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDDoubleStore.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDUtil; * Writable data store for double values. * * @author Erich Schubert + * @since 0.5.0 */ public class MapIntegerDBIDDoubleStore implements WritableDoubleDataStore { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDIntegerStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDIntegerStore.java index 2474aa4a..37fb84c0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDIntegerStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDIntegerStore.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDUtil; * Writable data store for double values. * * @author Erich Schubert + * @since 0.5.0 */ public class MapIntegerDBIDIntegerStore implements WritableIntegerDataStore { /** @@ -112,4 +113,9 @@ public class MapIntegerDBIDIntegerStore implements WritableIntegerDataStore { public void increment(DBIDRef id, int adjust) { map.adjustOrPutValue(DBIDUtil.asInteger(id), adjust, adjust); } + + @Override + public void clear() { + map.clear(); + } } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDRecordStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDRecordStore.java index 66f885d5..6461ad97 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDRecordStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDRecordStore.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDUtil; * record. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has MapIntegerDBIDRecordStore.StorageAccessor oneway - - projectsTo */ @@ -165,7 +166,12 @@ public class MapIntegerDBIDRecordStore implements WritableRecordStore { @Override public void delete(DBIDRef id) { - throw new UnsupportedOperationException("Record storage values cannot be deleted."); + throw new UnsupportedOperationException("Record storage accessors cannot be deleted."); + } + + @Override + public void clear() { + throw new UnsupportedOperationException("Record storage accessors cannot be cleared."); } @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDStore.java index 08e31971..2d21dccb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapIntegerDBIDStore.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDUtil; * wrapper around a regular map. * * @author Erich Schubert + * @since 0.4.0 * * @param <T> Representation object type */ @@ -94,6 +95,11 @@ public class MapIntegerDBIDStore<T> implements WritableDataStore<T> { } @Override + public void clear() { + data.clear(); + } + + @Override public String getLongName() { return "raw"; } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapRecordStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapRecordStore.java index 6ed7f581..e6cf1198 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapRecordStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapRecordStore.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDUtil; * record. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has MapRecordStore.StorageAccessor oneway - - projectsTo */ @@ -90,7 +91,7 @@ public class MapRecordStore implements WritableRecordStore { @SuppressWarnings("unchecked") protected <T> T get(DBIDRef id, int index) { Object[] d = data.get(DBIDUtil.deref(id)); - if (d == null) { + if(d == null) { return null; } return (T) d[index]; @@ -108,7 +109,7 @@ public class MapRecordStore implements WritableRecordStore { @SuppressWarnings("unchecked") protected <T> T set(DBIDRef id, int index, T value) { Object[] d = data.get(DBIDUtil.deref(id)); - if (d == null) { + if(d == null) { d = new Object[rlen]; data.put(DBIDUtil.deref(id), d); } @@ -157,6 +158,11 @@ public class MapRecordStore implements WritableRecordStore { } @Override + public void clear() { + throw new UnsupportedOperationException("Record storage accessors cannot (yet) be cleared."); + } + + @Override public void delete(DBIDRef id) { throw new UnsupportedOperationException("Record storage values cannot be deleted."); } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapStore.java index 98e5fc57..758e8bec 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MapStore.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDUtil; * wrapper around a regular map. * * @author Erich Schubert + * @since 0.4.0 * * @param <T> Representation object type */ @@ -87,6 +88,11 @@ public class MapStore<T> implements WritableDataStore<T> { } @Override + public void clear() { + data.clear(); + } + + @Override public String getLongName() { return "raw"; } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MemoryDataStoreFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MemoryDataStoreFactory.java index 649de071..6e9427f5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MemoryDataStoreFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/datastore/memory/MemoryDataStoreFactory.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDs; * in-memory. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.stereotype factory * @apiviz.has ArrayStore oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ArrayDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ArrayDBIDs.java index c48e575d..8fc27ff3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ArrayDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ArrayDBIDs.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.database.ids; * Interface for array based DBIDs. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has DBIDArrayIter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ArrayModifiableDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ArrayModifiableDBIDs.java index 498d090a..c879ae95 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ArrayModifiableDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ArrayModifiableDBIDs.java @@ -28,6 +28,7 @@ import java.util.Comparator; * Array-oriented implementation of a modifiable DBID collection. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has DBIDArrayMIter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ArrayStaticDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ArrayStaticDBIDs.java index 7331edce..623b102d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ArrayStaticDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ArrayStaticDBIDs.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.database.ids; * Unmodifiable, indexed DBIDs. * * @author Erich Schubert + * @since 0.4.0 */ public interface ArrayStaticDBIDs extends ArrayDBIDs, StaticDBIDs { // empty. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBID.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBID.java index 3fb4cc93..66001a7a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBID.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBID.java @@ -34,6 +34,7 @@ package de.lmu.ifi.dbs.elki.database.ids; * consistent across multiple results/databases. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDArrayIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDArrayIter.java index 9168e7c6..0f638fe0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDArrayIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDArrayIter.java @@ -28,6 +28,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.iterator.ArrayIter; * Array iterators that can also go backwards and seek. * * @author Erich Schubert + * @since 0.4.0 */ public interface DBIDArrayIter extends DBIDIter, ArrayIter { @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDArrayMIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDArrayMIter.java index e4bca297..5da6b6ae 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDArrayMIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDArrayMIter.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.database.ids; * Modifiable array iterator. * * @author Erich Schubert + * @since 0.4.0 */ public interface DBIDArrayMIter extends DBIDArrayIter, DBIDMIter { // Nothing new, see {@link DBIDArrayIter} and {@link DBIDMIter} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDFactory.java index dc424b71..6ac06aab 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDFactory.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.FixedSizeByteBufferSerializer; * instance to use. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.stereotype factory * @apiviz.uses DBID oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDIter.java index d2c816a2..f9e9e381 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDIter.java @@ -54,6 +54,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.iterator.Iter; * </ul> * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDMIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDMIter.java index d52e87ed..7dc3dca6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDMIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDMIter.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.iterator.MIter; * Modifiable DBID iterator. * * @author Erich Schubert + * @since 0.4.0 */ public interface DBIDMIter extends DBIDIter, MIter { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDPair.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDPair.java index 29d993ea..675f8810 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDPair.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDPair.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.database.ids; * using {@link de.lmu.ifi.dbs.elki.utilities.pairs.Pair} * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf de.lmu.ifi.dbs.elki.database.ids.DBID */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDRange.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDRange.java index 710ec3c6..1e515893 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDRange.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDRange.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.datastore.DataStoreIDMap; * Static DBID range. * * @author Erich Schubert + * @since 0.4.0 */ public interface DBIDRange extends ArrayStaticDBIDs, DataStoreIDMap { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDRef.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDRef.java index 80b69a1e..7f051e35 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDRef.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDRef.java @@ -31,6 +31,7 @@ package de.lmu.ifi.dbs.elki.database.ids; * are a good example how the DBIDRef may change. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDUtil.java index ae85fa12..c9f2c1f1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDUtil.java @@ -41,11 +41,12 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteBufferSerializer; /** * DBID Utility functions. - * + * * @author Erich Schubert - * + * @since 0.4.0 + * * @apiviz.landmark - * + * * @apiviz.has DBIDs * @apiviz.has DBIDRef * @apiviz.composedOf DBIDFactory @@ -65,7 +66,7 @@ public final class DBIDUtil { /** * Get the invalid special ID. - * + * * @return invalid ID value */ public static DBIDRef invalid() { @@ -74,9 +75,9 @@ public final class DBIDUtil { /** * Import and integer as DBID. - * + * * Note: this may not be possible for some factories! - * + * * @param id Integer ID to import * @return DBID */ @@ -86,9 +87,9 @@ public final class DBIDUtil { /** * Export a DBID as int. - * + * * Note: this may not be possible for some factories! - * + * * @param id DBID to export * @return integer value */ @@ -98,7 +99,7 @@ public final class DBIDUtil { /** * Compare two DBIDs. - * + * * @param id1 First ID * @param id2 Second ID * @return Comparison result @@ -109,7 +110,7 @@ public final class DBIDUtil { /** * Test two DBIDs for equality. - * + * * @param id1 First ID * @param id2 Second ID * @return Comparison result @@ -120,7 +121,7 @@ public final class DBIDUtil { /** * Dereference a DBID reference. - * + * * @param ref DBID reference * @return DBID */ @@ -133,7 +134,7 @@ public final class DBIDUtil { /** * Format a DBID as string. - * + * * @param id DBID * @return String representation */ @@ -143,7 +144,7 @@ public final class DBIDUtil { /** * Format a DBID as string. - * + * * @param ids DBIDs * @return String representation */ @@ -163,7 +164,7 @@ public final class DBIDUtil { /** * Get a serializer for DBIDs. - * + * * @return DBID serializer */ public static ByteBufferSerializer<DBID> getDBIDSerializer() { @@ -172,7 +173,7 @@ public final class DBIDUtil { /** * Get a serializer for DBIDs with static size. - * + * * @return DBID serializer */ public static ByteBufferSerializer<DBID> getDBIDSerializerStatic() { @@ -181,7 +182,7 @@ public final class DBIDUtil { /** * Generate a single DBID. - * + * * @return A single DBID */ public static DBID generateSingleDBID() { @@ -190,7 +191,7 @@ public final class DBIDUtil { /** * Return a single DBID for reuse. - * + * * @param id DBID to deallocate */ public static void deallocateSingleDBID(DBID id) { @@ -199,7 +200,7 @@ public final class DBIDUtil { /** * Generate a static DBID range. - * + * * @param size Requested size * @return DBID range */ @@ -209,7 +210,7 @@ public final class DBIDUtil { /** * Deallocate a static DBID range. - * + * * @param range Range to deallocate */ public static void deallocateDBIDRange(DBIDRange range) { @@ -218,7 +219,7 @@ public final class DBIDUtil { /** * Make a new DBID variable. - * + * * @param val Initial value. * @return Variable */ @@ -228,7 +229,7 @@ public final class DBIDUtil { /** * Make a new DBID variable. - * + * * @return Variable */ public static DBIDVar newVar() { @@ -237,7 +238,7 @@ public final class DBIDUtil { /** * Make a new (modifiable) array of DBIDs. - * + * * @return New array */ public static ArrayModifiableDBIDs newArray() { @@ -246,7 +247,7 @@ public final class DBIDUtil { /** * Make a new (modifiable) hash set of DBIDs. - * + * * @return New hash set */ public static HashSetModifiableDBIDs newHashSet() { @@ -255,7 +256,7 @@ public final class DBIDUtil { /** * Make a new (modifiable) array of DBIDs. - * + * * @param size Size hint * @return New array */ @@ -265,7 +266,7 @@ public final class DBIDUtil { /** * Make a new (modifiable) hash set of DBIDs. - * + * * @param size Size hint * @return New hash set */ @@ -275,7 +276,7 @@ public final class DBIDUtil { /** * Make a new (modifiable) array of DBIDs. - * + * * @param existing Existing DBIDs * @return New array */ @@ -285,7 +286,7 @@ public final class DBIDUtil { /** * Make a new (modifiable) hash set of DBIDs. - * + * * @param existing Existing DBIDs * @return New hash set */ @@ -295,7 +296,7 @@ public final class DBIDUtil { /** * Compute the set intersection of two sets. - * + * * @param first First set * @param second Second set * @return result. @@ -316,7 +317,7 @@ public final class DBIDUtil { /** * Compute the set intersection size of two sets. - * + * * @param first First set * @param second Second set * @return size @@ -345,7 +346,7 @@ public final class DBIDUtil { /** * Compute the set intersection size of two sets. - * + * * @param first First set * @param second Second set * @return size @@ -362,7 +363,7 @@ public final class DBIDUtil { /** * Compute the set symmetric intersection of two sets. - * + * * @param first First set * @param second Second set * @param firstonly OUTPUT: elements only in first. MUST BE EMPTY @@ -393,7 +394,7 @@ public final class DBIDUtil { /** * Returns the union of the two specified collection of IDs. - * + * * @param ids1 the first collection * @param ids2 the second collection * @return the union of ids1 and ids2 without duplicates @@ -407,7 +408,7 @@ public final class DBIDUtil { /** * Returns the difference of the two specified collection of IDs. - * + * * @param ids1 the first collection * @param ids2 the second collection * @return the difference of ids1 minus ids2 @@ -420,7 +421,7 @@ public final class DBIDUtil { /** * Wrap an existing DBIDs collection to be unmodifiable. - * + * * @param existing Existing collection * @return Unmodifiable collection */ @@ -442,7 +443,7 @@ public final class DBIDUtil { /** * Ensure that the given DBIDs are array-indexable. - * + * * @param ids IDs * @return Array DBIDs. */ @@ -457,7 +458,7 @@ public final class DBIDUtil { /** * Ensure that the given DBIDs support fast "contains" operations. - * + * * @param ids IDs * @return Set DBIDs. */ @@ -472,7 +473,7 @@ public final class DBIDUtil { /** * Ensure modifiable. - * + * * @param ids IDs * @return Modifiable DBIDs. */ @@ -493,10 +494,10 @@ public final class DBIDUtil { /** * Make a DBID pair. - * + * * @param id1 first ID * @param id2 second ID - * + * * @return DBID pair */ public static DBIDPair newPair(DBIDRef id1, DBIDRef id2) { @@ -505,7 +506,7 @@ public final class DBIDUtil { /** * Make a DoubleDBIDPair. - * + * * @param val double value * @param id ID * @return new pair @@ -516,9 +517,9 @@ public final class DBIDUtil { /** * Create an appropriate heap for the distance type. - * + * * This will use a double heap if appropriate. - * + * * @param k K value * @return New heap of size k, appropriate for this distance type. */ @@ -528,7 +529,7 @@ public final class DBIDUtil { /** * Build a new heap from a given list. - * + * * @param exist Existing result * @return New heap */ @@ -538,7 +539,7 @@ public final class DBIDUtil { /** * Produce a random shuffling of the given DBID array. - * + * * @param ids Original DBIDs * @param rnd Random generator */ @@ -548,7 +549,7 @@ public final class DBIDUtil { /** * Produce a random shuffling of the given DBID array. - * + * * @param ids Original DBIDs * @param random Random generator */ @@ -558,22 +559,24 @@ public final class DBIDUtil { /** * Produce a random shuffling of the given DBID array. - * - * Only the first {@code limit} elements will be randomized. - * + * + * Only the first {@code limit} elements will be fully randomized, but the + * remaining objects will also be changed. + * * @param ids Original DBIDs * @param random Random generator * @param limit Shuffling limit. */ public static void randomShuffle(ArrayModifiableDBIDs ids, Random random, final int limit) { + final int end = ids.size(); for(int i = 1; i < limit; i++) { - ids.swap(i - 1, i + random.nextInt(limit - i)); + ids.swap(i - 1, i + random.nextInt(end - i)); } } /** * Produce a random sample of the given DBIDs. - * + * * @param source Original DBIDs * @param k k Parameter * @param seed Random generator seed @@ -585,7 +588,7 @@ public final class DBIDUtil { /** * Produce a random sample of the given DBIDs. - * + * * @param source Original DBIDs * @param k k Parameter * @param seed Random generator seed @@ -602,7 +605,7 @@ public final class DBIDUtil { /** * Produce a random sample of the given DBIDs. - * + * * @param source Original DBIDs * @param k k Parameter * @param rnd Random generator @@ -614,7 +617,7 @@ public final class DBIDUtil { /** * Produce a random sample of the given DBIDs. - * + * * @param source Original DBIDs * @param k k Parameter * @param random Random generator @@ -645,7 +648,7 @@ public final class DBIDUtil { ArrayModifiableDBIDs sample = DBIDUtil.newArray(source); randomShuffle(sample, random, k); // Delete trailing elements - for(int i = sample.size() - 1; i > k; i--) { + for(int i = sample.size() - 1; i >= k; i--) { sample.remove(i); } return sample; @@ -654,7 +657,7 @@ public final class DBIDUtil { /** * Produce a random sample of the given DBIDs. - * + * * @param ids Original ids * @param rate Sampling rate * @param random Random generator @@ -666,7 +669,7 @@ public final class DBIDUtil { /** * Produce a random sample of the given DBIDs. - * + * * @param ids Original ids * @param rate Sampling rate * @param random Random generator @@ -711,7 +714,7 @@ public final class DBIDUtil { /** * Randomly split IDs into {@code p} partitions of almost-equal size. - * + * * @param ids Original DBIDs * @param p Desired number of partitions. * @param rnd Random generator @@ -722,7 +725,7 @@ public final class DBIDUtil { /** * Randomly split IDs into {@code p} partitions of almost-equal size. - * + * * @param oids Original DBIDs * @param p Desired number of partitions. * @param random Random generator @@ -752,7 +755,7 @@ public final class DBIDUtil { /** * Get a subset of the KNN result. - * + * * @param list Existing list * @param k k * @return Subset @@ -769,7 +772,7 @@ public final class DBIDUtil { /** * Create a modifiable list to store distance-DBID pairs. - * + * * @param size Estimated upper list size * @return Empty list */ @@ -779,7 +782,7 @@ public final class DBIDUtil { /** * Create a modifiable list to store distance-DBID pairs. - * + * * @return Empty list */ public static ModifiableDoubleDBIDList newDistanceDBIDList() { @@ -788,7 +791,7 @@ public final class DBIDUtil { /** * Assert that the presented ids constitute a continuous {@link DBIDRange}. - * + * * @param ids ID range. * @return DBID range. * @throws AbortException diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDVar.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDVar.java index adfa9aed..80dfaf53 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDVar.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDVar.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.database.datastore.DBIDDataStore; * candidate. * * @author Erich Schubert + * @since 0.4.0 */ public interface DBIDVar extends DBIDRef, ArrayDBIDs, SetDBIDs { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDs.java index 47ab6c2b..95a07f80 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DBIDs.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.database.ids; * Interface for a collection of database references (IDs). * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.composedOf DBID diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DoubleDBIDList.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DoubleDBIDList.java index 4ac19f95..355f9c17 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DoubleDBIDList.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DoubleDBIDList.java @@ -50,6 +50,7 @@ package de.lmu.ifi.dbs.elki.database.ids; * </pre> * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DoubleDBIDListIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DoubleDBIDListIter.java index 92fe9233..6435a048 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DoubleDBIDListIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DoubleDBIDListIter.java @@ -31,6 +31,7 @@ package de.lmu.ifi.dbs.elki.database.ids; * {@link de.lmu.ifi.dbs.elki.database.ids.DBIDRef}. * * @author Erich Schubert + * @since 0.3 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DoubleDBIDListMIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DoubleDBIDListMIter.java index 0e371ff8..638c32ee 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DoubleDBIDListMIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DoubleDBIDListMIter.java @@ -26,6 +26,7 @@ package de.lmu.ifi.dbs.elki.database.ids; * Modifiable DBIDList iterator. * * @author Erich Schubert + * @since 0.2 */ public interface DoubleDBIDListMIter extends DoubleDBIDListIter, DBIDArrayMIter { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DoubleDBIDPair.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DoubleDBIDPair.java index 725861d6..1a49ad56 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DoubleDBIDPair.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/DoubleDBIDPair.java @@ -30,6 +30,7 @@ package de.lmu.ifi.dbs.elki.database.ids; * object reference. * * @author Erich Schubert + * @since 0.2 */ public interface DoubleDBIDPair extends DBIDRef, Comparable<DoubleDBIDPair> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/EmptyDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/EmptyDBIDs.java index 5c1c3e2d..444b632c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/EmptyDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/EmptyDBIDs.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.logging.LoggingUtil; * Empty DBID collection. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf EmptyDBIDIterator */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/HashSetDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/HashSetDBIDs.java index c7deb732..e5a3c4d3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/HashSetDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/HashSetDBIDs.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.database.ids; * Hash-organized DBIDs * * @author Erich Schubert + * @since 0.4.0 */ public interface HashSetDBIDs extends SetDBIDs { // Empty marker interface diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/HashSetModifiableDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/HashSetModifiableDBIDs.java index e5cde131..f3a43b8b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/HashSetModifiableDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/HashSetModifiableDBIDs.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.database.ids; * Set-oriented implementation of a modifiable DBID collection. * * @author Erich Schubert + * @since 0.4.0 */ public interface HashSetModifiableDBIDs extends HashSetDBIDs, ModifiableDBIDs { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/KNNHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/KNNHeap.java index f2ae4c0e..73fddbb2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/KNNHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/KNNHeap.java @@ -31,6 +31,7 @@ package de.lmu.ifi.dbs.elki.database.ids; * {@link de.lmu.ifi.dbs.elki.database.ids.DBIDUtil#newHeap}! * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/KNNList.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/KNNList.java index 94c26a5f..f23e81e2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/KNNList.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/KNNList.java @@ -51,6 +51,7 @@ package de.lmu.ifi.dbs.elki.database.ids; * </pre> * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ModifiableDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ModifiableDBIDs.java index fa88c373..f59f1d92 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ModifiableDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ModifiableDBIDs.java @@ -25,43 +25,46 @@ package de.lmu.ifi.dbs.elki.database.ids; /** * Interface for a generic modifiable DBID collection. - * + * * Note: we had this use the Java Collections API for a long time, however this * prevented certain optimizations. So it now only mimics the Collections API * <em>deliberately</em>. - * + * * @author Erich Schubert - * + * @since 0.4.0 + * * @apiviz.has DBIDMIter */ public interface ModifiableDBIDs extends DBIDs { /** * Add DBIDs to collection. - * + * * @param ids IDs to add. - * @return {@code true} when modified + * @return {@code true} if the collection changed. */ boolean addDBIDs(DBIDs ids); /** * Remove DBIDs from collection. - * + * * @param ids IDs to remove. - * @return {@code true} when modified + * @return {@code true} if the collection changed. */ boolean removeDBIDs(DBIDs ids); /** * Add a single DBID to the collection. - * + * * @param id ID to add + * @return {@code true} if the collection changed. */ boolean add(DBIDRef id); /** * Remove a single DBID from the collection. - * + * * @param id ID to remove + * @return {@code true} if the collection changed. */ boolean remove(DBIDRef id); @@ -72,9 +75,9 @@ public interface ModifiableDBIDs extends DBIDs { /** * Get a <em>modifiable</em> DBID iterator (a more efficient API). - * + * * usage example: - * + * * <pre> * {@code * for(DBIDMIter iter = ids.iter(); iter.valid(); iter.advance()) { @@ -83,7 +86,7 @@ public interface ModifiableDBIDs extends DBIDs { * } * } * </pre> - * + * * @return modifiable iterator */ @Override @@ -93,6 +96,8 @@ public interface ModifiableDBIDs extends DBIDs { * Pop (get and remove) one DBID from the set, into a variable. * * @param outvar Output variable + * @return Always {@code outvar}, for inlining + * @throws ArrayIndexOutOfBoundsException when empty. */ - void pop(DBIDVar outvar); + DBIDVar pop(DBIDVar outvar); }
\ No newline at end of file diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ModifiableDoubleDBIDList.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ModifiableDoubleDBIDList.java index 964e18d0..8b4409ee 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ModifiableDoubleDBIDList.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/ModifiableDoubleDBIDList.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.database.ids; * Modifiable API for Distance-DBID results * * @author Erich Schubert + * @since 0.3 * * @apiviz.composedOf DoubleDBIDPair */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/SetDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/SetDBIDs.java index bcae4fec..cead3cb6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/SetDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/SetDBIDs.java @@ -29,6 +29,7 @@ package de.lmu.ifi.dbs.elki.database.ids; * "contains" lookups. * * @author Erich Schubert + * @since 0.4.0 */ public interface SetDBIDs extends DBIDs { // empty marker interface diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/StaticDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/StaticDBIDs.java index f1b96812..3b4ccc16 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/StaticDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/StaticDBIDs.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.database.ids; * Unmodifiable DBIDs. * * @author Erich Schubert + * @since 0.4.0 */ public interface StaticDBIDs extends DBIDs { // Empty marker interface. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/generic/KNNSubList.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/generic/KNNSubList.java index 1563efd4..770c3792 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/generic/KNNSubList.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/generic/KNNSubList.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.database.ids.KNNList; * Sublist of an existing result to contain only the first k elements. * * @author Erich Schubert + * @since 0.5.5 */ public class KNNSubList implements KNNList { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/generic/MaskedDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/generic/MaskedDBIDs.java index f71498bd..b61b2a98 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/generic/MaskedDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/generic/MaskedDBIDs.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.BitsUtil; * View on an ArrayDBIDs masked using a BitMask for efficient mask changing. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses DBIDs */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/generic/UnmodifiableArrayDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/generic/UnmodifiableArrayDBIDs.java index 637ad758..698e63ab 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/generic/UnmodifiableArrayDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/generic/UnmodifiableArrayDBIDs.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDVar; * Unmodifiable wrapper for DBIDs. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses ArrayDBIDs * @apiviz.has UnmodifiableDBIDArrayIter diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/generic/UnmodifiableDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/generic/UnmodifiableDBIDs.java index 16ff1f81..7ce291e8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/generic/UnmodifiableDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/generic/UnmodifiableDBIDs.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.database.ids.StaticDBIDs; * Unmodifiable wrapper for DBIDs. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses DBIDs * @apiviz.has UnmodifiableDBIDIter diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/AbstractIntegerDBIDFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/AbstractIntegerDBIDFactory.java index cbf29e9c..6ad8c6fe 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/AbstractIntegerDBIDFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/AbstractIntegerDBIDFactory.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.FixedSizeByteBufferSerializer; * Abstract base class for DBID factories. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses IntegerDBID oneway - - «create» * @apiviz.uses IntegerDBIDPair oneway - - «create» @@ -83,7 +84,8 @@ abstract class AbstractIntegerDBIDFactory implements DBIDFactory { @Override public String toString(DBIDRef id) { - return (id != null) ? Integer.toString(id.internalGetIndex()) : "null"; + return (id != null && id.internalGetIndex() != Integer.MIN_VALUE) // + ? Integer.toString(id.internalGetIndex()) : "null"; } @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/ArrayModifiableIntegerDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/ArrayModifiableIntegerDBIDs.java index 835bcd8d..8aa6813c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/ArrayModifiableIntegerDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/ArrayModifiableIntegerDBIDs.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDs; * Class using a primitive int[] array as storage. * * @author Erich Schubert + * @since 0.6.0 */ class ArrayModifiableIntegerDBIDs implements ArrayModifiableDBIDs, IntegerArrayDBIDs { /** @@ -271,7 +272,7 @@ class ArrayModifiableIntegerDBIDs implements ArrayModifiableDBIDs, IntegerArrayD } @Override - public void pop(DBIDVar var) { + public DBIDVar pop(DBIDVar var) { if(size == 0) { throw new ArrayIndexOutOfBoundsException("Cannot pop() from an empty array."); } @@ -282,6 +283,7 @@ class ArrayModifiableIntegerDBIDs implements ArrayModifiableDBIDs, IntegerArrayD // less efficient, involves object creation. var.set(get(--size)); } + return var; } @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/ArrayStaticIntegerDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/ArrayStaticIntegerDBIDs.java index 210dbb15..fb171416 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/ArrayStaticIntegerDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/ArrayStaticIntegerDBIDs.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.logging.LoggingUtil; * Static (no modifications allowed) set of Database Object IDs. * * @author Erich Schubert + * @since 0.4.0 */ class ArrayStaticIntegerDBIDs implements IntegerArrayStaticDBIDs { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDKNNHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDKNNHeap.java index 7162dbc2..1fe22b71 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDKNNHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDKNNHeap.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.heap.DoubleIntegerMaxHeap; * Class to efficiently manage a kNN heap. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has DoubleIntegerDBIDKNNList * @apiviz.composedOf DoubleIntegerMaxHeap diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDKNNList.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDKNNList.java index 449497d1..e0e891e3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDKNNList.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDKNNList.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DoubleDBIDListIter; * the results to be sorted! * * @author Erich Schubert + * @since 0.6.0 */ public class DoubleIntegerDBIDKNNList extends DoubleIntegerDBIDList implements IntegerDBIDKNNList { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDList.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDList.java index 6f551189..9c97f779 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDList.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDList.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arrays.DoubleIntegerArrayQui * Class to store double distance, integer DBID results. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.uses DoubleIntegerArrayQuickSort */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDListIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDListIter.java index 0cd7f33a..f944df03 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDListIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDListIter.java @@ -28,6 +28,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DoubleDBIDListIter; * Combination interface of the DoubleDBIDListIter with IntegerDBIDIter. * * @author Erich Schubert + * @since 0.7.0 */ public interface DoubleIntegerDBIDListIter extends DoubleDBIDListIter, IntegerDBIDIter { // No additional methods. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDListKNNHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDListKNNHeap.java index 82c0f184..4ddf7ba3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDListKNNHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDListKNNHeap.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.database.ids.KNNList; * order. * * @author Erich Schubert + * @since 0.6.0 */ class DoubleIntegerDBIDListKNNHeap extends DoubleIntegerDBIDKNNList implements KNNHeap { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDListMIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDListMIter.java index 59824d85..d46b2952 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDListMIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDListMIter.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DoubleDBIDListMIter; * Combination interface for modifiable iterators. * * @author Erich Schubert + * @since 0.4.0 */ interface DoubleIntegerDBIDListMIter extends DoubleIntegerDBIDListIter, DoubleDBIDListMIter { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDPair.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDPair.java index 7cb247ce..f18ab125 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDPair.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDPair.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DoubleDBIDPair; * Pair containing a double value and an integer DBID. * * @author Erich Schubert + * @since 0.4.0 */ class DoubleIntegerDBIDPair implements DoubleDBIDPair, IntegerDBIDRef { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDPairKNNListHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDPairKNNListHeap.java index ee06d7fa..eb2c8267 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDPairKNNListHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDPairKNNListHeap.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.database.ids.KNNList; * Currently unused, needs benchmarking. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.composedOf DoubleIntegerDBIDPair */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDPairList.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDPairList.java index 990e572f..593ba6ed 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDPairList.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/DoubleIntegerDBIDPairList.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.database.ids.ModifiableDoubleDBIDList; * Currently unused. Needs benchmarking. * * @author Erich Schubert + * @since 0.6.0 */ class DoubleIntegerDBIDPairList implements ModifiableDoubleDBIDList, IntegerDBIDs { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerArrayDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerArrayDBIDs.java index 4afc942a..3f93a4b9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerArrayDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerArrayDBIDs.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.ids.ArrayDBIDs; * Trivial combination interface. * * @author Erich Schubert + * @since 0.4.0 */ public interface IntegerArrayDBIDs extends IntegerDBIDs, ArrayDBIDs { @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerArrayStaticDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerArrayStaticDBIDs.java index fac20bca..c3ba28da 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerArrayStaticDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerArrayStaticDBIDs.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.ids.ArrayStaticDBIDs; * Combination of {@link ArrayStaticDBIDs} and {@link IntegerDBIDs}. * * @author Erich Schubert + * @since 0.4.0 */ interface IntegerArrayStaticDBIDs extends ArrayStaticDBIDs, IntegerArrayDBIDs { @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBID.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBID.java index bdc5196b..11cc8c07 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBID.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBID.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.FixedSizeByteBufferSerializer; * consistent across multiple results/databases. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf DynamicSerializer * @apiviz.composedOf StaticSerializer @@ -100,7 +101,7 @@ final class IntegerDBID implements DBID, IntegerDBIDRef { @Override public String toString() { - return Integer.toString(id); + return (id != Integer.MIN_VALUE) ? Integer.toString(id) : "null"; } @Override @@ -111,11 +112,11 @@ final class IntegerDBID implements DBID, IntegerDBIDRef { @Override @Deprecated public boolean equals(Object obj) { - if (this == obj) { + if(this == obj) { return true; } - if (!(obj instanceof IntegerDBID)) { - if (obj instanceof DBIDRef) { + if(!(obj instanceof IntegerDBID)) { + if(obj instanceof DBIDRef) { LoggingUtil.warning("Programming error: DBID.equals(DBIDRef) is not well-defined. Use DBIDUtil.equal() instead!", new Throwable()); } return false; @@ -137,7 +138,7 @@ final class IntegerDBID implements DBID, IntegerDBIDRef { @Override public DBID get(int i) { - if (i != 0) { + if(i != 0) { throw new ArrayIndexOutOfBoundsException(); } return this; @@ -145,7 +146,7 @@ final class IntegerDBID implements DBID, IntegerDBIDRef { @Override public DBIDVar assignVar(int index, DBIDVar var) { - if (index != 0) { + if(index != 0) { throw new ArrayIndexOutOfBoundsException(); } var.set(this); @@ -165,9 +166,10 @@ final class IntegerDBID implements DBID, IntegerDBIDRef { @Override public ArrayDBIDs slice(int begin, int end) { - if (begin == 0 && end == 1) { + if(begin == 0 && end == 1) { return this; - } else { + } + else { return DBIDUtil.EMPTYDBIDS; } } @@ -232,7 +234,7 @@ final class IntegerDBID implements DBID, IntegerDBIDRef { @Override public boolean equals(Object other) { - if (other instanceof DBID) { + if(other instanceof DBID) { LoggingUtil.warning("Programming error detected: DBIDItr.equals(DBID). Use sameDBID()!", new Throwable()); } return super.equals(other); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDArrayIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDArrayIter.java index f0ac9928..4b120c8c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDArrayIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDArrayIter.java @@ -28,6 +28,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDArrayIter; * Modifiable integer array iterator. * * @author Erich Schubert + * @since 0.4.0 */ interface IntegerDBIDArrayIter extends IntegerDBIDIter, DBIDArrayIter { // Empty diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDArrayMIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDArrayMIter.java index c9234060..946484ec 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDArrayMIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDArrayMIter.java @@ -28,6 +28,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDArrayMIter; * Modifiable integer array iterator. * * @author Erich Schubert + * @since 0.4.0 */ interface IntegerDBIDArrayMIter extends IntegerDBIDArrayIter, IntegerDBIDMIter, DBIDArrayMIter { // Empty diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDArrayQuickSort.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDArrayQuickSort.java index bfbde351..7e020554 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDArrayQuickSort.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDArrayQuickSort.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.uses IntegerArrayDBIDs */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDIter.java index 687a64b2..08b7fa01 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDIter.java @@ -28,6 +28,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDIter; * Iterator for integer DBIDs. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDKNNList.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDKNNList.java index 3fb0d381..c71253de 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDKNNList.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDKNNList.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.ids.KNNList; * Combination interface for KNNList and IntegerDBIDs. * * @author Erich Schubert + * @since 0.7.0 */ public interface IntegerDBIDKNNList extends KNNList, DoubleDBIDList, IntegerDBIDs { @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDKNNSubList.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDKNNSubList.java index 4d1095e0..ac050ab9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDKNNSubList.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDKNNSubList.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DoubleDBIDPair; * Sublist of an existing result to contain only the first k elements. * * @author Erich Schubert + * @since 0.5.5 */ public class IntegerDBIDKNNSubList implements IntegerDBIDKNNList { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDMIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDMIter.java index 6bf1cffd..bf6bfcd8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDMIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDMIter.java @@ -28,6 +28,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDMIter; * Modifiable iterator interface for integer DBIDs. * * @author Erich Schubert + * @since 0.4.0 */ interface IntegerDBIDMIter extends DBIDMIter, IntegerDBIDIter { // Empty. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDPair.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDPair.java index cd50f00e..5ed718d3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDPair.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDPair.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDVar; * DBID pair using two ints for storage. * * @author Erich Schubert + * @since 0.4.0 */ class IntegerDBIDPair implements DBIDPair, IntegerDBIDs { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDRange.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDRange.java index 2b790fb5..b7a21419 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDRange.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDRange.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.database.ids.SetDBIDs; * Representing a DBID range allocation. * * @author Erich Schubert + * @since 0.4.0 */ final class IntegerDBIDRange implements IntegerDBIDs, DBIDRange, SetDBIDs { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDRef.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDRef.java index da21b007..e2cb0b2e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDRef.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDRef.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; * DBID reference that references an integer value. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDVar.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDVar.java index 12e320e9..b2721a20 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDVar.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDVar.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.logging.LoggingUtil; * should come for free! * * @author Erich Schubert + * @since 0.4.0 */ class IntegerDBIDVar implements DBIDVar, IntegerDBIDs { /** @@ -165,7 +166,7 @@ class IntegerDBIDVar implements DBIDVar, IntegerDBIDs { @Override public String toString() { - return Integer.toString(id); + return (id != Integer.MIN_VALUE) ? Integer.toString(id) : "null"; } @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDs.java index 3146f829..50c2b950 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/IntegerDBIDs.java @@ -28,6 +28,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDs; * Integer DBID collection. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has IntegerDBIDIter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/ReusingDBIDFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/ReusingDBIDFactory.java index 02819f0f..ac4715a8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/ReusingDBIDFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/ReusingDBIDFactory.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * TODO: manage fragmentation of ranges? * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.stereotype factory */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/SimpleDBIDFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/SimpleDBIDFactory.java index b49ab39a..99b96b03 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/SimpleDBIDFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/SimpleDBIDFactory.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * negative values. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.stereotype factory diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/TrivialDBIDFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/TrivialDBIDFactory.java index c3e77e99..e9c3b30c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/TrivialDBIDFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/TrivialDBIDFactory.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * sequence. All IDs will be positive. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.stereotype factory diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/TroveHashSetModifiableDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/TroveHashSetModifiableDBIDs.java index 2fc54afd..912a501b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/TroveHashSetModifiableDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/TroveHashSetModifiableDBIDs.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.iterator.Iter; * Implementation using GNU Trove Int Hash Sets. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has Itr */ @@ -158,7 +159,7 @@ class TroveHashSetModifiableDBIDs implements HashSetModifiableDBIDs, IntegerDBID } @Override - public void pop(DBIDVar outvar) { + public DBIDVar pop(DBIDVar outvar) { if(store.size() == 0) { throw new ArrayIndexOutOfBoundsException("Cannot pop() from an empty array."); } @@ -167,9 +168,8 @@ class TroveHashSetModifiableDBIDs implements HashSetModifiableDBIDs, IntegerDBID while(i-- > 0 && (states[i] != TPrimitiveHash.FULL)) { ; // Not occupied. Continue } - if(i < 0) { - outvar.unset(); - return; + if(i < 0) { // Should never happen because size > 0 + throw new ArrayIndexOutOfBoundsException("Cannot pop() from an empty array."); } final int val = store._set[i]; if(outvar instanceof IntegerDBIDVar) { @@ -180,6 +180,7 @@ class TroveHashSetModifiableDBIDs implements HashSetModifiableDBIDs, IntegerDBID } // Unfortunately, not visible: store.removeAt(i); store.remove(val); + return outvar; } /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/UnmodifiableIntegerArrayDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/UnmodifiableIntegerArrayDBIDs.java index b7c1fb87..402b780e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/UnmodifiableIntegerArrayDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/UnmodifiableIntegerArrayDBIDs.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDVar; * Unmodifiable wrapper for DBIDs. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses IntegerArrayDBIDs * @apiviz.has UnmodifiableDBIDIter diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/UnmodifiableIntegerDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/UnmodifiableIntegerDBIDs.java index 2c4ad2f6..cd48f2b3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/UnmodifiableIntegerDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/ids/integer/UnmodifiableIntegerDBIDs.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.database.ids.StaticDBIDs; * Unmodifiable wrapper for DBIDs. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses IntegerDBIDs * @apiviz.has UnmodifiableDBIDIter diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/DatabaseQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/DatabaseQuery.java index 703f0abd..f37694fe 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/DatabaseQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/DatabaseQuery.java @@ -29,6 +29,7 @@ package de.lmu.ifi.dbs.elki.database.query; * Will only contain elemental stuff such as some hints. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/DistanceSimilarityQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/DistanceSimilarityQuery.java index 5f0ea430..aae16b79 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/DistanceSimilarityQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/DistanceSimilarityQuery.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.database.query.similarity.SimilarityQuery; * combined implementations of both. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/LinearScanQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/LinearScanQuery.java index ad580c97..fa4b43b7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/LinearScanQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/LinearScanQuery.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.database.query; * Marker interface for linear scan (slow, non-accelerated) queries. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses de.lmu.ifi.dbs.elki.database.Database */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/AbstractDatabaseDistanceQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/AbstractDatabaseDistanceQuery.java index f37c7cc7..a52da9af 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/AbstractDatabaseDistanceQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/AbstractDatabaseDistanceQuery.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * Run a database query in a database context. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Database object type. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/AbstractDistanceQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/AbstractDistanceQuery.java index b6ea580a..77aeccb4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/AbstractDistanceQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/AbstractDistanceQuery.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * distances. * * @author Erich Schubert + * @since 0.4.0 * * @param O Input object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/DBIDDistanceQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/DBIDDistanceQuery.java index 2cb55529..3185376b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/DBIDDistanceQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/DBIDDistanceQuery.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.DBIDDistanceFunction; * Run a distance query based on DBIDs * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.uses DBIDDistanceFunction diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/DBIDRangeDistanceQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/DBIDRangeDistanceQuery.java index 5976d247..70c17202 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/DBIDRangeDistanceQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/DBIDRangeDistanceQuery.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.DBIDRangeDistanceFunction; * Run a distance query based on DBIDRanges * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.uses DBIDRangeDistanceFunction @@ -59,6 +60,7 @@ public class DBIDRangeDistanceQuery extends DBIDDistanceQuery { public DBIDRangeDistanceQuery(Relation<DBID> relation, DBIDRangeDistanceFunction distanceFunction) { super(relation, distanceFunction); this.range = DBIDUtil.assertRange(relation.getDBIDs()); + distanceFunction.checkRange(this.range); this.distanceFunction = distanceFunction; } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/DistanceQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/DistanceQuery.java index c1ce98a1..6eac7fa8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/DistanceQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/DistanceQuery.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction; * distances. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/PrimitiveDistanceQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/PrimitiveDistanceQuery.java index 1dbd0dff..a91c7e43 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/PrimitiveDistanceQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/PrimitiveDistanceQuery.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.PrimitiveDistanceFunction; * Run a database query in a database context. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.uses PrimitiveDistanceFunction diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/PrimitiveDistanceSimilarityQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/PrimitiveDistanceSimilarityQuery.java index ccea951b..bb2c7d8c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/PrimitiveDistanceSimilarityQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/PrimitiveDistanceSimilarityQuery.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.distance.similarityfunction.PrimitiveSimilarityFuncti * Combination query class, for convenience. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses PrimitiveSimilarityFunction * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/SpatialDistanceQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/SpatialDistanceQuery.java index 21e0deda..9ddc5bdb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/SpatialDistanceQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/SpatialDistanceQuery.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.SpatialPrimitiveDistanceFun * Query interface for spatial distance queries. * * @author Erich Schubert + * @since 0.4.0 * * @param <V> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/SpatialPrimitiveDistanceQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/SpatialPrimitiveDistanceQuery.java index f7272014..50ff7992 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/SpatialPrimitiveDistanceQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/distance/SpatialPrimitiveDistanceQuery.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.SpatialPrimitiveDistanceFun /** * Distance query for spatial distance functions * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses SpatialPrimitiveDistanceFunction * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/AbstractDistanceKNNQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/AbstractDistanceKNNQuery.java index 883e4e74..69856801 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/AbstractDistanceKNNQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/AbstractDistanceKNNQuery.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * Instance for the query on a particular database. * * @author Erich Schubert + * @since 0.4.0 */ public abstract class AbstractDistanceKNNQuery<O> implements KNNQuery<O> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/KNNQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/KNNQuery.java index 67010016..cf214a4e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/KNNQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/KNNQuery.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.database.query.DatabaseQuery; * The interface of an actual instance. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.has KNNList oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/LinearScanDistanceKNNQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/LinearScanDistanceKNNQuery.java index 31e27242..8e362b56 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/LinearScanDistanceKNNQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/LinearScanDistanceKNNQuery.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.database.query.distance.DistanceQuery; * Instance of this query for a particular database. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.has DistanceQuery diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/LinearScanEuclideanDistanceKNNQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/LinearScanEuclideanDistanceKNNQuery.java index e4ca590d..807b194f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/LinearScanEuclideanDistanceKNNQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/LinearScanEuclideanDistanceKNNQuery.java @@ -47,6 +47,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanD * retrieve the query object from the relation only once! * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses PrimitiveDistanceQuery * @apiviz.uses EuclideanDistanceFunction diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/LinearScanPrimitiveDistanceKNNQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/LinearScanPrimitiveDistanceKNNQuery.java index ccb52533..a1234a43 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/LinearScanPrimitiveDistanceKNNQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/LinearScanPrimitiveDistanceKNNQuery.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.PrimitiveDistanceFunction; * retrieve the query object from the relation only once! * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses PrimitiveDistanceQuery * @apiviz.uses PrimitiveDistanceFunction diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/PreprocessorKNNQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/PreprocessorKNNQuery.java index 6a851b80..10957258 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/PreprocessorKNNQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/knn/PreprocessorKNNQuery.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * Instance for a particular database, invoking the preprocessor. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Data object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/AbstractDistanceRangeQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/AbstractDistanceRangeQuery.java index af121f59..809ccf25 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/AbstractDistanceRangeQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/AbstractDistanceRangeQuery.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * instance * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Database object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/LinearScanDistanceRangeQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/LinearScanDistanceRangeQuery.java index 809d563b..bab6521c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/LinearScanDistanceRangeQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/LinearScanDistanceRangeQuery.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.database.query.distance.DistanceQuery; * Default linear scan range query class. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.has DistanceQuery diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/LinearScanEuclideanDistanceRangeQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/LinearScanEuclideanDistanceRangeQuery.java index d89b3b60..74e0bc6b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/LinearScanEuclideanDistanceRangeQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/LinearScanEuclideanDistanceRangeQuery.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.SquaredEuclideanD * Optimized linear scan for Euclidean distance range queries. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses SquaredEuclideanDistanceFunction * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/LinearScanPrimitiveDistanceRangeQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/LinearScanPrimitiveDistanceRangeQuery.java index 80828bd8..aff636fa 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/LinearScanPrimitiveDistanceRangeQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/LinearScanPrimitiveDistanceRangeQuery.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.PrimitiveDistanceFunction; * once from the relation. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses PrimitiveDistanceQuery * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/RangeQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/RangeQuery.java index 3dfe9c5e..f5cf8525 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/RangeQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/range/RangeQuery.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.database.query.DatabaseQuery; * called "range queries". * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.uses DoubleDBIDList oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/rknn/AbstractRKNNQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/rknn/AbstractRKNNQuery.java index 32d19c76..36550fe4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/rknn/AbstractRKNNQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/rknn/AbstractRKNNQuery.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * Instance for the query on a particular database. * * @author Erich Schubert + * @since 0.4.0 */ public abstract class AbstractRKNNQuery<O> implements RKNNQuery<O> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/rknn/LinearScanRKNNQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/rknn/LinearScanRKNNQuery.java index 60a64552..bd16a8a1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/rknn/LinearScanRKNNQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/rknn/LinearScanRKNNQuery.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.database.query.knn.KNNQuery; * Default linear scan RKNN query class. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.has KNNQuery diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/rknn/PreprocessorRKNNQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/rknn/PreprocessorRKNNQuery.java index 2f971854..4be95a39 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/rknn/PreprocessorRKNNQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/rknn/PreprocessorRKNNQuery.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * Instance for a particular database, invoking the preprocessor. * * @author Elke Achtert + * @since 0.4.0 */ public class PreprocessorRKNNQuery<O> implements RKNNQuery<O> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/rknn/RKNNQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/rknn/RKNNQuery.java index a0822585..c45aa782 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/rknn/RKNNQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/rknn/RKNNQuery.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.database.query.DatabaseQuery; * Abstract reverse kNN Query interface. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses DoubleDBIDList oneway - - «create» * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/similarity/AbstractDBIDSimilarityQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/similarity/AbstractDBIDSimilarityQuery.java index 142d0577..f30c4cdb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/similarity/AbstractDBIDSimilarityQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/similarity/AbstractDBIDSimilarityQuery.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * Run a database query in a database context. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Database object type. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/similarity/AbstractSimilarityQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/similarity/AbstractSimilarityQuery.java index 44e10020..08b51dcc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/similarity/AbstractSimilarityQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/similarity/AbstractSimilarityQuery.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * similarity functions. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Input object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/similarity/PrimitiveSimilarityQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/similarity/PrimitiveSimilarityQuery.java index b961222c..450f674e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/similarity/PrimitiveSimilarityQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/similarity/PrimitiveSimilarityQuery.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.distance.similarityfunction.PrimitiveSimilarityFuncti * Run a database query in a database context. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has PrimitiveSimilarityFunction * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/similarity/SimilarityQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/similarity/SimilarityQuery.java index 9f9e2531..7dbf7403 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/similarity/SimilarityQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/query/similarity/SimilarityQuery.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.distance.similarityfunction.SimilarityFunction; * similarity functions. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/AbstractRelation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/AbstractRelation.java index 9022c2d0..21694a4c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/AbstractRelation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/AbstractRelation.java @@ -49,6 +49,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * Abstract base class for relations. * * @author Erich Schubert + * @since 0.7.0 * * @param <O> Data type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/ConvertToStringView.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/ConvertToStringView.java index df4da4ef..6ab6753c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/ConvertToStringView.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/ConvertToStringView.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * representation. * * @author Erich Schubert + * @since 0.4.0 */ public class ConvertToStringView extends AbstractRelation<String> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/DBIDView.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/DBIDView.java index f2a3b741..612b0755 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/DBIDView.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/DBIDView.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * Pseudo-representation that is the object ID itself. * * @author Erich Schubert + * @since 0.4.0 */ public class DBIDView extends AbstractRelation<DBID> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/DoubleRelation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/DoubleRelation.java index 73641b9c..35ce7bc4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/DoubleRelation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/DoubleRelation.java @@ -28,6 +28,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; * Interface for double-valued relations. * * @author Erich Schubert + * @since 0.7.0 */ public interface DoubleRelation extends ModifiableRelation<Double> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/MaterializedDoubleRelation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/MaterializedDoubleRelation.java index 0d9c2a21..2b2d6ef7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/MaterializedDoubleRelation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/MaterializedDoubleRelation.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * set(), remove the DBID, then delete(). * * @author Erich Schubert + * @since 0.4.0 */ public class MaterializedDoubleRelation extends AbstractRelation<Double>implements DoubleRelation { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/MaterializedRelation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/MaterializedRelation.java index a7aa2995..463c5c26 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/MaterializedRelation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/MaterializedRelation.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * TODO: is this semantic sane? * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Data type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/ModifiableRelation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/ModifiableRelation.java index 0127fa66..98cd93a5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/ModifiableRelation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/ModifiableRelation.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; * creation (i.e. notifying them of inserts and deletions). * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Data type. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/ProjectedView.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/ProjectedView.java index 513dab9d..170d5ad2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/ProjectedView.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/ProjectedView.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * Projected relation view (non-materialized) * * @author Erich Schubert + * @since 0.4.0 * * @param <IN> Vector type * @param <OUT> Vector type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/ProxyView.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/ProxyView.java index 51306d52..03221e94 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/ProxyView.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/ProxyView.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * passed on to the wrapped representation. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/Relation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/Relation.java index 88b4b18d..9bc9eff2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/Relation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/Relation.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.result.HierarchicalResult; * An object representation from a database. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses DBIDRef * @apiviz.exclude TooltipStringVisualization diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/RelationUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/RelationUtil.java index ac9fed6d..2dd8c62e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/RelationUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/database/relation/RelationUtil.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDs; * Utility functions for handling database relation. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.uses Relation oneway * @apiviz.has CollectionFromRelation diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/AbstractDatabaseConnection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/AbstractDatabaseConnection.java index e75187d4..72c1ff98 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/AbstractDatabaseConnection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/AbstractDatabaseConnection.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * already provides the setting of the database according to parameters. * * @author Elke Achtert + * @since 0.2 * * @apiviz.uses ObjectFilter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/ArrayAdapterDatabaseConnection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/ArrayAdapterDatabaseConnection.java index 316ead88..a9cb0cd1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/ArrayAdapterDatabaseConnection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/ArrayAdapterDatabaseConnection.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * Note: this class is not parameterizable, but can only be used from Java. * * @author Erich Schubert + * @since 0.5.0 */ public class ArrayAdapterDatabaseConnection implements DatabaseConnection { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/BundleDatabaseConnection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/BundleDatabaseConnection.java index 58d2bbf7..2abd6f83 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/BundleDatabaseConnection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/BundleDatabaseConnection.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.FileParameter; * indexes. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.composedOf BundleReader */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/ConcatenateFilesDatabaseConnection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/ConcatenateFilesDatabaseConnection.java index ce639606..c5f98815 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/ConcatenateFilesDatabaseConnection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/ConcatenateFilesDatabaseConnection.java @@ -51,6 +51,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.FileListParameter * Database that will loading multiple files, concatenating the results. * * @author Erich Schubert + * @since 0.5.0 */ public class ConcatenateFilesDatabaseConnection extends AbstractDatabaseConnection { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/DBIDRangeDatabaseConnection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/DBIDRangeDatabaseConnection.java index 117a9eaa..2a50859e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/DBIDRangeDatabaseConnection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/DBIDRangeDatabaseConnection.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * This is useful when using e.g. a distance matrix to access external data. * * @author Erich Schubert + * @since 0.5.0 */ @Description("This class generates a sequence of DBIDs to 'load' into a database. This is useful when using an external data matrix, and not requiring access to the actual vectors.") public class DBIDRangeDatabaseConnection implements DatabaseConnection { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/DatabaseConnection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/DatabaseConnection.java index 77adf35b..42b62315 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/DatabaseConnection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/DatabaseConnection.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.datasource.bundle.MultipleObjectsBundle; * an intermediate connection to a database system. * * @author Arthur Zimek + * @since 0.2 * * @apiviz.landmark * @apiviz.has MultipleObjectsBundle diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/EmptyDatabaseConnection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/EmptyDatabaseConnection.java index 4fb02813..f1198774 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/EmptyDatabaseConnection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/EmptyDatabaseConnection.java @@ -25,6 +25,7 @@ package de.lmu.ifi.dbs.elki.datasource; import de.lmu.ifi.dbs.elki.datasource.bundle.MultipleObjectsBundle; import de.lmu.ifi.dbs.elki.logging.Logging; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; import de.lmu.ifi.dbs.elki.utilities.documentation.Title; @@ -32,9 +33,11 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * Pseudo database that is empty. * * @author Erich Schubert + * @since 0.3 */ @Title("Empty Database") @Description("Dummy data source that does not provide any objects.") +@Alias("de.lmu.ifi.dbs.elki.database.connection.EmptyDatabaseConnection") public class EmptyDatabaseConnection extends AbstractDatabaseConnection { /** * Static logger @@ -59,4 +62,4 @@ public class EmptyDatabaseConnection extends AbstractDatabaseConnection { protected Logging getLogger() { return LOG; } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/ExternalIDJoinDatabaseConnection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/ExternalIDJoinDatabaseConnection.java index 771f6c80..a04fb46d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/ExternalIDJoinDatabaseConnection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/ExternalIDJoinDatabaseConnection.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectListParamet * Joins multiple data sources by their label * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses ExternalID */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/FileBasedDatabaseConnection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/FileBasedDatabaseConnection.java index 3fffb19d..a96b5f16 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/FileBasedDatabaseConnection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/FileBasedDatabaseConnection.java @@ -31,7 +31,10 @@ import java.io.InputStream; import java.util.List; import de.lmu.ifi.dbs.elki.datasource.filter.ObjectFilter; +import de.lmu.ifi.dbs.elki.datasource.parser.ArffParser; +import de.lmu.ifi.dbs.elki.datasource.parser.NumberVectorLabelParser; import de.lmu.ifi.dbs.elki.datasource.parser.Parser; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.FileUtil; import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; @@ -42,9 +45,11 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.FileParameter; * File based database connection based on the parser to be set. * * @author Arthur Zimek + * @since 0.2 * * @apiviz.landmark */ +@Alias("de.lmu.ifi.dbs.elki.database.connection.FileBasedDatabaseConnection") public class FileBasedDatabaseConnection extends InputStreamDatabaseConnection { /** * Constructor. @@ -115,12 +120,18 @@ public class FileBasedDatabaseConnection extends InputStreamDatabaseConnection { @Override protected void makeOptions(Parameterization config) { + Class<? extends Parser> defaultParser = NumberVectorLabelParser.class; // Add the input file first, for usability reasons. final FileParameter inputParam = new FileParameter(INPUT_ID, FileParameter.FileType.INPUT_FILE); if(config.grab(inputParam)) { infile = inputParam.getValue(); + String nam = infile.getName(); + if(nam != null && (nam.endsWith(".arff") || nam.endsWith(".arff.gz"))) { + defaultParser = ArffParser.class; + } } - super.makeOptions(config); + configParser(config, Parser.class, defaultParser); + configFilters(config); } @Override @@ -128,4 +139,4 @@ public class FileBasedDatabaseConnection extends InputStreamDatabaseConnection { return new FileBasedDatabaseConnection(filters, parser, infile); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/GeneratorXMLDatabaseConnection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/GeneratorXMLDatabaseConnection.java index 8d3df23b..201122ce 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/GeneratorXMLDatabaseConnection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/GeneratorXMLDatabaseConnection.java @@ -75,6 +75,7 @@ import de.lmu.ifi.dbs.elki.utilities.xml.XMLNodeIterator; * supported) data sets that satisfy a given specification file. * * @author Erich Schubert + * @since 0.2 * * @apiviz.composedOf GeneratorMain */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/InputStreamDatabaseConnection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/InputStreamDatabaseConnection.java index 444e15af..e82a2354 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/InputStreamDatabaseConnection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/InputStreamDatabaseConnection.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * Database connection expecting input from an input stream such as stdin. * * @author Arthur Zimek + * @since 0.2 * * @apiviz.uses Parser oneway - - runs */ @@ -132,7 +133,6 @@ public class InputStreamDatabaseConnection extends AbstractDatabaseConnection { public static class Parameterizer extends AbstractDatabaseConnection.Parameterizer { @Override protected void makeOptions(Parameterization config) { - super.makeOptions(config); configParser(config, Parser.class, NumberVectorLabelParser.class); configFilters(config); } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/LabelJoinDatabaseConnection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/LabelJoinDatabaseConnection.java index 2e9e5fc9..28f010e3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/LabelJoinDatabaseConnection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/LabelJoinDatabaseConnection.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectListParamet * Joins multiple data sources by their label * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses LabelList */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/MultipleObjectsBundleDatabaseConnection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/MultipleObjectsBundleDatabaseConnection.java index 249135c8..94b9aaa0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/MultipleObjectsBundleDatabaseConnection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/MultipleObjectsBundleDatabaseConnection.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.datasource.bundle.MultipleObjectsBundle; * database. * * @author Erich Schubert + * @since 0.4.0 */ public class MultipleObjectsBundleDatabaseConnection implements DatabaseConnection { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/PresortedBlindJoinDatabaseConnection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/PresortedBlindJoinDatabaseConnection.java index 1f36c0bf..2c7a0dc9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/PresortedBlindJoinDatabaseConnection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/PresortedBlindJoinDatabaseConnection.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectListParamet * sources are ordered appropriately! * * @author Erich Schubert + * @since 0.5.0 */ @Description("Blindly joins multiple data sources, assuming they are ordered the same way.") public class PresortedBlindJoinDatabaseConnection extends AbstractDatabaseConnection { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/RandomDoubleVectorDatabaseConnection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/RandomDoubleVectorDatabaseConnection.java index 701f51c5..a34f8fe4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/RandomDoubleVectorDatabaseConnection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/RandomDoubleVectorDatabaseConnection.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * Produce a database of random double vectors with each dimension in [0:1]. * * @author Erich Schubert + * @since 0.4.0 */ public class RandomDoubleVectorDatabaseConnection extends AbstractDatabaseConnection { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/BundleMeta.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/BundleMeta.java index 041961ae..2be09983 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/BundleMeta.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/BundleMeta.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.data.type.SimpleTypeInformation; * it improves code readability and type safety. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf SimpleTypeInformation */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/BundleReader.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/BundleReader.java index e0534408..a9ee6dce 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/BundleReader.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/BundleReader.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteBufferSerializer; * TODO: resize buffer when necessary? * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.uses MappedByteBuffer - - «reads» * @apiviz.uses FileChannel - - «reads» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/BundleStreamSource.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/BundleStreamSource.java index 7e98c135..9254e9da 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/BundleStreamSource.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/BundleStreamSource.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDVar; * Soruce for a bundle stream * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf BundleMeta * @apiviz.has BundleStreamSource.Event diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/BundleWriter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/BundleWriter.java index f4c2ece3..f5e3af9d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/BundleWriter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/BundleWriter.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteBufferSerializer; * Bundle streams that add new columns are not supported. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.uses BundleStreamSource - - «reads» * @apiviz.uses WritableByteChannel - - «writes» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/MultipleObjectsBundle.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/MultipleObjectsBundle.java index a910fb56..507ef6a6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/MultipleObjectsBundle.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/MultipleObjectsBundle.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * with multiple representations outside of any index structure. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/ObjectBundle.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/ObjectBundle.java index 46ab032e..3af418c4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/ObjectBundle.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/ObjectBundle.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDVar; * Shared API for both single-object and multi-object packages. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf BundleMeta */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/SingleObjectBundle.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/SingleObjectBundle.java index 0f93bcd1..0eacf962 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/SingleObjectBundle.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/SingleObjectBundle.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDVar; * representations outside of any index structure. * * @author Erich Schubert + * @since 0.4.0 */ public class SingleObjectBundle implements ObjectBundle { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/StreamFromBundle.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/StreamFromBundle.java index 10762d4b..085aacdf 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/StreamFromBundle.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/bundle/StreamFromBundle.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDVar; * To use this, invoke {@link MultipleObjectsBundle#asStream()}. * * @author Erich Schubert + * @since 0.4.0 */ public class StreamFromBundle implements BundleStreamSource { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractConversionFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractConversionFilter.java index 57eb6501..dbb492d5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractConversionFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractConversionFilter.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * Abstract base class for simple conversion filters such as normalizations and projections. * * @author Erich Schubert + * @since 0.4.0 * * @param <I> Input object type * @param <O> Input object type @@ -74,7 +75,7 @@ public abstract class AbstractConversionFilter<I, O> implements ObjectFilter { // When necessary, perform an initialization scan if(prepareStart(castType)) { - FiniteProgress pprog = logger.isVerbose() ? new FiniteProgress("Preparing normalization.", objects.dataLength(), logger) : null; + FiniteProgress pprog = logger.isVerbose() ? new FiniteProgress("Preparing normalization", objects.dataLength(), logger) : null; for(Object o : column) { @SuppressWarnings("unchecked") final I obj = (I) o; @@ -90,7 +91,7 @@ public abstract class AbstractConversionFilter<I, O> implements ObjectFilter { bundle.appendColumn(convertedType(castType), castColumn); // Normalization scan - FiniteProgress nprog = logger.isVerbose() ? new FiniteProgress("Data normalization.", objects.dataLength(), logger) : null; + FiniteProgress nprog = logger.isVerbose() ? new FiniteProgress("Data normalization", objects.dataLength(), logger) : null; for(int i = 0; i < objects.dataLength(); i++) { @SuppressWarnings("unchecked") final I obj = (I) column.get(i); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractStreamConversionFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractStreamConversionFilter.java index 19aa0d53..57b8474a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractStreamConversionFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractStreamConversionFilter.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.datasource.bundle.BundleMeta; * projections. * * @author Erich Schubert + * @since 0.5.0 * * @param <I> Input object type * @param <O> Input object type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractStreamFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractStreamFilter.java index f2cf7e62..19d8ce05 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractStreamFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractStreamFilter.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.datasource.bundle.MultipleObjectsBundle; * Abstract base class for streaming filters. * * @author Erich Schubert + * @since 0.4.0 */ public abstract class AbstractStreamFilter implements StreamFilter { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractVectorConversionFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractVectorConversionFilter.java index 4c4e92bd..4da87ed1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractVectorConversionFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractVectorConversionFilter.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.data.type.SimpleTypeInformation; * Abstract class for filters that produce number vectors. * * @author Erich Schubert + * @since 0.4.0 * * @param <I> Input vector type * @param <O> Output vector type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractVectorStreamConversionFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractVectorStreamConversionFilter.java index b5111a22..80edde67 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractVectorStreamConversionFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/AbstractVectorStreamConversionFilter.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.data.type.SimpleTypeInformation; * Abstract base class for streaming filters that produce vectors. * * @author Erich Schubert + * @since 0.4.0 * * @param <I> Input type * @param <O> Output vector type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/FilterUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/FilterUtil.java index d8da0f62..2dc97ef0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/FilterUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/FilterUtil.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.logging.LoggingUtil; * Utilities for implementing filters. * * @author Erich Schubert + * @since 0.4.0 */ public final class FilterUtil { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/FixedDBIDsFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/FixedDBIDsFilter.java index f6ae4a41..0177acb4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/FixedDBIDsFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/FixedDBIDsFilter.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * the bundle by adding a column of DBID type to the bundle. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has DBIDRange oneway - - «produces» */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/NoOpFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/NoOpFilter.java index 872daf19..c8c77e0e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/NoOpFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/NoOpFilter.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.datasource.bundle.MultipleObjectsBundle; * just use this dummy filter as first parameter. * * @author Erich Schubert + * @since 0.4.0 */ public class NoOpFilter extends AbstractStreamFilter { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/ObjectFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/ObjectFilter.java index cbf5fa85..ed541778 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/ObjectFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/ObjectFilter.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.datasource.bundle.MultipleObjectsBundle; * Object filters as part of the input step. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/StreamFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/StreamFilter.java index 2e07c52c..9157967e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/StreamFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/StreamFilter.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.datasource.bundle.BundleStreamSource; * keep a reference to earlier data. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/cleaning/DropNaNFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/cleaning/DropNaNFilter.java index 8eb54ab4..21300cea 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/cleaning/DropNaNFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/cleaning/DropNaNFilter.java @@ -44,8 +44,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * TODO: add support for sparse vectors. * * @author Erich Schubert + * @since 0.4.0 */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.DropNaNFilter" }) +@Alias("de.lmu.ifi.dbs.elki.datasource.filter.DropNaNFilter") public class DropNaNFilter extends AbstractStreamFilter { /** * Class logger diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/cleaning/NoMissingValuesFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/cleaning/NoMissingValuesFilter.java index 32b92a8a..a7c425e4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/cleaning/NoMissingValuesFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/cleaning/NoMissingValuesFilter.java @@ -36,8 +36,10 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * A filter to remove entries that have missing values. * * @author Erich Schubert + * @since 0.4.0 */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.NoMissingValuesFilter" }) +@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.FilterNoMissingValuesFilter", // +"de.lmu.ifi.dbs.elki.datasource.filter.NoMissingValuesFilter" }) public class NoMissingValuesFilter extends AbstractStreamFilter { /** * Class logger @@ -130,4 +132,4 @@ public class NoMissingValuesFilter extends AbstractStreamFilter { return new NoMissingValuesFilter(); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/cleaning/ReplaceNaNWithRandomFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/cleaning/ReplaceNaNWithRandomFilter.java index 6ee9e220..a5222d8f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/cleaning/ReplaceNaNWithRandomFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/cleaning/ReplaceNaNWithRandomFilter.java @@ -48,8 +48,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * TODO: add support for sparse vectors. * * @author Erich Schubert + * @since 0.4.0 */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.ReplaceNaNWithRandomFilter" }) +@Alias("de.lmu.ifi.dbs.elki.datasource.filter.ReplaceNaNWithRandomFilter") public class ReplaceNaNWithRandomFilter extends AbstractStreamFilter { /** * Class logger diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/cleaning/VectorDimensionalityFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/cleaning/VectorDimensionalityFilter.java index d0bafa31..33a9c13f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/cleaning/VectorDimensionalityFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/cleaning/VectorDimensionalityFilter.java @@ -44,10 +44,10 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * Filter to remove all vectors that do not have the desired dimensionality. * * @author Erich Schubert + * @since 0.7.0 * * @param <V> Vector type */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.VectorDimensionalityFilter" }) public class VectorDimensionalityFilter<V extends NumberVector> extends AbstractStreamFilter { /** * Class logger. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/AbstractNormalization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/AbstractNormalization.java index e0cd3f09..0e6f783b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/AbstractNormalization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/AbstractNormalization.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.LinearEquationSystem; * Abstract super class for all normalizations. * * @author Elke Achtert + * @since 0.4.0 * * @param <V> Object type processed */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/AbstractStreamNormalization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/AbstractStreamNormalization.java index 1e61a206..e8b099ce 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/AbstractStreamNormalization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/AbstractStreamNormalization.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.LinearEquationSystem; * Abstract super class for all normalizations. * * @author Erich Schubert + * @since 0.4.0 * * @param <V> Object type processed */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/NonNumericFeaturesException.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/NonNumericFeaturesException.java index 16175bc8..4f8cfb56 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/NonNumericFeaturesException.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/NonNumericFeaturesException.java @@ -29,6 +29,7 @@ package de.lmu.ifi.dbs.elki.datasource.filter.normalization; * features have been expected. * * @author Arthur Zimek + * @since 0.4.0 */ public class NonNumericFeaturesException extends Exception { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/Normalization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/Normalization.java index 26393bd9..ea08a93e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/Normalization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/Normalization.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.LinearEquationSystem; * dependencies quantitatively adapted to the original space. * * @author Arthur Zimek + * @since 0.4.0 * * @apiviz.landmark * @apiviz.has NonNumericFeaturesException diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseBetaNormalization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseBetaNormalization.java index 2500a370..1b9b9d6d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseBetaNormalization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseBetaNormalization.java @@ -59,13 +59,13 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectListParamet * this. * * @author Erich Schubert + * @since 0.6.0 * * @param <V> vector type * * @apiviz.uses NumberVector * @apiviz.uses DistributionEstimator */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.AttributeWiseBetaNormalization"}) public class AttributeWiseBetaNormalization<V extends NumberVector> implements Normalization<V> { /** * Class logger. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseCDFNormalization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseCDFNormalization.java index d4028f1e..6d2f77e8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseCDFNormalization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseCDFNormalization.java @@ -64,6 +64,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectListParamet * but they do not detail how to obtain an appropriate function `F`. * * @author Erich Schubert + * @since 0.6.0 * @param <V> vector type * * @apiviz.uses NumberVector diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseErfNormalization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseErfNormalization.java index 83d24244..a099e533 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseErfNormalization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseErfNormalization.java @@ -36,12 +36,14 @@ import de.lmu.ifi.dbs.elki.utilities.Alias; * sense when you have data that has been mean-variance normalized before. * * @author Erich Schubert + * @since 0.4.0 * * @param <V> Object type * * @apiviz.uses NumberVector */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.AttributeWiseErfNormalization"}) +@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.AttributeWiseErfNormalization", // +"de.lmu.ifi.dbs.elki.datasource.filter.AttributeWiseErfNormalization" }) public class AttributeWiseErfNormalization<V extends NumberVector> extends AbstractNormalization<V> { /** * Class logger. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseMADNormalization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseMADNormalization.java index cdb60a4d..165aa4a1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseMADNormalization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseMADNormalization.java @@ -52,6 +52,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.ExceptionMessages; * robust towards outliers, and only slightly more expensive to compute. * * @author Erich Schubert + * @since 0.6.0 * @param <V> vector type * * @apiviz.uses NumberVector @@ -111,7 +112,7 @@ public class AttributeWiseMADNormalization<V extends NumberVector> implements No // Scratch space for testing: double[] test = new double[castColumn.size()]; - FiniteProgress dprog = LOG.isVerbose() ? new FiniteProgress("Analyzing data.", dim, LOG) : null; + FiniteProgress dprog = LOG.isVerbose() ? new FiniteProgress("Analyzing data", dim, LOG) : null; // We iterate over dimensions, this kind of filter needs fast random // access. for(int d = 0; d < dim; d++) { @@ -147,7 +148,7 @@ public class AttributeWiseMADNormalization<V extends NumberVector> implements No } LOG.ensureCompleted(dprog); - FiniteProgress nprog = LOG.isVerbose() ? new FiniteProgress("Data normalization.", objects.dataLength(), LOG) : null; + FiniteProgress nprog = LOG.isVerbose() ? new FiniteProgress("Data normalization", objects.dataLength(), LOG) : null; // Normalization scan double[] buf = new double[dim]; for(int i = 0; i < objects.dataLength(); i++) { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseMeanNormalization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseMeanNormalization.java index 350f6188..4aedfe3d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseMeanNormalization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseMeanNormalization.java @@ -38,11 +38,11 @@ import de.lmu.ifi.dbs.elki.utilities.FormatUtil; * attribute is scaled to have the same mean (but 0 is not changed). * * @author Erich Schubert + * @since 0.7.0 * @param <V> vector type * * @apiviz.uses NumberVector */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.AttributeWiseMeanNormalization"}) public class AttributeWiseMeanNormalization<V extends NumberVector> extends AbstractNormalization<V> { /** * Class logger. @@ -204,4 +204,4 @@ public class AttributeWiseMeanNormalization<V extends NumberVector> extends Abst protected SimpleTypeInformation<? super V> getInputTypeRestriction() { return TypeUtil.NUMBER_VECTOR_FIELD; } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseMinMaxNormalization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseMinMaxNormalization.java index 7981d4f5..8fbff47e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseMinMaxNormalization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseMinMaxNormalization.java @@ -44,11 +44,13 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleListParamet * given minimum and maximum in each dimension. * * @author Elke Achtert + * @since 0.4.0 * @param <V> vector type * * @apiviz.uses NumberVector */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.AttributeWiseMinMaxNormalization" }) +@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.AttributeWiseMinMaxNormalization", // +"de.lmu.ifi.dbs.elki.datasource.filter.AttributeWiseMinMaxNormalization" }) public class AttributeWiseMinMaxNormalization<V extends NumberVector> extends AbstractNormalization<V> { /** * Class logger. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseVarianceNormalization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseVarianceNormalization.java index e997b907..d53f7ffd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseVarianceNormalization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/AttributeWiseVarianceNormalization.java @@ -46,11 +46,13 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleListParamet * given mean and standard deviation in each dimension. * * @author Erich Schubert + * @since 0.4.0 * @param <V> vector type * * @apiviz.uses NumberVector */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.AttributeWiseVarianceNormalization", "z" }) +@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.AttributeWiseVarianceNormalization", // +"z", "de.lmu.ifi.dbs.elki.datasource.filter.AttributeWiseVarianceNormalization" }) public class AttributeWiseVarianceNormalization<V extends NumberVector> extends AbstractNormalization<V> { /** * Class logger. @@ -277,4 +279,4 @@ public class AttributeWiseVarianceNormalization<V extends NumberVector> extends return new AttributeWiseVarianceNormalization<>(mean, stddev); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/IntegerRankTieNormalization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/IntegerRankTieNormalization.java index 03c98023..d9733b78 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/IntegerRankTieNormalization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/IntegerRankTieNormalization.java @@ -45,8 +45,9 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arrays.IntegerComparator; * then, followed by the next on "4") * * @author Erich Schubert + * @since 0.5.0 */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.IntegerRankTieNormalization"}) +@Alias("de.lmu.ifi.dbs.elki.datasource.filter.normalization.RankTieNormalization") public class IntegerRankTieNormalization implements ObjectFilter { /** * Constructor. @@ -147,4 +148,4 @@ public class IntegerRankTieNormalization implements ObjectFilter { return (vx < vy) ? -1 : (vx == vy) ? 0 : +1; } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/InverseDocumentFrequencyNormalization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/InverseDocumentFrequencyNormalization.java index 3ebce57d..6b730fc1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/InverseDocumentFrequencyNormalization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/columnwise/InverseDocumentFrequencyNormalization.java @@ -38,12 +38,14 @@ import de.lmu.ifi.dbs.elki.utilities.Alias; * frequency (IDF). See also: TF-IDF for text analysis. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses SparseNumberVector * * @param <V> Vector type */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.InverseDocumentFrequencyNormalization" }) +@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.InverseDocumentFrequencyNormalization", // +"de.lmu.ifi.dbs.elki.datasource.filter.InverseDocumentFrequencyNormalization" }) public class InverseDocumentFrequencyNormalization<V extends SparseNumberVector> extends AbstractNormalization<V> { /** * Class logger. @@ -127,4 +129,4 @@ public class InverseDocumentFrequencyNormalization<V extends SparseNumberVector> protected Logging getLogger() { return LOG; } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/HellingerHistogramNormalization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/HellingerHistogramNormalization.java index a79a3047..352e96dd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/HellingerHistogramNormalization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/HellingerHistogramNormalization.java @@ -39,10 +39,10 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * {@link de.lmu.ifi.dbs.elki.distance.distancefunction.probabilistic.HellingerDistanceFunction} * * @author Erich Schubert + * @since 0.7.0 * * @param <V> vector type */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.HellingerHistogramNormalization" }) public class HellingerHistogramNormalization<V extends NumberVector> extends AbstractStreamNormalization<V> { /** * Static instance. @@ -94,4 +94,4 @@ public class HellingerHistogramNormalization<V extends NumberVector> extends Abs return STATIC; } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/InstanceLogRankNormalization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/InstanceLogRankNormalization.java index 8f46b156..d8d0ff95 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/InstanceLogRankNormalization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/InstanceLogRankNormalization.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * largest is 1, but using log_2(1+x). * * @author Erich Schubert + * @since 0.7.0 * * @param <V> vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/InstanceMeanVarianceNormalization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/InstanceMeanVarianceNormalization.java index a546ccd8..fa1eb6d1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/InstanceMeanVarianceNormalization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/InstanceMeanVarianceNormalization.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Normalize vectors such that they have zero mean and unit variance. * * @author Erich Schubert + * @since 0.7.0 * * @param <V> vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/InstanceMinMaxNormalization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/InstanceMinMaxNormalization.java index f0b1ceea..fbbd4d46 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/InstanceMinMaxNormalization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/InstanceMinMaxNormalization.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Normalize vectors such that the smallest attribute is 0, the largest is 1. * * @author Erich Schubert + * @since 0.7.0 * * @param <V> vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/InstanceRankNormalization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/InstanceRankNormalization.java index f6058ecb..bd85d912 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/InstanceRankNormalization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/InstanceRankNormalization.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * largest is 1. * * @author Erich Schubert + * @since 0.7.0 * * @param <V> vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/LengthNormalization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/LengthNormalization.java index df00683e..b82d1eba 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/LengthNormalization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/LengthNormalization.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * * @author Heidi Kolb * @author Erich Schubert + * @since 0.5.0 * * @param <V> vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/Log1PlusNormalization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/Log1PlusNormalization.java index 04e27e73..737869ae 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/Log1PlusNormalization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/normalization/instancewise/Log1PlusNormalization.java @@ -41,10 +41,10 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * By default b=1, and thus the transformation is log2(1+|x|). * * @author Erich Schubert + * @since 0.5.0 * * @param <V> vector type */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.Log1PlusNormalization" }) public class Log1PlusNormalization<V extends NumberVector> extends AbstractStreamNormalization<V> { /** * Static instance. @@ -116,4 +116,4 @@ public class Log1PlusNormalization<V extends NumberVector> extends AbstractStrea return new Log1PlusNormalization<>(boost); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/selection/ByLabelFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/selection/ByLabelFilter.java index 381001c0..962e3a7a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/selection/ByLabelFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/selection/ByLabelFilter.java @@ -42,10 +42,12 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.PatternParameter; * A filter to select data set by their label. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses LabelList oneway - - «reads» */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.ByLabelFilter" }) +@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.ByLabelFilter", // +"de.lmu.ifi.dbs.elki.datasource.filter.FilterByLabelFilter" }) public class ByLabelFilter extends AbstractStreamFilter { /** * Class logger @@ -195,4 +197,4 @@ public class ByLabelFilter extends AbstractStreamFilter { return new ByLabelFilter(pattern, inverted); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/selection/RandomSamplingStreamFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/selection/RandomSamplingStreamFilter.java index faf6276f..9418a6c1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/selection/RandomSamplingStreamFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/selection/RandomSamplingStreamFilter.java @@ -40,8 +40,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * Subsampling stream filter. * * @author Erich Schubert + * @since 0.5.0 */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.RandomSamplingStreamFilter" }) +@Alias("de.lmu.ifi.dbs.elki.datasource.filter.RandomSamplingStreamFilter") public class RandomSamplingStreamFilter extends AbstractStreamFilter { /** * Probability diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/selection/ShuffleObjectsFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/selection/ShuffleObjectsFilter.java index 1d86a59d..16afb512 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/selection/ShuffleObjectsFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/selection/ShuffleObjectsFilter.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * A filter to shuffle the dataset. * * @author Erich Schubert + * @since 0.4.0 */ @Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.ShuffleObjectsFilter" }) public class ShuffleObjectsFilter implements ObjectFilter { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/selection/SortByLabelFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/selection/SortByLabelFilter.java index d1a7beb8..5b833c07 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/selection/SortByLabelFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/selection/SortByLabelFilter.java @@ -39,10 +39,11 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * A filter to sort the data set by some label. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses de.lmu.ifi.dbs.elki.data.LabelList oneway - - «reads» */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.SortByLabelFilter" }) +@Alias("de.lmu.ifi.dbs.elki.datasource.filter.SortByLabelFilter") public class SortByLabelFilter implements ObjectFilter { /** * Class logger diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/AbstractSupervisedProjectionVectorFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/AbstractSupervisedProjectionVectorFilter.java index bd89e7f1..3854ee7d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/AbstractSupervisedProjectionVectorFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/AbstractSupervisedProjectionVectorFilter.java @@ -23,9 +23,6 @@ package de.lmu.ifi.dbs.elki.datasource.filter.transform; along with this program. If not, see <http://www.gnu.org/licenses/>. */ -import gnu.trove.list.TIntList; -import gnu.trove.list.array.TIntArrayList; - import java.util.HashMap; import java.util.Iterator; import java.util.List; @@ -42,12 +39,13 @@ import de.lmu.ifi.dbs.elki.datasource.filter.typeconversions.ClassLabelFilter; import de.lmu.ifi.dbs.elki.logging.Logging; import de.lmu.ifi.dbs.elki.math.linearalgebra.Matrix; import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; -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.OptionID; import de.lmu.ifi.dbs.elki.utilities.optionhandling.constraints.CommonConstraints; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; +import gnu.trove.list.TIntList; +import gnu.trove.list.array.TIntArrayList; /** * Base class for supervised projection methods. @@ -56,6 +54,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * * @author Angela Peng * @author Erich Schubert + * @since 0.6.0 * * @param <V> Vector type */ @@ -113,7 +112,7 @@ public abstract class AbstractSupervisedProjectionVectorFilter<V extends NumberV List<V> vectorcolumn = (List<V>) column; final VectorFieldTypeInformation<?> vtype = (VectorFieldTypeInformation<?>) type; @SuppressWarnings("unchecked") - NumberVector.Factory<V> factory = (NumberVector.Factory<V> ) vtype.getFactory(); + NumberVector.Factory<V> factory = (NumberVector.Factory<V>) vtype.getFactory(); int dim = vtype.getDimensionality(); if(tdim > dim) { @@ -127,7 +126,7 @@ public abstract class AbstractSupervisedProjectionVectorFilter<V extends NumberV Matrix proj = computeProjectionMatrix(vectorcolumn, classcolumn, dim); for(int i = 0; i < dataLength; i++) { final Vector pv = proj.times(vectorcolumn.get(i).getColumnVector()); - V filteredObj = factory.newNumberVector(pv, ArrayLikeUtil.VECTORADAPTER); + V filteredObj = factory.newNumberVector(pv); vectorcolumn.set(i, filteredObj); } bundle.appendColumn(convertedType(type, factory), column); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/ClassicMultidimensionalScalingTransform.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/ClassicMultidimensionalScalingTransform.java index af1aa3af..8c1d161c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/ClassicMultidimensionalScalingTransform.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/ClassicMultidimensionalScalingTransform.java @@ -54,6 +54,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * instead. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.composedOf SingularValueDecomposition * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/FastMultidimensionalScalingTransform.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/FastMultidimensionalScalingTransform.java index 121e500b..7270b3ac 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/FastMultidimensionalScalingTransform.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/FastMultidimensionalScalingTransform.java @@ -52,6 +52,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * This implementation is O(n^2), and uses O(n^2) memory. * * @author Erich Schubert + * @since 0.6.0 * * @param <O> Data type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/GlobalPrincipalComponentAnalysisTransform.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/GlobalPrincipalComponentAnalysisTransform.java index 86b30c0c..20b64eb0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/GlobalPrincipalComponentAnalysisTransform.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/GlobalPrincipalComponentAnalysisTransform.java @@ -54,6 +54,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * {@link Parameterizer#FILTER_ID} parameter! * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.composedOf PCARunner * @apiviz.composedOf CovarianceMatrix diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/HistogramJitterFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/HistogramJitterFilter.java index 609ee0c9..a88ec88d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/HistogramJitterFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/HistogramJitterFilter.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.data.type.TypeUtil; import de.lmu.ifi.dbs.elki.datasource.filter.AbstractVectorStreamConversionFilter; import de.lmu.ifi.dbs.elki.math.random.RandomFactory; import de.lmu.ifi.dbs.elki.math.statistics.distribution.ExponentialDistribution; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; @@ -52,10 +53,12 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * to control the degradation amount. * * @author Erich Schubert + * @since 0.5.5 * * @param <V> Vector type */ @Description("Add uniform Jitter to a dataset, while preserving the total vector sum.") +@Alias("de.lmu.ifi.dbs.elki.datasource.filter.HistogramJitterFilter") public class HistogramJitterFilter<V extends NumberVector> extends AbstractVectorStreamConversionFilter<V, V> { /** * Jitter amount. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/LatLngToECEFFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/LatLngToECEFFilter.java index e82f07d1..9284f4ab 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/LatLngToECEFFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/LatLngToECEFFilter.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Z), such that Euclidean distance is line-of-sight. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.uses NumberVector * @apiviz.composedOf EarthModel diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/LinearDiscriminantAnalysisFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/LinearDiscriminantAnalysisFilter.java index 58e29021..08ebcc8b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/LinearDiscriminantAnalysisFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/LinearDiscriminantAnalysisFilter.java @@ -54,6 +54,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * * @author Angela Peng * @author Erich Schubert + * @since 0.6.0 * * @param <V> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/LngLatToECEFFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/LngLatToECEFFilter.java index fae5ee9f..7fcabaaf 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/LngLatToECEFFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/LngLatToECEFFilter.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Z), such that Euclidean distance is line-of-sight. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.uses NumberVector * @apiviz.composedOf EarthModel diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/NumberVectorFeatureSelectionFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/NumberVectorFeatureSelectionFilter.java index e2a03544..2716b830 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/NumberVectorFeatureSelectionFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/NumberVectorFeatureSelectionFilter.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntListParameter; * </p> * * @author Arthur Zimek + * @since 0.4.0 * * @apiviz.uses NumberVector * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/NumberVectorRandomFeatureSelectionFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/NumberVectorRandomFeatureSelectionFilter.java index fff1f44a..fca5aa73 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/NumberVectorRandomFeatureSelectionFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/NumberVectorRandomFeatureSelectionFilter.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * randomly selected subset of attributes. * * @author Arthur Zimek + * @since 0.4.0 * * @apiviz.uses NumberVector * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/PerturbationFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/PerturbationFilter.java index 680cd023..afae04a2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/PerturbationFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/PerturbationFilter.java @@ -67,6 +67,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.LongParameter; * </p> * * @author Arthur Zimek + * @since 0.7.0 */ @Title("Data Perturbation for Outlier Detection Ensembles") @Description("A filter to perturb a datasset on read by an additive noise component, implemented for use in an outlier ensemble (this reference).") diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/ProjectionFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/ProjectionFilter.java index ed87b8db..2074929e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/ProjectionFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/transform/ProjectionFilter.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Apply a projection to the data. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.composedOf Projection * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/ClassLabelFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/ClassLabelFilter.java index 4e48adbc..33b715dc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/ClassLabelFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/ClassLabelFilter.java @@ -44,11 +44,12 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Class that turns a label column into a class label column. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses LabelList oneway - - «reads» * @apiviz.has ClassLabel */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.ClassLabelFilter" }) +@Alias("de.lmu.ifi.dbs.elki.datasource.filter.ClassLabelFilter") public class ClassLabelFilter implements ObjectFilter { /** * The index of the label to be used as class label, null if no class label is diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/ClassLabelFromPatternFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/ClassLabelFromPatternFilter.java index 0d3279ce..1eab3804 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/ClassLabelFromPatternFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/ClassLabelFromPatternFilter.java @@ -44,8 +44,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.StringParameter; * Streaming filter to derive an outlier class label. * * @author Erich Schubert + * @since 0.6.0 */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.ClassLabelFromPatternFilter" }) +@Alias("de.lmu.ifi.dbs.elki.datasource.filter.ClassLabelFromPatternFilter") public class ClassLabelFromPatternFilter extends AbstractStreamFilter { /** * Current meta data diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/ExternalIDFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/ExternalIDFilter.java index 72ac5578..b6baaebf 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/ExternalIDFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/ExternalIDFilter.java @@ -42,11 +42,12 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * Class that turns a label column into an external ID column. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses LabelList oneway - - «reads» * @apiviz.has ExternalID oneway - - «produces» */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.ExternalIDFilter" }) +@Alias("de.lmu.ifi.dbs.elki.datasource.filter.ExternalIDFilter") public class ExternalIDFilter implements ObjectFilter { /** * The index of the label to be used as external Id. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/MultivariateTimeSeriesFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/MultivariateTimeSeriesFilter.java index 4ee50783..5d4e253b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/MultivariateTimeSeriesFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/MultivariateTimeSeriesFilter.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * Class to "fold" a flat number vector into a multivariate time series. * * @author Erich Schubert + * @since 0.7.0 * * @param <V> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/SparseVectorFieldFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/SparseVectorFieldFilter.java index 86092f7c..f174eb70 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/SparseVectorFieldFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/SparseVectorFieldFilter.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.Alias; * the maximum dimensionality for each vector. * * @author Erich Schubert + * @since 0.5.0 * * @param <V> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/SplitNumberVectorFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/SplitNumberVectorFilter.java index bf1e415f..95e3fd6a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/SplitNumberVectorFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/SplitNumberVectorFilter.java @@ -45,12 +45,13 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntListParameter; * Split an existing column into two types. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses NumberVector * * @param <V> Vector type */ -@Alias({ "de.lmu.ifi.dbs.elki.datasource.filter.normalization.SplitNumberVectorFilter" }) +@Alias("de.lmu.ifi.dbs.elki.datasource.filter.SplitNumberVectorFilter") public class SplitNumberVectorFilter<V extends NumberVector> implements ObjectFilter { /** * Selected dimensions. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/UncertainSplitFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/UncertainSplitFilter.java index 0ae85cd2..68dcf218 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/UncertainSplitFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/UncertainSplitFilter.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * uncertain observation. * * @author Erich Schubert + * @since 0.7.0 */ public class UncertainSplitFilter extends AbstractConversionFilter<NumberVector, UnweightedDiscreteUncertainObject> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/UncertainifyFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/UncertainifyFilter.java index e45b964c..ccd8e72f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/UncertainifyFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/UncertainifyFilter.java @@ -57,6 +57,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * * @author Alexander Koos * @author Erich Schubert + * @since 0.7.0 * * @param <UO> Uncertain object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/WeightedUncertainSplitFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/WeightedUncertainSplitFilter.java index 48df989b..0a10b036 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/WeightedUncertainSplitFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/filter/typeconversions/WeightedUncertainSplitFilter.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * interpret as uncertain observation. * * @author Erich Schubert + * @since 0.7.0 */ public class WeightedUncertainSplitFilter extends AbstractConversionFilter<NumberVector, WeightedDiscreteUncertainObject> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/AbstractStreamingParser.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/AbstractStreamingParser.java index 642a7cf1..3671a447 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/AbstractStreamingParser.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/AbstractStreamingParser.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * Base class for streaming parsers. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses CSVReaderFormat * @apiviz.composedOf TokenizedReader diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/ArffParser.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/ArffParser.java index 515c68c4..9a2cf786 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/ArffParser.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/ArffParser.java @@ -68,6 +68,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.PatternParameter; * TODO: allow optional class labels. * * @author Erich Schubert + * @since 0.4.0 */ public class ArffParser implements Parser { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/BitVectorLabelParser.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/BitVectorLabelParser.java index e6060bb4..ddef1548 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/BitVectorLabelParser.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/BitVectorLabelParser.java @@ -23,12 +23,14 @@ package de.lmu.ifi.dbs.elki.datasource.parser; along with this program. If not, see <http://www.gnu.org/licenses/>. */ -import gnu.trove.list.array.TLongArrayList; + import de.lmu.ifi.dbs.elki.data.BitVector; import de.lmu.ifi.dbs.elki.data.LabelList; import de.lmu.ifi.dbs.elki.logging.Logging; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; import de.lmu.ifi.dbs.elki.utilities.documentation.Title; +import gnu.trove.list.array.TLongArrayList; /** * Parser for parsing one BitVector per line, bits separated by whitespace. @@ -37,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * Bit. Lines starting with "#" will be ignored. * * @author Arthur Zimek + * @since 0.2 * * @apiviz.has BitVector */ @@ -47,6 +50,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; "If this fails, it will be appended to a label. " + // "(Thus, any label must not be parseable as Bit.) " + // "Empty lines and lines beginning with \"#\" will be ignored.") +@Alias("de.lmu.ifi.dbs.elki.parser.BitVectorLabelParser") public class BitVectorLabelParser extends NumberVectorLabelParser<BitVector> implements Parser { /** * Class logger diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/CSVReaderFormat.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/CSVReaderFormat.java index c0adbabd..5104f83d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/CSVReaderFormat.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/CSVReaderFormat.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.StringParameter; * * @author Arthur Zimek * @author Erich Schubert + * @since 0.2 * * @apiviz.has TokenizedReader */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/CategorialDataAsNumberVectorParser.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/CategorialDataAsNumberVectorParser.java index 86054b86..9f6f9c42 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/CategorialDataAsNumberVectorParser.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/CategorialDataAsNumberVectorParser.java @@ -40,6 +40,7 @@ import gnu.trove.map.hash.TObjectIntHashMap; * TODO: specify handling for numerical values. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.landmark * @apiviz.has NumberVector diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/ClusteringVectorParser.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/ClusteringVectorParser.java index e6b8d82b..26dd9acc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/ClusteringVectorParser.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/ClusteringVectorParser.java @@ -73,6 +73,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * TODO: support noise, via negative cluster numbers? * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has Clustering */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/LibSVMFormatParser.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/LibSVMFormatParser.java index fab7bc60..8e5dae65 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/LibSVMFormatParser.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/LibSVMFormatParser.java @@ -53,6 +53,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * <tt>#</tt>. * * @author Erich Schubert + * @since 0.7.0 * * @param <V> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/NumberVectorLabelParser.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/NumberVectorLabelParser.java index aaca0190..f3584932 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/NumberVectorLabelParser.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/NumberVectorLabelParser.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.data.type.VectorFieldTypeInformation; import de.lmu.ifi.dbs.elki.data.type.VectorTypeInformation; import de.lmu.ifi.dbs.elki.datasource.bundle.BundleMeta; import de.lmu.ifi.dbs.elki.logging.Logging; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.BitsUtil; import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.DoubleArray; import de.lmu.ifi.dbs.elki.utilities.datastructures.hash.Unique; @@ -59,12 +60,15 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * * @author Arthur Zimek * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark * @apiviz.has NumberVector * * @param <V> the type of NumberVector used */ +@Alias({ "de.lmu.ifi.dbs.elki.parser.NumberVectorLabelParser", // +"de.lmu.ifi.dbs.elki.parser.RealVectorLabelParser" }) public class NumberVectorLabelParser<V extends NumberVector> extends AbstractStreamingParser { /** * Logging class. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/Parser.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/Parser.java index c9ba4d1a..649fb1fe 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/Parser.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/Parser.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.datasource.bundle.MultipleObjectsBundle; * A Parser shall provide a ParsingResult by parsing an InputStream. * * @author Arthur Zimek + * @since 0.4.0 * * @apiviz.landmark * @apiviz.uses InputStream diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/SimplePolygonParser.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/SimplePolygonParser.java index 4abd76c6..e291214c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/SimplePolygonParser.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/SimplePolygonParser.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.utilities.FormatUtil; * Unparseable parts will be treated as labels. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has PolygonsObject */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/SimpleTransactionParser.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/SimpleTransactionParser.java index 6fb96359..5fbf8af7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/SimpleTransactionParser.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/SimpleTransactionParser.java @@ -54,6 +54,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * of tokens. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has BitVector */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/SparseNumberVectorLabelParser.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/SparseNumberVectorLabelParser.java index 478a9686..f6061fa6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/SparseNumberVectorLabelParser.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/SparseNumberVectorLabelParser.java @@ -70,6 +70,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Arthur Zimek + * @since 0.2 * * @apiviz.has SparseNumberVector * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/StreamingParser.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/StreamingParser.java index a189cd86..a3cb7a99 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/StreamingParser.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/StreamingParser.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.datasource.bundle.BundleStreamSource; * combination with filters. * * @author Erich Schubert + * @since 0.4.0 */ public interface StreamingParser extends Parser, BundleStreamSource { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/StringParser.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/StringParser.java index 0110ea9a..8750df85 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/StringParser.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/StringParser.java @@ -51,6 +51,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.PatternParameter; * * @author Felix Stahlberg * @author Erich Schubert + * @since 0.6.0 */ @Title("String Parser") @Description("Parses new line separated strings") diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/TermFrequencyParser.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/TermFrequencyParser.java index da0aca26..ccaac348 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/TermFrequencyParser.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/datasource/parser/TermFrequencyParser.java @@ -53,6 +53,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * {@link SimpleTransactionParser} instead. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has SparseNumberVector */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractDBIDRangeDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractDBIDRangeDistanceFunction.java index b858f6dd..330f1f6a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractDBIDRangeDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractDBIDRangeDistanceFunction.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * within a consecutive range. This is beneficial for external distances. * * @author Erich Schubert + * @since 0.7.0 */ public abstract class AbstractDBIDRangeDistanceFunction extends AbstractDatabaseDistanceFunction<DBID> implements DBIDRangeDistanceFunction { @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractDatabaseDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractDatabaseDistanceFunction.java index 3bd107ca..851e7dc6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractDatabaseDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractDatabaseDistanceFunction.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * Abstract super class for distance functions needing a database context. * * @author Elke Achtert + * @since 0.4.0 * * @apiviz.has AbstractDatabaseDistanceFunction.Instance * @apiviz.excludeSubtypes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractIndexBasedDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractIndexBasedDistanceFunction.java index 73eed528..1676364e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractIndexBasedDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractIndexBasedDistanceFunction.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Abstract super class for distance functions needing a database index. * * @author Elke Achtert + * @since 0.4.0 * * @apiviz.has AbstractIndexBasedDistanceFunction.Instance * @apiviz.composedOf IndexFactory diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractNumberVectorDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractNumberVectorDistanceFunction.java index b4de6fbf..56dd19ea 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractNumberVectorDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractNumberVectorDistanceFunction.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.data.type.TypeUtil; * on number vectors and returning double values. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.excludeSubtypes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractNumberVectorNorm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractNumberVectorNorm.java index 59273fc5..7af85c0e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractNumberVectorNorm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractNumberVectorNorm.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.data.NumberVector; * norms. * * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractPrimitiveDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractPrimitiveDistanceFunction.java index a19199b9..e06e2c5b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractPrimitiveDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractPrimitiveDistanceFunction.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * AbstractDistanceFunction provides some methods valid for any extending class. * * @author Arthur Zimek + * @since 0.4.0 * * @apiviz.excludeSubtypes * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractSpatialDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractSpatialDistanceFunction.java index a36faa3f..e73cb7bc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractSpatialDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractSpatialDistanceFunction.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * distance functions easier. * * @author Erich Schubert + * @since 0.4.0 */ public abstract class AbstractSpatialDistanceFunction extends AbstractNumberVectorDistanceFunction implements SpatialPrimitiveDistanceFunction<NumberVector> { @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractSpatialNorm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractSpatialNorm.java index b8915ef1..bc3fc200 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractSpatialNorm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/AbstractSpatialNorm.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * distance functions easier. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/ArcCosineDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/ArcCosineDistanceFunction.java index b8227739..a51544e7 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/ArcCosineDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/ArcCosineDistanceFunction.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * value, i.e., <code>arccos(<v1,v2>)</code>. * * @author Arthur Zimek + * @since 0.2 */ @Alias({ "arccos" }) public class ArcCosineDistanceFunction extends AbstractSpatialDistanceFunction { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/BrayCurtisDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/BrayCurtisDistanceFunction.java index 46770514..dafe9c65 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/BrayCurtisDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/BrayCurtisDistanceFunction.java @@ -67,6 +67,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * TODO: add a version optimized for sparse vectors / binary data. * * @author Erich Schubert + * @since 0.4.0 */ @Alias({ "bray-curtis", "braycurtis", "sorensen", "dice", "sorensen-dice" }) @Reference(authors = "J. R. Bray and J. T. Curtis", title = "An ordination of the upland forest communities of southern Wisconsin", booktitle = "Ecological monographs 27.4", url = "http://dx.doi.org/10.2307/1942268") diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/CanberraDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/CanberraDistanceFunction.java index 530ee70d..f373e2e1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/CanberraDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/CanberraDistanceFunction.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.4.0 */ @Reference(authors = "G. N. Lance, W. T. Williams", // title = "Computer programs for hierarchical polythetic classification (similarity analyses)", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/ClarkDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/ClarkDistanceFunction.java index 128d7e80..56f7de86 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/ClarkDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/ClarkDistanceFunction.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.4.0 */ @Reference(authors = "M.-M. Deza and E. Deza", title = "Dictionary of distances", booktitle = "Dictionary of distances") public class ClarkDistanceFunction extends AbstractSpatialDistanceFunction { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/CosineDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/CosineDistanceFunction.java index b0f55abd..ec9a9bf6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/CosineDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/CosineDistanceFunction.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * <code>1-(cosine similarity)</code>. * * @author Arthur Zimek + * @since 0.2 */ @Alias({ "cosine" }) public class CosineDistanceFunction extends AbstractSpatialDistanceFunction { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/DBIDDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/DBIDDistanceFunction.java index 4a1803da..8f3ee417 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/DBIDDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/DBIDDistanceFunction.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; * Example: external precomputed distances * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.uses DBID oneway - - defined on diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/DBIDRangeDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/DBIDRangeDistanceFunction.java index 23284d1a..6c121ce5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/DBIDRangeDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/DBIDRangeDistanceFunction.java @@ -1,5 +1,7 @@ package de.lmu.ifi.dbs.elki.distance.distancefunction; +import de.lmu.ifi.dbs.elki.database.ids.DBIDRange; + /* This file is part of ELKI: Environment for Developing KDD-Applications Supported by Index-Structures @@ -34,6 +36,7 @@ package de.lmu.ifi.dbs.elki.distance.distancefunction; * Example: external precomputed distances * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.uses de.lmu.ifi.dbs.elki.database.ids.DBIDRange oneway - - defined on @@ -47,4 +50,12 @@ public interface DBIDRangeDistanceFunction extends DBIDDistanceFunction { * @return Distance */ double distance(int i1, int i2); + + /** + * Validate the range of DBIDs to use. This will log a warning if an obvious + * mismatch was found. + * + * @param range DBID range + */ + void checkRange(DBIDRange range); }
\ No newline at end of file diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/DistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/DistanceFunction.java index d53c9e26..375083d1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/DistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/DistanceFunction.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * Base interface for any kind of distances. * * @author Erich Schubert + * @since 0.2 * * @param <O> Object type * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/IndexBasedDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/IndexBasedDistanceFunction.java index 8b41f956..9e24c934 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/IndexBasedDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/IndexBasedDistanceFunction.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; * Distance function relying on an index (such as preprocessed neighborhoods). * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.stereotype factory diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/Kulczynski1DistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/Kulczynski1DistanceFunction.java index 2baa2466..da8ea270 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/Kulczynski1DistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/Kulczynski1DistanceFunction.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.4.0 */ @Reference(authors = "M.-M. Deza and E. Deza", title = "Dictionary of distances", booktitle = "Dictionary of distances") public class Kulczynski1DistanceFunction extends AbstractSpatialDistanceFunction { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/LorentzianDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/LorentzianDistanceFunction.java index cbb193ac..fdf6de66 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/LorentzianDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/LorentzianDistanceFunction.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.4.0 */ @Reference(authors = "M.-M. Deza and E. Deza", title = "Dictionary of distances", booktitle = "Dictionary of distances") public class LorentzianDistanceFunction extends AbstractSpatialNorm { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/MatrixWeightedDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/MatrixWeightedDistanceFunction.java index 40b8b900..006e2bd0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/MatrixWeightedDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/MatrixWeightedDistanceFunction.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; * Weighted distance for feature vectors. * * @author Elke Achtert + * @since 0.2 */ // TODO: Factory with parameterizable weight matrix? public class MatrixWeightedDistanceFunction extends AbstractNumberVectorDistanceFunction { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/Norm.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/Norm.java index f25c91be..ba7724a6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/Norm.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/Norm.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.distance.distancefunction; * Abstract interface for a mathematical norm. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/NumberVectorDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/NumberVectorDistanceFunction.java index 3b6021e0..7840d0b8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/NumberVectorDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/NumberVectorDistanceFunction.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.data.NumberVector; * vectors. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/PrimitiveDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/PrimitiveDistanceFunction.java index 2a3ae0c1..0995e7b9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/PrimitiveDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/PrimitiveDistanceFunction.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.data.type.SimpleTypeInformation; * Primitive distance function that is defined on some kind of object. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/RandomStableDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/RandomStableDistanceFunction.java index e1eafbad..d6ced169 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/RandomStableDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/RandomStableDistanceFunction.java @@ -47,6 +47,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * metrical. * * @author Erich Schubert + * @since 0.4.0 */ public class RandomStableDistanceFunction extends AbstractDatabaseDistanceFunction<DBID> implements DBIDDistanceFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/SharedNearestNeighborJaccardDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/SharedNearestNeighborJaccardDistanceFunction.java index c11a3448..691a7373 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/SharedNearestNeighborJaccardDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/SharedNearestNeighborJaccardDistanceFunction.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * coefficient, which is a proper distance metric. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses * de.lmu.ifi.dbs.elki.index.preprocessed.snn.SharedNearestNeighborIndex diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/SpatialPrimitiveDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/SpatialPrimitiveDistanceFunction.java index 2611c36f..d8d246e1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/SpatialPrimitiveDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/SpatialPrimitiveDistanceFunction.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * API for a spatial primitive distance function. * * @author Erich Schubert + * @since 0.4.0 * * @param <V> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/WeightedCanberraDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/WeightedCanberraDistanceFunction.java index bd4fb5db..8c2b382e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/WeightedCanberraDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/WeightedCanberraDistanceFunction.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleListParamet * Weighted Canberra distance function, a variation of Manhattan distance. * * @author Erich Schubert + * @since 0.4.0 */ public class WeightedCanberraDistanceFunction extends AbstractSpatialDistanceFunction implements WeightedNumberVectorDistanceFunction<NumberVector> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/WeightedNumberVectorDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/WeightedNumberVectorDistanceFunction.java index 682b394a..2890292b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/WeightedNumberVectorDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/WeightedNumberVectorDistanceFunction.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; * Distance functions where each dimension is assigned a weight. * * @author Erich Schubert + * @since 0.4.0 * * @param <V> Vector type, usually NumberVector or above. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/adapter/AbstractSimilarityAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/adapter/AbstractSimilarityAdapter.java index f77c4927..31138c4d 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/adapter/AbstractSimilarityAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/adapter/AbstractSimilarityAdapter.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * equation. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has Instance * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/adapter/ArccosSimilarityAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/adapter/ArccosSimilarityAdapter.java index 4931c4e8..87cadf1a 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/adapter/ArccosSimilarityAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/adapter/ArccosSimilarityAdapter.java @@ -28,17 +28,20 @@ import de.lmu.ifi.dbs.elki.database.query.similarity.SimilarityQuery; import de.lmu.ifi.dbs.elki.database.relation.Relation; import de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction; import de.lmu.ifi.dbs.elki.distance.similarityfunction.NormalizedSimilarityFunction; +import de.lmu.ifi.dbs.elki.utilities.Alias; /** * Adapter from a normalized similarity function to a distance function using * <code>arccos(sim)</code>. * * @author Erich Schubert + * @since 0.2 * * @apiviz.has Instance * * @param <O> Object class to process. */ +@Alias("de.lmu.ifi.dbs.elki.distance.distancefunction.adapter.SimilarityAdapterArccos") public class ArccosSimilarityAdapter<O> extends AbstractSimilarityAdapter<O> { /** * Constructor. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/adapter/LinearAdapterLinear.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/adapter/LinearAdapterLinear.java index 63b681e9..4d1f76c4 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/adapter/LinearAdapterLinear.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/adapter/LinearAdapterLinear.java @@ -28,17 +28,20 @@ import de.lmu.ifi.dbs.elki.database.query.similarity.SimilarityQuery; import de.lmu.ifi.dbs.elki.database.relation.Relation; import de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction; import de.lmu.ifi.dbs.elki.distance.similarityfunction.NormalizedSimilarityFunction; +import de.lmu.ifi.dbs.elki.utilities.Alias; /** * Adapter from a normalized similarity function to a distance function using * <code>1 - sim</code>. * * @author Erich Schubert + * @since 0.2 * * @apiviz.has Instance * * @param <O> Object class to process. */ +@Alias("de.lmu.ifi.dbs.elki.distance.distancefunction.adapter.SimilarityAdapterLinear") public class LinearAdapterLinear<O> extends AbstractSimilarityAdapter<O> { /** * Constructor. @@ -98,4 +101,4 @@ public class LinearAdapterLinear<O> extends AbstractSimilarityAdapter<O> { return NORMALIZED_SIMILARITY; } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/adapter/LnSimilarityAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/adapter/LnSimilarityAdapter.java index f3002e1a..1ccc3749 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/adapter/LnSimilarityAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/adapter/LnSimilarityAdapter.java @@ -28,17 +28,20 @@ import de.lmu.ifi.dbs.elki.database.query.similarity.SimilarityQuery; import de.lmu.ifi.dbs.elki.database.relation.Relation; import de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction; import de.lmu.ifi.dbs.elki.distance.similarityfunction.NormalizedSimilarityFunction; +import de.lmu.ifi.dbs.elki.utilities.Alias; /** * Adapter from a normalized similarity function to a distance function using * <code>-log(sim)</code>. * * @author Erich Schubert + * @since 0.2 * * @apiviz.has Instance * * @param <O> object class to process. */ +@Alias("de.lmu.ifi.dbs.elki.distance.distancefunction.adapter.SimilarityAdapterLn") public class LnSimilarityAdapter<O> extends AbstractSimilarityAdapter<O> { /** * Constructor. @@ -98,4 +101,4 @@ public class LnSimilarityAdapter<O> extends AbstractSimilarityAdapter<O> { return NORMALIZED_SIMILARITY; } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/colorhistogram/HSBHistogramQuadraticDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/colorhistogram/HSBHistogramQuadraticDistanceFunction.java index ec5e4a90..48383915 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/colorhistogram/HSBHistogramQuadraticDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/colorhistogram/HSBHistogramQuadraticDistanceFunction.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntListParameter; * </p> * * @author Erich Schubert + * @since 0.3 */ @Reference(authors = "J. R. Smith, S. F. Chang", title = "VisualSEEk: a fully automated content-based image query system", booktitle = "Proceedings of the fourth ACM international conference on Multimedia 1997", url = "http://dx.doi.org/10.1145/244130.244151") public class HSBHistogramQuadraticDistanceFunction extends MatrixWeightedDistanceFunction { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/colorhistogram/HistogramIntersectionDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/colorhistogram/HistogramIntersectionDistanceFunction.java index e4141684..ba5e129b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/colorhistogram/HistogramIntersectionDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/colorhistogram/HistogramIntersectionDistanceFunction.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * International Journal of Computer Vision, 7(1), 32, 1991 * * @author Erich Schubert + * @since 0.3 */ @Title("Color histogram intersection distance") @Description("Distance function for color histograms that emphasizes 'strong' bins.") diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/colorhistogram/RGBHistogramQuadraticDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/colorhistogram/RGBHistogramQuadraticDistanceFunction.java index 70935d28..01540f98 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/colorhistogram/RGBHistogramQuadraticDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/colorhistogram/RGBHistogramQuadraticDistanceFunction.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Erich Schubert + * @since 0.3 */ @Reference(authors = "J. Hafner, H. S.Sawhney, W. Equits, M. Flickner, W. Niblack", title = "Efficient Color Histogram Indexing for Quadratic Form Distance Functions", booktitle = "IEEE Trans. on Pattern Analysis and Machine Intelligence, Vol. 17, No. 7, July 1995", url = "http://dx.doi.org/10.1109/34.391417") public class RGBHistogramQuadraticDistanceFunction extends MatrixWeightedDistanceFunction { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/AbsolutePearsonCorrelationDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/AbsolutePearsonCorrelationDistanceFunction.java index c0033742..df2c3018 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/AbsolutePearsonCorrelationDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/AbsolutePearsonCorrelationDistanceFunction.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * uncorrelated. * * @author Erich Schubert + * @since 0.3 */ public class AbsolutePearsonCorrelationDistanceFunction extends AbstractNumberVectorDistanceFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/AbsoluteUncenteredCorrelationDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/AbsoluteUncenteredCorrelationDistanceFunction.java index 50321129..b37719db 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/AbsoluteUncenteredCorrelationDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/AbsoluteUncenteredCorrelationDistanceFunction.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * but uses a fixed mean of 0 instead of the sample mean. * * @author Erich Schubert + * @since 0.4.0 */ public class AbsoluteUncenteredCorrelationDistanceFunction extends AbstractNumberVectorDistanceFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/PearsonCorrelationDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/PearsonCorrelationDistanceFunction.java index 0a0c6dc9..0bcafa43 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/PearsonCorrelationDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/PearsonCorrelationDistanceFunction.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * will be intermediate (around 1). * * @author Arthur Zimek + * @since 0.3 */ public class PearsonCorrelationDistanceFunction extends AbstractNumberVectorDistanceFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/SquaredPearsonCorrelationDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/SquaredPearsonCorrelationDistanceFunction.java index ea1cede4..f98235d4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/SquaredPearsonCorrelationDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/SquaredPearsonCorrelationDistanceFunction.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * 1). * * @author Arthur Zimek + * @since 0.3 */ public class SquaredPearsonCorrelationDistanceFunction extends AbstractNumberVectorDistanceFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/SquaredUncenteredCorrelationDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/SquaredUncenteredCorrelationDistanceFunction.java index 5f39b0ad..0828c82a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/SquaredUncenteredCorrelationDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/SquaredUncenteredCorrelationDistanceFunction.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * but uses a fixed mean of 0 instead of the sample mean. * * @author Erich Schubert + * @since 0.4.0 */ public class SquaredUncenteredCorrelationDistanceFunction extends AbstractNumberVectorDistanceFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/UncenteredCorrelationDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/UncenteredCorrelationDistanceFunction.java index 83bb7e7d..e5f6dd18 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/UncenteredCorrelationDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/UncenteredCorrelationDistanceFunction.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * uses a fixed mean of 0 instead of the sample mean. * * @author Erich Schubert + * @since 0.3 */ public class UncenteredCorrelationDistanceFunction extends AbstractNumberVectorDistanceFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/WeightedPearsonCorrelationDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/WeightedPearsonCorrelationDistanceFunction.java index 60ed0638..70c8f34e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/WeightedPearsonCorrelationDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/WeightedPearsonCorrelationDistanceFunction.java @@ -50,6 +50,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleListParamet * * @author Arthur Zimek * @author Erich Schubert + * @since 0.3 */ public class WeightedPearsonCorrelationDistanceFunction extends AbstractNumberVectorDistanceFunction implements WeightedNumberVectorDistanceFunction<NumberVector> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/WeightedSquaredPearsonCorrelationDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/WeightedSquaredPearsonCorrelationDistanceFunction.java index 4ec94227..108f8f97 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/WeightedSquaredPearsonCorrelationDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/correlation/WeightedSquaredPearsonCorrelationDistanceFunction.java @@ -50,6 +50,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleListParamet * * @author Arthur Zimek * @author Erich Schubert + * @since 0.3 */ public class WeightedSquaredPearsonCorrelationDistanceFunction extends AbstractNumberVectorDistanceFunction implements WeightedNumberVectorDistanceFunction<NumberVector> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/AsciiDistanceParser.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/AsciiDistanceParser.java index 2122f43b..61552730 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/AsciiDistanceParser.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/AsciiDistanceParser.java @@ -29,6 +29,7 @@ import java.io.InputStream; import de.lmu.ifi.dbs.elki.datasource.parser.CSVReaderFormat; import de.lmu.ifi.dbs.elki.logging.Logging; import de.lmu.ifi.dbs.elki.logging.progress.IndefiniteProgress; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; import de.lmu.ifi.dbs.elki.utilities.documentation.Title; @@ -41,11 +42,12 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * Parser for parsing one distance value per line. * * A line must have the following format: {@code id1 id2 distanceValue}, where - * id1 and id2 are integers representing the two ids belonging to the distance - * value. Lines starting with "#" will be ignored. + * id1 and id2 are integers starting at 0 representing the two ids belonging to + * the distance value. Lines starting with "#" will be ignored. * * @author Elke Achtert * @author Erich Schubert + * @since 0.2 * * @apiviz.uses CSVReaderFormat * @apiviz.composedOf TokenizedReader @@ -54,8 +56,11 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz */ @Title("Number Distance Parser") @Description("Parser for the following line format:\n" // - + "id1 id2 distanceValue, where id1 and is2 are integers representing the two ids belonging to the distance value.\n" // - + "The ids and the distance value are separated by whitespace. Empty lines and lines beginning with \"#\" will be ignored.") ++ "id1 id2 distanceValue, where id1 and is2 are integers starting at 0 representing the two ids belonging to the distance value.\n" // ++ "The ids and the distance value are separated by whitespace. Empty lines and lines beginning with \"#\" will be ignored.") +@Alias({ "de.lmu.ifi.dbs.elki.datasource.parser.NumberDistanceParser", // +"de.lmu.ifi.dbs.elki.distance.distancefunction.external.NumberDistanceParser", // +"de.lmu.ifi.dbs.elki.parser.NumberDistanceParser" }) public class AsciiDistanceParser implements DistanceParser { /** * The logger for this class. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/DiskCacheBasedDoubleDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/DiskCacheBasedDoubleDistanceFunction.java index 6bfd6df0..5ad01b72 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/DiskCacheBasedDoubleDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/DiskCacheBasedDoubleDistanceFunction.java @@ -26,7 +26,9 @@ package de.lmu.ifi.dbs.elki.distance.distancefunction.external; import java.io.File; import java.io.IOException; +import de.lmu.ifi.dbs.elki.database.ids.DBIDRange; import de.lmu.ifi.dbs.elki.distance.distancefunction.AbstractDBIDRangeDistanceFunction; +import de.lmu.ifi.dbs.elki.logging.Logging; import de.lmu.ifi.dbs.elki.persistent.OnDiskUpperTriangleMatrix; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; import de.lmu.ifi.dbs.elki.utilities.documentation.Title; @@ -42,11 +44,15 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.FileParameter; * matrix of an external binary matrix file. * * @author Erich Schubert + * @since 0.2 */ @Title("File based double distance for database objects.") @Description("Loads double distance values from an external matrix.") public class DiskCacheBasedDoubleDistanceFunction extends AbstractDBIDRangeDistanceFunction { - // TODO: constructor with file. + /** + * Class logger. + */ + private static final Logging LOG = Logging.getLogger(DiskCacheBasedDoubleDistanceFunction.class); /** * Magic to identify double cache matrices @@ -68,6 +74,17 @@ public class DiskCacheBasedDoubleDistanceFunction extends AbstractDBIDRangeDista this.cache = cache; } + /** + * Constructor. + * + * @param matrixfile File name + * @throws IOException + */ + public DiskCacheBasedDoubleDistanceFunction(File matrixfile) throws IOException { + super(); + this.cache = new OnDiskUpperTriangleMatrix(matrixfile, DOUBLE_CACHE_MAGIC, 0, ByteArrayUtil.SIZE_DOUBLE, false); + } + @Override public double distance(int i1, int i2) { // the smaller id is the first key @@ -84,6 +101,13 @@ public class DiskCacheBasedDoubleDistanceFunction extends AbstractDBIDRangeDista } @Override + public void checkRange(DBIDRange range) { + if(cache.getMatrixSize() < range.size()) { + LOG.warning("Distance matrix has size " + cache.getMatrixSize() + " but range has size: " + range.size()); + } + } + + @Override public boolean equals(Object obj) { if(obj == null) { return false; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/DiskCacheBasedFloatDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/DiskCacheBasedFloatDistanceFunction.java index de8d96b4..b6731a30 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/DiskCacheBasedFloatDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/DiskCacheBasedFloatDistanceFunction.java @@ -26,7 +26,9 @@ package de.lmu.ifi.dbs.elki.distance.distancefunction.external; import java.io.File; import java.io.IOException; +import de.lmu.ifi.dbs.elki.database.ids.DBIDRange; import de.lmu.ifi.dbs.elki.distance.distancefunction.AbstractDBIDRangeDistanceFunction; +import de.lmu.ifi.dbs.elki.logging.Logging; import de.lmu.ifi.dbs.elki.persistent.OnDiskUpperTriangleMatrix; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; import de.lmu.ifi.dbs.elki.utilities.documentation.Title; @@ -41,11 +43,15 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.FileParameter; * of an external binary matrix file. * * @author Erich Schubert + * @since 0.2 */ @Title("File based float distance for database objects.") @Description("Loads float distance values from an external matrix.") public class DiskCacheBasedFloatDistanceFunction extends AbstractDBIDRangeDistanceFunction { - // TODO: constructor with file. + /** + * Class logger. + */ + private static final Logging LOG = Logging.getLogger(DiskCacheBasedFloatDistanceFunction.class); /** * Magic to identify double cache matrices @@ -67,6 +73,17 @@ public class DiskCacheBasedFloatDistanceFunction extends AbstractDBIDRangeDistan this.cache = cache; } + /** + * Constructor. + * + * @param matrixfile File name + * @throws IOException + */ + public DiskCacheBasedFloatDistanceFunction(File matrixfile) throws IOException { + super(); + this.cache = new OnDiskUpperTriangleMatrix(matrixfile, FLOAT_CACHE_MAGIC, 0, ByteArrayUtil.SIZE_FLOAT, false); + } + @Override public double distance(int i1, int i2) { // the smaller id is the first key @@ -94,6 +111,13 @@ public class DiskCacheBasedFloatDistanceFunction extends AbstractDBIDRangeDistan return this.cache.equals(other.cache); } + @Override + public void checkRange(DBIDRange range) { + if(cache.getMatrixSize() < range.size()) { + LOG.warning("Distance matrix has size " + cache.getMatrixSize() + " but range has size: " + range.size()); + } + } + /** * Parameterization class. * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/DistanceCacheWriter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/DistanceCacheWriter.java index cd73b73e..3d83db66 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/DistanceCacheWriter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/DistanceCacheWriter.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.distance.distancefunction.external; * Interface to plug in the cache storage into the parser. * * @author Erich Schubert + * @since 0.4.0 */ public interface DistanceCacheWriter { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/DistanceParser.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/DistanceParser.java index 28234d75..d495427b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/DistanceParser.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/DistanceParser.java @@ -30,6 +30,7 @@ import java.io.InputStream; * InputStream. * * @author Arthur Zimek + * @since 0.2 * * @apiviz.uses DistanceCacheWriter oneway - - «create» */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/FileBasedDoubleDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/FileBasedDoubleDistanceFunction.java index 4f872766..cbbf7fa2 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/FileBasedDoubleDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/FileBasedDoubleDistanceFunction.java @@ -1,5 +1,28 @@ package de.lmu.ifi.dbs.elki.distance.distancefunction.external; +import java.io.BufferedInputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; + +import de.lmu.ifi.dbs.elki.database.ids.DBID; +import de.lmu.ifi.dbs.elki.database.ids.DBIDRange; +import de.lmu.ifi.dbs.elki.database.query.distance.DistanceQuery; +import de.lmu.ifi.dbs.elki.database.relation.Relation; +import de.lmu.ifi.dbs.elki.distance.distancefunction.AbstractDBIDRangeDistanceFunction; +import de.lmu.ifi.dbs.elki.logging.Logging; +import de.lmu.ifi.dbs.elki.utilities.FileUtil; +import de.lmu.ifi.dbs.elki.utilities.documentation.Description; +import de.lmu.ifi.dbs.elki.utilities.documentation.Title; +import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.FileParameter; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; +import gnu.trove.impl.Constants; + /* This file is part of ELKI: Environment for Developing KDD-Applications Supported by Index-Structures @@ -26,26 +49,6 @@ package de.lmu.ifi.dbs.elki.distance.distancefunction.external; import gnu.trove.map.TLongDoubleMap; import gnu.trove.map.hash.TLongDoubleHashMap; -import java.io.BufferedInputStream; -import java.io.File; -import java.io.FileInputStream; -import java.io.IOException; -import java.io.InputStream; - -import de.lmu.ifi.dbs.elki.database.ids.DBID; -import de.lmu.ifi.dbs.elki.database.query.distance.DistanceQuery; -import de.lmu.ifi.dbs.elki.database.relation.Relation; -import de.lmu.ifi.dbs.elki.distance.distancefunction.AbstractDBIDRangeDistanceFunction; -import de.lmu.ifi.dbs.elki.utilities.FileUtil; -import de.lmu.ifi.dbs.elki.utilities.documentation.Description; -import de.lmu.ifi.dbs.elki.utilities.documentation.Title; -import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.FileParameter; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; - /** * Distance function that is based on double distances given by a distance * matrix of an external ASCII file. @@ -58,6 +61,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * * @author Elke Achtert * @author Erich Schubert + * @since 0.2 * * @apiviz.composedOf DistanceCacheWriter */ @@ -65,6 +69,11 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; @Description("Loads double distance values from an external text file.") public class FileBasedDoubleDistanceFunction extends AbstractDBIDRangeDistanceFunction { /** + * Class logger. + */ + private static final Logging LOG = Logging.getLogger(FileBasedDoubleDistanceFunction.class); + + /** * The distance cache */ private TLongDoubleMap cache; @@ -80,6 +89,11 @@ public class FileBasedDoubleDistanceFunction extends AbstractDBIDRangeDistanceFu private File matrixfile; /** + * Minimum and maximum IDs seen. + */ + private int min, max; + + /** * Constructor. * * @param parser Parser @@ -106,18 +120,25 @@ public class FileBasedDoubleDistanceFunction extends AbstractDBIDRangeDistanceFu @Override public double distance(int i1, int i2) { - if(i1 == i2) { - return 0.; - } - return cache.get(makeKey(i1, i2)); + return (i1 == i2) ? 0. : cache.get(makeKey(i1 + min, i2 + min)); } private void loadCache(DistanceParser parser, File matrixfile) throws IOException { InputStream in = new BufferedInputStream(FileUtil.tryGzipInput(new FileInputStream(matrixfile))); - cache = new TLongDoubleHashMap(); + cache = new TLongDoubleHashMap(Constants.DEFAULT_CAPACITY, Constants.DEFAULT_LOAD_FACTOR, -1L, Double.POSITIVE_INFINITY); + min = Integer.MAX_VALUE; + max = Integer.MIN_VALUE; parser.parse(in, new DistanceCacheWriter() { @Override public void put(int id1, int id2, double distance) { + if(id1 < id2) { + min = id1 < min ? id1 : min; + max = id2 > max ? id2 : max; + } + else { + min = id2 < min ? id2 : min; + max = id1 > max ? id1 : max; + } cache.put(makeKey(id1, id2), distance); } @@ -126,6 +147,9 @@ public class FileBasedDoubleDistanceFunction extends AbstractDBIDRangeDistanceFu return cache.containsKey(makeKey(id1, id2)); } }); + if(min != 0) { + LOG.verbose("Distance matrix is supposed to be 0-indexed. Choosing offset " + min + " to compensate."); + } } /** @@ -142,6 +166,14 @@ public class FileBasedDoubleDistanceFunction extends AbstractDBIDRangeDistanceFu } @Override + public void checkRange(DBIDRange range) { + final int size = max + 1 - min; + if(size < range.size()) { + LOG.warning("Distance matrix has size " + size + " but range has size: " + range.size()); + } + } + + @Override public boolean equals(Object obj) { if(obj == null) { return false; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/FileBasedFloatDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/FileBasedFloatDistanceFunction.java index d14afb5d..51ae874e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/FileBasedFloatDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/external/FileBasedFloatDistanceFunction.java @@ -1,5 +1,27 @@ package de.lmu.ifi.dbs.elki.distance.distancefunction.external; +import java.io.BufferedInputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; + +import de.lmu.ifi.dbs.elki.database.ids.DBID; +import de.lmu.ifi.dbs.elki.database.ids.DBIDRange; +import de.lmu.ifi.dbs.elki.database.query.distance.DistanceQuery; +import de.lmu.ifi.dbs.elki.database.relation.Relation; +import de.lmu.ifi.dbs.elki.distance.distancefunction.AbstractDBIDRangeDistanceFunction; +import de.lmu.ifi.dbs.elki.logging.Logging; +import de.lmu.ifi.dbs.elki.utilities.FileUtil; +import de.lmu.ifi.dbs.elki.utilities.documentation.Description; +import de.lmu.ifi.dbs.elki.utilities.documentation.Title; +import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; +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.FileParameter; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; +import gnu.trove.impl.Constants; + /* This file is part of ELKI: Environment for Developing KDD-Applications Supported by Index-Structures @@ -26,25 +48,6 @@ package de.lmu.ifi.dbs.elki.distance.distancefunction.external; import gnu.trove.map.TLongFloatMap; import gnu.trove.map.hash.TLongFloatHashMap; -import java.io.BufferedInputStream; -import java.io.File; -import java.io.FileInputStream; -import java.io.IOException; -import java.io.InputStream; - -import de.lmu.ifi.dbs.elki.database.ids.DBID; -import de.lmu.ifi.dbs.elki.database.query.distance.DistanceQuery; -import de.lmu.ifi.dbs.elki.database.relation.Relation; -import de.lmu.ifi.dbs.elki.distance.distancefunction.AbstractDBIDRangeDistanceFunction; -import de.lmu.ifi.dbs.elki.utilities.FileUtil; -import de.lmu.ifi.dbs.elki.utilities.documentation.Description; -import de.lmu.ifi.dbs.elki.utilities.documentation.Title; -import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; -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.FileParameter; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; - /** * Distance function that is based on float distances given by a distance matrix * of an external ASCII file. @@ -57,6 +60,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * * @author Elke Achtert * @author Erich Schubert + * @since 0.2 * * @apiviz.composedOf DistanceCacheWriter */ @@ -64,6 +68,11 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; @Description("Loads float distance values from an external text file.") public class FileBasedFloatDistanceFunction extends AbstractDBIDRangeDistanceFunction { /** + * Class logger. + */ + private static final Logging LOG = Logging.getLogger(FileBasedFloatDistanceFunction.class); + + /** * The distance cache */ private TLongFloatMap cache; @@ -79,6 +88,11 @@ public class FileBasedFloatDistanceFunction extends AbstractDBIDRangeDistanceFun private File matrixfile; /** + * Minimum and maximum IDs seen. + */ + private int min, max; + + /** * Constructor. * * @param parser Parser @@ -105,15 +119,25 @@ public class FileBasedFloatDistanceFunction extends AbstractDBIDRangeDistanceFun @Override public double distance(int i1, int i2) { - return (i1 == i2) ? 0. : cache.get(makeKey(i1, i2)); + return (i1 == i2) ? 0. : cache.get(makeKey(i1 + min, i2 + min)); } private void loadCache(DistanceParser parser, File matrixfile) throws IOException { InputStream in = new BufferedInputStream(FileUtil.tryGzipInput(new FileInputStream(matrixfile))); - cache = new TLongFloatHashMap(); + cache = new TLongFloatHashMap(Constants.DEFAULT_CAPACITY, Constants.DEFAULT_LOAD_FACTOR, -1L, Float.POSITIVE_INFINITY); + min = Integer.MAX_VALUE; + max = Integer.MIN_VALUE; parser.parse(in, new DistanceCacheWriter() { @Override public void put(int id1, int id2, double distance) { + if(id1 < id2) { + min = id1 < min ? id1 : min; + max = id2 > max ? id2 : max; + } + else { + min = id2 < min ? id2 : min; + max = id1 > max ? id1 : max; + } cache.put(makeKey(id1, id2), (float) distance); } @@ -122,6 +146,9 @@ public class FileBasedFloatDistanceFunction extends AbstractDBIDRangeDistanceFun return cache.containsKey(makeKey(id1, id2)); } }); + if(min != 0) { + LOG.verbose("Distance matrix is supposed to be 0-indexed. Choosing offset " + min + " to compensate."); + } } /** @@ -138,6 +165,14 @@ public class FileBasedFloatDistanceFunction extends AbstractDBIDRangeDistanceFun } @Override + public void checkRange(DBIDRange range) { + final int size = max + 1 - min; + if(size < range.size()) { + LOG.warning("Distance matrix has size " + size + " but range has size: " + range.size()); + } + } + + @Override public boolean equals(Object obj) { if(obj == null) { return false; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/geo/DimensionSelectingLatLngDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/geo/DimensionSelectingLatLngDistanceFunction.java index 203e9e1c..8e8f9310 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/geo/DimensionSelectingLatLngDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/geo/DimensionSelectingLatLngDistanceFunction.java @@ -56,6 +56,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf EarthModel */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/geo/LatLngDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/geo/LatLngDistanceFunction.java index 2ccb13ec..b7528a41 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/geo/LatLngDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/geo/LatLngDistanceFunction.java @@ -52,6 +52,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf EarthModel */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/geo/LngLatDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/geo/LngLatDistanceFunction.java index 2e1f0c13..faf541a1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/geo/LngLatDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/geo/LngLatDistanceFunction.java @@ -52,6 +52,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf EarthModel */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/histogram/HistogramMatchDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/histogram/HistogramMatchDistanceFunction.java index 089460f3..cd1d0be5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/histogram/HistogramMatchDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/histogram/HistogramMatchDistanceFunction.java @@ -50,6 +50,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.4.0 */ @Reference(authors = "L.N. Vaserstein", // title = "Markov processes over denumerable products of spaces describing large systems of automata", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/histogram/KolmogorovSmirnovDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/histogram/KolmogorovSmirnovDistanceFunction.java index a078eae3..7645e5fd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/histogram/KolmogorovSmirnovDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/histogram/KolmogorovSmirnovDistanceFunction.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * i.e. they should be some 1-dimensional histogram. * * @author Erich Schubert + * @since 0.4.0 */ public class KolmogorovSmirnovDistanceFunction extends AbstractNumberVectorDistanceFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/EuclideanDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/EuclideanDistanceFunction.java index 422ea5d0..d17756f9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/EuclideanDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/EuclideanDistanceFunction.java @@ -32,8 +32,10 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Euclidean distance for {@link NumberVector}s. * * @author Arthur Zimek + * @since 0.2 */ -@Alias({ "euclidean", "euclid", "l2", "EuclideanDistanceFunction", "de.lmu.ifi.dbs.elki.distance.distancefunction.EuclideanDistanceFunction" }) +@Alias({ "euclidean", "euclid", "l2", // +"de.lmu.ifi.dbs.elki.distance.distancefunction.EuclideanDistanceFunction" }) public class EuclideanDistanceFunction extends LPIntegerNormDistanceFunction { /** * Static instance. Use this! diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/LPIntegerNormDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/LPIntegerNormDistanceFunction.java index 055e96cf..56d03b41 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/LPIntegerNormDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/LPIntegerNormDistanceFunction.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * machine version. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/LPNormDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/LPNormDistanceFunction.java index 88b5edc5..aa8b9e80 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/LPNormDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/LPNormDistanceFunction.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * LP-Norm for {@link NumberVector}s. * * @author Arthur Zimek + * @since 0.2 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/ManhattanDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/ManhattanDistanceFunction.java index f0562aa0..f82514ac 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/ManhattanDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/ManhattanDistanceFunction.java @@ -32,8 +32,10 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Manhattan distance for {@link NumberVector}s. * * @author Arthur Zimek + * @since 0.2 */ -@Alias({ "taxicab", "cityblock", "l1", "ManhattanDistanceFunction", "de.lmu.ifi.dbs.elki.distance.distancefunction.ManhattanDistanceFunction" }) +@Alias({ "taxicab", "cityblock", "l1", // +"de.lmu.ifi.dbs.elki.distance.distancefunction.ManhattanDistanceFunction" }) public class ManhattanDistanceFunction extends LPIntegerNormDistanceFunction { /** * The static instance to use. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/MaximumDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/MaximumDistanceFunction.java index 84c1e7a2..dce6a67e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/MaximumDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/MaximumDistanceFunction.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Maximum distance for {@link NumberVector}s. * * @author Erich Schubert + * @since 0.3 */ @Alias({ "maximum", "max", "chebyshev", "de.lmu.ifi.dbs.elki.distance.distancefunction.MaximumDistanceFunction" }) public class MaximumDistanceFunction extends LPNormDistanceFunction { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/MinimumDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/MinimumDistanceFunction.java index 1d218718..3ce7da42 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/MinimumDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/MinimumDistanceFunction.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Maximum distance for {@link NumberVector}s. * * @author Erich Schubert + * @since 0.3 */ @Alias({ "minimum", "min", "de.lmu.ifi.dbs.elki.distance.distancefunction.MinimumDistanceFunction" }) public class MinimumDistanceFunction extends AbstractSpatialNorm { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SparseEuclideanDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SparseEuclideanDistanceFunction.java index b6085f9a..91960751 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SparseEuclideanDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SparseEuclideanDistanceFunction.java @@ -24,13 +24,16 @@ package de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski; */ import de.lmu.ifi.dbs.elki.data.SparseNumberVector; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; /** * Euclidean distance function, optimized for {@link SparseNumberVector}s. * * @author Erich Schubert + * @since 0.5.0 */ +@Alias("de.lmu.ifi.dbs.elki.distance.distancefunction.SparseEuclideanDistanceFunction") public class SparseEuclideanDistanceFunction extends SparseLPNormDistanceFunction { /** * Static instance diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SparseLPNormDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SparseLPNormDistanceFunction.java index 28e3e33e..97ffe515 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SparseLPNormDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SparseLPNormDistanceFunction.java @@ -28,6 +28,7 @@ import de.lmu.ifi.dbs.elki.data.type.SimpleTypeInformation; import de.lmu.ifi.dbs.elki.data.type.TypeUtil; import de.lmu.ifi.dbs.elki.distance.distancefunction.AbstractPrimitiveDistanceFunction; import de.lmu.ifi.dbs.elki.distance.distancefunction.Norm; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; import de.lmu.ifi.dbs.elki.utilities.optionhandling.constraints.CommonConstraints; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; @@ -37,8 +38,10 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * LP-Norm, optimized for {@link SparseNumberVector}s. * * @author Erich Schubert + * @since 0.5.0 */ // TODO: implement SpatialDistanceFunction +@Alias("de.lmu.ifi.dbs.elki.distance.distancefunction.SparseLPNormDistanceFunction") public class SparseLPNormDistanceFunction extends AbstractPrimitiveDistanceFunction<SparseNumberVector> implements Norm<SparseNumberVector> { /** * P parameter and its inverse. @@ -153,4 +156,4 @@ public class SparseLPNormDistanceFunction extends AbstractPrimitiveDistanceFunct return new SparseLPNormDistanceFunction(p); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SparseManhattanDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SparseManhattanDistanceFunction.java index ffb6bdfc..a83a0ac4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SparseManhattanDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SparseManhattanDistanceFunction.java @@ -24,13 +24,16 @@ package de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski; */ import de.lmu.ifi.dbs.elki.data.SparseNumberVector; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; /** * Manhattan distance, optimized for {@link SparseNumberVector}s. * * @author Erich Schubert + * @since 0.5.0 */ +@Alias("de.lmu.ifi.dbs.elki.distance.distancefunction.SparseManhattanDistanceFunction") public class SparseManhattanDistanceFunction extends SparseLPNormDistanceFunction { /** * Static instance @@ -112,4 +115,4 @@ public class SparseManhattanDistanceFunction extends SparseLPNormDistanceFunctio return SparseManhattanDistanceFunction.STATIC; } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SparseMaximumDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SparseMaximumDistanceFunction.java index 237453c8..5a33c6aa 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SparseMaximumDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SparseMaximumDistanceFunction.java @@ -23,13 +23,16 @@ package de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski; along with this program. If not, see <http://www.gnu.org/licenses/>. */ import de.lmu.ifi.dbs.elki.data.SparseNumberVector; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; /** * Maximum distance, optimized for {@link SparseNumberVector}s. * * @author Erich Schubert + * @since 0.5.0 */ +@Alias("de.lmu.ifi.dbs.elki.distance.distancefunction.SparseMaximumDistanceFunction") public class SparseMaximumDistanceFunction extends SparseLPNormDistanceFunction { /** * Static instance @@ -123,4 +126,4 @@ public class SparseMaximumDistanceFunction extends SparseLPNormDistanceFunction return SparseMaximumDistanceFunction.STATIC; } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SquaredEuclideanDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SquaredEuclideanDistanceFunction.java index 387dfa86..7714282c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SquaredEuclideanDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/SquaredEuclideanDistanceFunction.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * computing the square root. * * @author Arthur Zimek + * @since 0.2 */ @Alias({ "squaredeuclidean", "de.lmu.ifi.dbs.elki.distance.distancefunction.SquaredEuclideanDistanceFunction" }) public class SquaredEuclideanDistanceFunction extends AbstractSpatialNorm { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedEuclideanDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedEuclideanDistanceFunction.java index 3fbfc28e..fe163c43 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedEuclideanDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedEuclideanDistanceFunction.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleListParamet * Weighted Euclidean distance for {@link NumberVector}s. * * @author Erich Schubert + * @since 0.4.0 */ public class WeightedEuclideanDistanceFunction extends WeightedLPNormDistanceFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedLPNormDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedLPNormDistanceFunction.java index 6f9a99c2..dc75a0bd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedLPNormDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedLPNormDistanceFunction.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.data.spatial.SpatialComparable; import de.lmu.ifi.dbs.elki.data.type.SimpleTypeInformation; import de.lmu.ifi.dbs.elki.data.type.VectorFieldTypeInformation; import de.lmu.ifi.dbs.elki.distance.distancefunction.WeightedNumberVectorDistanceFunction; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleListParameter; @@ -37,7 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleListParamet * Weighted version of the Minkowski L_p norm distance for {@link NumberVector}. * * @author Erich Schubert + * @since 0.4.0 */ +@Alias("de.lmu.ifi.dbs.elki.distance.distancefunction.WeightedLPNormDistanceFunction") public class WeightedLPNormDistanceFunction extends LPNormDistanceFunction implements WeightedNumberVectorDistanceFunction<NumberVector> { /** * Weight array diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedManhattanDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedManhattanDistanceFunction.java index 473c24fb..2d2483a6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedManhattanDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedManhattanDistanceFunction.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleListParamet * {@link NumberVector}s. * * @author Erich Schubert + * @since 0.4.0 */ public class WeightedManhattanDistanceFunction extends WeightedLPNormDistanceFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedMaximumDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedMaximumDistanceFunction.java index 14f1d899..71a4bf7e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedMaximumDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedMaximumDistanceFunction.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleListParamet * {@link NumberVector}s. * * @author Erich Schubert + * @since 0.4.0 */ public class WeightedMaximumDistanceFunction extends WeightedLPNormDistanceFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedSquaredEuclideanDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedSquaredEuclideanDistanceFunction.java index b57e0317..9e6a5868 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedSquaredEuclideanDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/minkowski/WeightedSquaredEuclideanDistanceFunction.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.data.NumberVector; import de.lmu.ifi.dbs.elki.data.spatial.SpatialComparable; import de.lmu.ifi.dbs.elki.distance.distancefunction.AbstractSpatialNorm; import de.lmu.ifi.dbs.elki.distance.distancefunction.WeightedNumberVectorDistanceFunction; +import de.lmu.ifi.dbs.elki.utilities.Alias; 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; @@ -38,7 +39,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleListParamet * same rankings as Euclidean distance, but saves computing the square root. * * @author Arthur Zimek + * @since 0.4.0 */ +@Alias("de.lmu.ifi.dbs.elki.distance.distancefunction.WeightedSquaredEuclideanDistanceFunction") public class WeightedSquaredEuclideanDistanceFunction extends AbstractSpatialNorm implements WeightedNumberVectorDistanceFunction<NumberVector> { /** * Weight array diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/ChiSquaredDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/ChiSquaredDistanceFunction.java index 06b7bf79..5eb40eea 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/ChiSquaredDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/ChiSquaredDistanceFunction.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.4.0 */ @Alias("chisq") @Reference(authors = "J. Puzicha, J.M. Buhmann, Y. Rubner, C. Tomasi", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/HellingerDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/HellingerDistanceFunction.java index f955520a..ba191a46 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/HellingerDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/HellingerDistanceFunction.java @@ -55,6 +55,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * TODO: support acceleration for sparse vectors * * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "E. Hellinger", // title = "Neue Begründung der Theorie quadratischer Formen von unendlichvielen Veränderlichen", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/JeffreyDivergenceDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/JeffreyDivergenceDistanceFunction.java index 55f9a476..16814c4c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/JeffreyDivergenceDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/JeffreyDivergenceDistanceFunction.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.4.0 */ @Reference(authors = "J. Puzicha, J.M. Buhmann, Y. Rubner, C. Tomasi", // title = "Empirical evaluation of dissimilarity measures for color and texture", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/JensenShannonDivergenceDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/JensenShannonDivergenceDistanceFunction.java index 18eb33bf..6b20a3f7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/JensenShannonDivergenceDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/JensenShannonDivergenceDistanceFunction.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * scaled by half. * * @author Erich Schubert + * @since 0.6.0 */ public class JensenShannonDivergenceDistanceFunction extends JeffreyDivergenceDistanceFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/KullbackLeiblerDivergenceAsymmetricDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/KullbackLeiblerDivergenceAsymmetricDistanceFunction.java index 48cd39e4..064fc6df 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/KullbackLeiblerDivergenceAsymmetricDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/KullbackLeiblerDivergenceAsymmetricDistanceFunction.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.4.0 */ @Reference(authors = "S. Kullback", title = "Information theory and statistics", booktitle = "Information theory and statistics, Courier Dover Publications, 1997.") @Alias("kl") diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/KullbackLeiblerDivergenceReverseAsymmetricDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/KullbackLeiblerDivergenceReverseAsymmetricDistanceFunction.java index 1e96ee0e..4bfe9521 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/KullbackLeiblerDivergenceReverseAsymmetricDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/KullbackLeiblerDivergenceReverseAsymmetricDistanceFunction.java @@ -47,6 +47,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.4.0 */ @Reference(authors = "S. Kullback", title = "Information theory and statistics", booktitle = "Information theory and statistics, Courier Dover Publications, 1997.") @Alias("kli") diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/SqrtJensenShannonDivergenceDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/SqrtJensenShannonDivergenceDistanceFunction.java index ca99a4c8..b792f97c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/SqrtJensenShannonDivergenceDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/SqrtJensenShannonDivergenceDistanceFunction.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.4.0 */ @Reference(authors = "D. M. Endres, J. E. Schindelin", title = "A new metric for probability distributions", booktitle = "IEEE Transactions on Information Theory, 49(7)", url = "http://dx.doi.org/10.1109/TIT.2003.813506") public class SqrtJensenShannonDivergenceDistanceFunction extends AbstractNumberVectorDistanceFunction { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/set/AbstractSetDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/set/AbstractSetDistanceFunction.java index 814d144e..bce8437c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/set/AbstractSetDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/set/AbstractSetDistanceFunction.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.AbstractPrimitiveDistanceFu * Abstract base class for set distance functions. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/set/HammingDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/set/HammingDistanceFunction.java index 4d467db9..a04c5d37 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/set/HammingDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/set/HammingDistanceFunction.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * TODO: add a sparse (but not binary) optimized version? * * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "R. W. Hamming", // title = "Error detecting and error correcting codes", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/set/JaccardSimilarityDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/set/JaccardSimilarityDistanceFunction.java index 954339ec..c13b4af0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/set/JaccardSimilarityDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/set/JaccardSimilarityDistanceFunction.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; import de.lmu.ifi.dbs.elki.distance.distancefunction.NumberVectorDistanceFunction; import de.lmu.ifi.dbs.elki.distance.distancefunction.PrimitiveDistanceFunction; import de.lmu.ifi.dbs.elki.distance.similarityfunction.NormalizedPrimitiveSimilarityFunction; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; /** @@ -56,12 +57,14 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @param <O> Vector type */ @Reference(authors = "P. Jaccard", // title = "Distribution de la florine alpine dans la Bassin de Dranses et dans quelques regiones voisines", // booktitle = "Bulletin del la Société Vaudoise des Sciences Naturelles") +@Alias("de.lmu.ifi.dbs.elki.distance.similarityfunction.JaccardPrimitiveSimilarityFunction") public class JaccardSimilarityDistanceFunction<O extends FeatureVector<?>> extends AbstractSetDistanceFunction<O> implements NormalizedPrimitiveSimilarityFunction<O>, NumberVectorDistanceFunction<O>, PrimitiveDistanceFunction<O> { /** * Constructor. No parameters. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/strings/LevenshteinDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/strings/LevenshteinDistanceFunction.java index 5a6aa5f6..a2b098e5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/strings/LevenshteinDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/strings/LevenshteinDistanceFunction.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * @author Felix Stahlberg * @author Erich Schubert + * @since 0.6.0 * * @apiviz.uses String */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/strings/NormalizedLevenshteinDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/strings/NormalizedLevenshteinDistanceFunction.java index 8a48038d..f2b3d7db 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/strings/NormalizedLevenshteinDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/strings/NormalizedLevenshteinDistanceFunction.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * @author Felix Stahlberg * @author Erich Schubert + * @since 0.6.0 * * @apiviz.uses String */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/AbstractDimensionsSelectingDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/AbstractDimensionsSelectingDistanceFunction.java index 98d753ff..17f493cd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/AbstractDimensionsSelectingDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/AbstractDimensionsSelectingDistanceFunction.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntListParameter; * Selected dimensions are encuded as bits in a {@code long[]}. * * @author Elke Achtert + * @since 0.2 * @param <V> the type of FeatureVector to compute the distances in between */ public abstract class AbstractDimensionsSelectingDistanceFunction<V extends FeatureVector<?>> extends AbstractPrimitiveDistanceFunction<V> implements PrimitiveDistanceFunction<V>, DimensionSelectingSubspaceDistanceFunction<V> { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/DimensionSelectingSubspaceDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/DimensionSelectingSubspaceDistanceFunction.java index e96dfd33..0e46d953 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/DimensionSelectingSubspaceDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/DimensionSelectingSubspaceDistanceFunction.java @@ -28,6 +28,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction; * Interface for dimension selecting subspace distance functions. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/OnedimensionalDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/OnedimensionalDistanceFunction.java index 58b16354..e37287e3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/OnedimensionalDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/OnedimensionalDistanceFunction.java @@ -28,6 +28,7 @@ import de.lmu.ifi.dbs.elki.data.spatial.SpatialComparable; import de.lmu.ifi.dbs.elki.data.type.VectorFieldTypeInformation; import de.lmu.ifi.dbs.elki.data.type.VectorTypeInformation; import de.lmu.ifi.dbs.elki.distance.distancefunction.AbstractSpatialNorm; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.BitsUtil; import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; @@ -40,7 +41,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * absolute difference of their values in a specified dimension only. * * @author Elke Achtert + * @since 0.2 */ +@Alias("de.lmu.ifi.dbs.elki.distance.distancefunction.subspace.DimensionSelectingDistanceFunction") public class OnedimensionalDistanceFunction extends AbstractSpatialNorm implements DimensionSelectingSubspaceDistanceFunction<NumberVector> { /** * The dimension to be considered for distance computation. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/SubspaceEuclideanDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/SubspaceEuclideanDistanceFunction.java index baa67c60..57895724 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/SubspaceEuclideanDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/SubspaceEuclideanDistanceFunction.java @@ -25,6 +25,7 @@ package de.lmu.ifi.dbs.elki.distance.distancefunction.subspace; import de.lmu.ifi.dbs.elki.data.NumberVector; import de.lmu.ifi.dbs.elki.data.spatial.SpatialComparable; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.BitsUtil; /** @@ -32,7 +33,9 @@ import de.lmu.ifi.dbs.elki.utilities.BitsUtil; * dimensions. * * @author Elke Achtert + * @since 0.2 */ +@Alias("de.lmu.ifi.dbs.elki.distance.distancefunction.subspace.DimensionsSelectingEuclideanDistanceFunction") public class SubspaceEuclideanDistanceFunction extends SubspaceLPNormDistanceFunction { /** * Constructor. @@ -144,4 +147,4 @@ public class SubspaceEuclideanDistanceFunction extends SubspaceLPNormDistanceFun return new SubspaceEuclideanDistanceFunction(dimensions); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/SubspaceLPNormDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/SubspaceLPNormDistanceFunction.java index 69ca26a2..f3102c76 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/SubspaceLPNormDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/SubspaceLPNormDistanceFunction.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * dimensions. * * @author Elke Achtert + * @since 0.2 */ public class SubspaceLPNormDistanceFunction extends AbstractDimensionsSelectingDistanceFunction<NumberVector> implements SpatialPrimitiveDistanceFunction<NumberVector>, Norm<NumberVector>, NumberVectorDistanceFunction<NumberVector> { /** @@ -198,4 +199,4 @@ public class SubspaceLPNormDistanceFunction extends AbstractDimensionsSelectingD return new SubspaceLPNormDistanceFunction(p, dimensions); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/SubspaceManhattanDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/SubspaceManhattanDistanceFunction.java index 4e2e1ed5..87168695 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/SubspaceManhattanDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/SubspaceManhattanDistanceFunction.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.BitsUtil; * dimensions. * * @author Elke Achtert + * @since 0.5.0 */ public class SubspaceManhattanDistanceFunction extends SubspaceLPNormDistanceFunction { /** @@ -130,4 +131,4 @@ public class SubspaceManhattanDistanceFunction extends SubspaceLPNormDistanceFun return new SubspaceManhattanDistanceFunction(dimensions); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/SubspaceMaximumDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/SubspaceMaximumDistanceFunction.java index edf88ef6..e24ff4cc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/SubspaceMaximumDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/subspace/SubspaceMaximumDistanceFunction.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.BitsUtil; * dimensions. * * @author Elke Achtert + * @since 0.5.0 */ public class SubspaceMaximumDistanceFunction extends SubspaceLPNormDistanceFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/AbstractEditDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/AbstractEditDistanceFunction.java index 6eb4a0cf..37d611a4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/AbstractEditDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/AbstractEditDistanceFunction.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Edit Distance for FeatureVectors. * * @author Thomas Bernecker + * @since 0.2 */ public abstract class AbstractEditDistanceFunction extends AbstractNumberVectorDistanceFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/DTWDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/DTWDistanceFunction.java index b3a1e19f..deddb490 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/DTWDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/DTWDistanceFunction.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * * @author Thomas Bernecker * @author Erich Schubert + * @since 0.2 */ @Title("Dynamic Time Warping Distance Function") @Reference(authors = "Berndt, D. and Clifford, J.", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/DerivativeDTWDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/DerivativeDTWDistanceFunction.java index c21997cb..4116fb94 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/DerivativeDTWDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/DerivativeDTWDistanceFunction.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * </p> * * @author Lara Hirschbeck, Daniel Kolb + * @since 0.2 */ @Title("Derivative dynamic time warping") @Reference(authors = "E. J. Keogh and M. J. Pazzani", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/EDRDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/EDRDistanceFunction.java index c6d01419..afc7b8de 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/EDRDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/EDRDistanceFunction.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * </p> * * @author Thomas Bernecker + * @since 0.2 */ @Title("Edit Distance on Real Sequence") @Reference(authors = "L. Chen and M. T. Özsu and V. Oria", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/ERPDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/ERPDistanceFunction.java index 39341d1e..93fd98bd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/ERPDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/ERPDistanceFunction.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * </p> * * @author Thomas Bernecker + * @since 0.2 */ @Title("Edit Distance with Real Penalty") @Reference(authors = "L. Chen and R. Ng", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/LCSSDistanceFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/LCSSDistanceFunction.java index 2d71ba1c..12e2752d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/LCSSDistanceFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/distancefunction/timeseries/LCSSDistanceFunction.java @@ -68,6 +68,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * * * @author Thomas Bernecker + * @since 0.2 */ @Title("Longest Common Subsequence distance function") @Reference(authors = "M. Vlachos, M. Hadjieleftheriou, D. Gunopulos, E. Keogh", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/AbstractDBIDSimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/AbstractDBIDSimilarityFunction.java index 9a4f2f58..9c440aee 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/AbstractDBIDSimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/AbstractDBIDSimilarityFunction.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * Abstract super class for distance functions needing a preprocessor. * * @author Elke Achtert + * @since 0.4.0 */ public abstract class AbstractDBIDSimilarityFunction extends AbstractPrimitiveSimilarityFunction<DBID> implements DBIDSimilarityFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/AbstractIndexBasedSimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/AbstractIndexBasedSimilarityFunction.java index 014ed7c9..16ba4e7f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/AbstractIndexBasedSimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/AbstractIndexBasedSimilarityFunction.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Abstract super class for distance functions needing a preprocessor. * * @author Elke Achtert + * @since 0.4.0 * * @apiviz.uses IndexFactory * @apiviz.has Instance oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/AbstractPrimitiveSimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/AbstractPrimitiveSimilarityFunction.java index 0cfb7c2a..7f1775ed 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/AbstractPrimitiveSimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/AbstractPrimitiveSimilarityFunction.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * Base implementation of a similarity function. * * @author Arthur Zimek + * @since 0.4.0 * * @apiviz.excludeSubtypes * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/AbstractVectorSimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/AbstractVectorSimilarityFunction.java index 1550c6c3..a09aff09 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/AbstractVectorSimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/AbstractVectorSimilarityFunction.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.data.type.TypeUtil; * Abstract base class for double-valued primitive similarity functions. * * @author Erich Schubert + * @since 0.4.0 */ public abstract class AbstractVectorSimilarityFunction extends AbstractPrimitiveSimilarityFunction<NumberVector> implements PrimitiveSimilarityFunction<NumberVector> { @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/DBIDSimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/DBIDSimilarityFunction.java index cd8c8a0e..3db8b672 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/DBIDSimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/DBIDSimilarityFunction.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBID; * function defined over object IDs. * * @author Elke Achtert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.uses DBID oneway - - defined on diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/FractionalSharedNearestNeighborSimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/FractionalSharedNearestNeighborSimilarityFunction.java index 046d3725..36195869 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/FractionalSharedNearestNeighborSimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/FractionalSharedNearestNeighborSimilarityFunction.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * Strings that define a non-negative Integer. * * @author Arthur Zimek + * @since 0.2 * * @apiviz.has * de.lmu.ifi.dbs.elki.index.preprocessed.snn.SharedNearestNeighborIndex diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/IndexBasedSimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/IndexBasedSimilarityFunction.java index 989178b5..1b79330d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/IndexBasedSimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/IndexBasedSimilarityFunction.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.index.Index; * Interface for preprocessor/index based similarity functions. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has Instance oneway - - «create» * @apiviz.landmark diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/InvertedDistanceSimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/InvertedDistanceSimilarityFunction.java index 3238b263..2e921066 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/InvertedDistanceSimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/InvertedDistanceSimilarityFunction.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; * 1/distance. * * @author Erich Schubert + * @since 0.5.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/Kulczynski1SimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/Kulczynski1SimilarityFunction.java index a4f43310..1f84efcb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/Kulczynski1SimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/Kulczynski1SimilarityFunction.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 */ @Reference(authors = "M.-M. Deza and E. Deza", title = "Dictionary of distances", booktitle = "Dictionary of distances") public class Kulczynski1SimilarityFunction extends AbstractVectorSimilarityFunction { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/Kulczynski2SimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/Kulczynski2SimilarityFunction.java index 29fedb2e..15ab839f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/Kulczynski2SimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/Kulczynski2SimilarityFunction.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * TODO: add an optimized version for binary data. * * @author Erich Schubert + * @since 0.6.0 */ @Reference(authors = "M.-M. Deza and E. Deza", title = "Dictionary of distances", booktitle = "Dictionary of distances") public class Kulczynski2SimilarityFunction extends AbstractVectorSimilarityFunction { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/NormalizedPrimitiveSimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/NormalizedPrimitiveSimilarityFunction.java index 9f7fd624..d43d095e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/NormalizedPrimitiveSimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/NormalizedPrimitiveSimilarityFunction.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.distance.similarityfunction; * limited to the 0-1 value range. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/NormalizedSimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/NormalizedSimilarityFunction.java index 0194b614..28dc1722 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/NormalizedSimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/NormalizedSimilarityFunction.java @@ -29,6 +29,7 @@ package de.lmu.ifi.dbs.elki.distance.similarityfunction; * produce values in the range of [0:1]. * * @author Erich Schubert + * @since 0.2 * @param <O> object type */ public interface NormalizedSimilarityFunction<O> extends SimilarityFunction<O> { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/PrimitiveSimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/PrimitiveSimilarityFunction.java index 308711f0..085e245a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/PrimitiveSimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/PrimitiveSimilarityFunction.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.data.type.SimpleTypeInformation; * function. * * @author Elke Achtert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.excludeSubtypes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/SharedNearestNeighborSimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/SharedNearestNeighborSimilarityFunction.java index c48b1dd3..6bb6f37b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/SharedNearestNeighborSimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/SharedNearestNeighborSimilarityFunction.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * Strings that define a non-negative Integer. * * @author Arthur Zimek + * @since 0.2 * * @apiviz.has * de.lmu.ifi.dbs.elki.index.preprocessed.snn.SharedNearestNeighborIndex diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/SimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/SimilarityFunction.java index 95a8d59d..2315ec85 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/SimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/SimilarityFunction.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * function. * * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusterIntersectionSimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusterIntersectionSimilarityFunction.java index e7758720..dd5d0dcd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusterIntersectionSimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusterIntersectionSimilarityFunction.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Measure the similarity of clusters via the intersection size. * * @author Erich Schubert + * @since 0.7.0 */ public class ClusterIntersectionSimilarityFunction extends AbstractPrimitiveSimilarityFunction<Cluster<?>> implements PrimitiveDistanceFunction<Cluster<?>> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusterJaccardSimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusterJaccardSimilarityFunction.java index f67e4bc3..79993a5a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusterJaccardSimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusterJaccardSimilarityFunction.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "P. Jaccard", // title = "Distribution de la florine alpine dans la Bassin de Dranses et dans quelques regiones voisines", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringAdjustedRandIndexSimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringAdjustedRandIndexSimilarityFunction.java index 5d742ad1..255168fb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringAdjustedRandIndexSimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringAdjustedRandIndexSimilarityFunction.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "Rand, W. M.", // title = "Objective Criteria for the Evaluation of Clustering Methods", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringBCubedF1SimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringBCubedF1SimilarityFunction.java index d4806cc4..58f7c3d9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringBCubedF1SimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringBCubedF1SimilarityFunction.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "Bagga, A. and Baldwin, B.", // title = "Entity-based cross-document coreferencing using the Vector Space Model", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringDistanceSimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringDistanceSimilarityFunction.java index cc207a26..890c24db 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringDistanceSimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringDistanceSimilarityFunction.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.distance.similarityfunction.PrimitiveSimilarityFuncti * Distance and similarity measure for clusterings. * * @author Erich Schubert + * @since 0.6.0 */ public interface ClusteringDistanceSimilarityFunction extends PrimitiveSimilarityFunction<Clustering<?>>, PrimitiveDistanceFunction<Clustering<?>> { @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringFowlkesMallowsSimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringFowlkesMallowsSimilarityFunction.java index e23fd289..0b9e99a7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringFowlkesMallowsSimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringFowlkesMallowsSimilarityFunction.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "Fowlkes, E.B. and Mallows, C.L.", // title = "A method for comparing two hierarchical clusterings", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringRandIndexSimilarityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringRandIndexSimilarityFunction.java index 4719d1f6..13572924 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringRandIndexSimilarityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/cluster/ClusteringRandIndexSimilarityFunction.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "Rand, W. M.", // title = "Objective Criteria for the Evaluation of Clustering Methods", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/KernelMatrix.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/KernelMatrix.java index d747bc01..24195f7a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/KernelMatrix.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/KernelMatrix.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Matrix; * Kernel matrix representation. * * @author Simon Paradies + * @since 0.2 * * @apiviz.uses PrimitiveSimilarityFunction */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/LaplaceKernelFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/LaplaceKernelFunction.java index 1e0f3515..3a26e43a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/LaplaceKernelFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/LaplaceKernelFunction.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Laplace / exponential radial basis function kernel. * * @author Erich Schubert + * @since 0.2 */ public class LaplaceKernelFunction extends AbstractVectorSimilarityFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/LinearKernelFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/LinearKernelFunction.java index ca0d62fd..39380c11 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/LinearKernelFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/LinearKernelFunction.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * {@link de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction} * * @author Simon Paradies + * @since 0.2 */ public class LinearKernelFunction extends PolynomialKernelFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/PolynomialKernelFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/PolynomialKernelFunction.java index 9fe6b943..16249ec8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/PolynomialKernelFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/PolynomialKernelFunction.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * vectors V1 and V2 defined by (V1^T*V2)^degree. * * @author Simon Paradies + * @since 0.2 */ public class PolynomialKernelFunction extends AbstractVectorSimilarityFunction implements PrimitiveDistanceFunction<NumberVector> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/RadialBasisFunctionKernelFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/RadialBasisFunctionKernelFunction.java index c786f77d..b8bfa7e4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/RadialBasisFunctionKernelFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/RadialBasisFunctionKernelFunction.java @@ -37,8 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Gaussian radial basis function kernel (RBF Kernel). * * @author Erich Schubert + * @since 0.2 */ -@Alias({ "rbf" }) +@Alias("rbf") public class RadialBasisFunctionKernelFunction extends AbstractVectorSimilarityFunction { /** * Scaling factor gamma. (= - 1/(2sigma^2)) diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/RationalQuadraticKernelFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/RationalQuadraticKernelFunction.java index 91264881..ea8c746e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/RationalQuadraticKernelFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/RationalQuadraticKernelFunction.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * RBF kernel ({@link RadialBasisFunctionKernelFunction}). * * @author Erich Schubert + * @since 0.2 */ public class RationalQuadraticKernelFunction extends AbstractVectorSimilarityFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/SigmoidKernelFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/SigmoidKernelFunction.java index 82eb5ea6..7a752a3a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/SigmoidKernelFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/distance/similarityfunction/kernel/SigmoidKernelFunction.java @@ -26,6 +26,7 @@ package de.lmu.ifi.dbs.elki.distance.similarityfunction.kernel; import de.lmu.ifi.dbs.elki.data.NumberVector; import de.lmu.ifi.dbs.elki.distance.distancefunction.AbstractNumberVectorDistanceFunction; import de.lmu.ifi.dbs.elki.distance.similarityfunction.AbstractVectorSimilarityFunction; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; @@ -36,7 +37,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * perceptron MLP kernel). * * @author Erich Schubert + * @since 0.2 */ +@Alias("sigmoid") public class SigmoidKernelFunction extends AbstractVectorSimilarityFunction { /** * Scaling factor c, bias theta @@ -59,7 +62,7 @@ public class SigmoidKernelFunction extends AbstractVectorSimilarityFunction { public double similarity(NumberVector o1, NumberVector o2) { final int dim = AbstractNumberVectorDistanceFunction.dimensionality(o1, o2); double sim = 0.; - for (int i = 0; i < dim; i++) { + for(int i = 0; i < dim; i++) { final double v = o1.doubleValue(i) * o2.doubleValue(i); sim += v; } @@ -93,11 +96,11 @@ public class SigmoidKernelFunction extends AbstractVectorSimilarityFunction { protected void makeOptions(Parameterization config) { super.makeOptions(config); final DoubleParameter cP = new DoubleParameter(C_ID, 1.); - if (config.grab(cP)) { + if(config.grab(cP)) { c = cP.doubleValue(); } final DoubleParameter thetaP = new DoubleParameter(THETA_ID, 0.); - if (config.grab(thetaP)) { + if(config.grab(thetaP)) { theta = thetaP.doubleValue(); } } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/AutomaticEvaluation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/AutomaticEvaluation.java index 484b55c5..0763f69e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/AutomaticEvaluation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/AutomaticEvaluation.java @@ -50,6 +50,7 @@ import de.lmu.ifi.dbs.elki.utilities.scaling.LinearScaling; * Evaluator that tries to auto-run a number of evaluation methods. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/Evaluator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/Evaluator.java index ad8d06db..636b4c8a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/Evaluator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/Evaluator.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.result.ResultProcessor; * evaluations, ... * * @author Erich Schubert + * @since 0.2 * * @apiviz.excludeSubtypes */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/NoAutomaticEvaluation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/NoAutomaticEvaluation.java index c2fd7811..e6cd96a2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/NoAutomaticEvaluation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/NoAutomaticEvaluation.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * evaluation to run. * * @author Erich Schubert + * @since 0.2 */ public class NoAutomaticEvaluation implements Evaluator { @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/ConfusionMatrix.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/ConfusionMatrix.java index 78be5b52..73098bc5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/ConfusionMatrix.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/ConfusionMatrix.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.data.ClassLabel; * can be derived from a confusion matrix. * * @author Arthur Zimek + * @since 0.7.0 */ public class ConfusionMatrix { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/ConfusionMatrixEvaluationResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/ConfusionMatrixEvaluationResult.java index 87ad6df3..02d35025 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/ConfusionMatrixEvaluationResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/ConfusionMatrixEvaluationResult.java @@ -30,10 +30,13 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterStream; /** * Provides the prediction performance measures for a classifier based on the * confusion matrix. - * + * * Note: this API is non-final, and will be refactored soon. * * @author Arthur Zimek + * @since 0.7.0 + * + * @apiviz.composedOf ConfusionMatrix */ public class ConfusionMatrixEvaluationResult implements Result, TextWriteable { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/AbstractHoldout.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/AbstractHoldout.java index cbe90475..bff2fa7f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/AbstractHoldout.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/AbstractHoldout.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * Split a data set for holdout evaluation. * * @author Erich Schubert + * @since 0.7.0 */ public abstract class AbstractHoldout implements Holdout { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/DisjointCrossValidation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/DisjointCrossValidation.java index c3c1df82..ecb872ac 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/DisjointCrossValidation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/DisjointCrossValidation.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * perform cross-validation. The test sets are guaranteed to be disjoint. * * @author Arthur Zimek + * @since 0.7.0 */ public class DisjointCrossValidation extends RandomizedHoldout { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/Holdout.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/Holdout.java index 69de2f9e..c2656147 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/Holdout.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/Holdout.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.datasource.bundle.MultipleObjectsBundle; * pairs of training and test data sets. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses MultipleObjectsBundle * @apiviz.has TrainingAndTestSet diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/LeaveOneOut.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/LeaveOneOut.java index ae638a39..e67d4a14 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/LeaveOneOut.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/LeaveOneOut.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.datasource.bundle.MultipleObjectsBundle; * remaining instances are training instances. * * @author Arthur Zimek + * @since 0.7.0 */ public class LeaveOneOut extends AbstractHoldout { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/RandomizedCrossValidation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/RandomizedCrossValidation.java index 868462d9..2921fc22 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/RandomizedCrossValidation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/RandomizedCrossValidation.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * to perform cross-validation. The test sets are not guaranteed to be disjoint. * * @author Arthur Zimek + * @since 0.7.0 */ public class RandomizedCrossValidation extends RandomizedHoldout { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/RandomizedHoldout.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/RandomizedHoldout.java index dd390421..aca68ed6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/RandomizedHoldout.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/RandomizedHoldout.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * A holdout providing a seed for randomized operations. * * @author Arthur Zimek + * @since 0.3 */ public abstract class RandomizedHoldout extends AbstractHoldout { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/StratifiedCrossValidation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/StratifiedCrossValidation.java index 3e0c4b2b..60af8179 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/StratifiedCrossValidation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/StratifiedCrossValidation.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * deterministic. * * @author Arthur Zimek + * @since 0.7.0 */ public class StratifiedCrossValidation extends AbstractHoldout { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/TrainingAndTestSet.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/TrainingAndTestSet.java index 7ee58663..3c1af309 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/TrainingAndTestSet.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/classification/holdout/TrainingAndTestSet.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.datasource.bundle.MultipleObjectsBundle; * training and test set are provided in labels. * * @author Arthur Zimek + * @since 0.7.0 */ public class TrainingAndTestSet { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/BCubed.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/BCubed.java index e4958527..4cf9ec0e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/BCubed.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/BCubed.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Sascha Goldhofer + * @since 0.5.0 */ @Reference(authors = "A. Bagga and B. Baldwin", // title = "Entity-based cross-document coreferencing using the Vector Space Model", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/ClusterContingencyTable.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/ClusterContingencyTable.java index e063b967..b269d2f9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/ClusterContingencyTable.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/ClusterContingencyTable.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.BitsUtil; * Class storing the contingency table and related data on two clusterings. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/EditDistance.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/EditDistance.java index 85764e2e..e07c84eb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/EditDistance.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/EditDistance.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Sascha Goldhofer + * @since 0.5.0 */ @Reference(authors = "Pantel, P. and Lin, D.", title = "Document clustering with committees", booktitle = "Proc. 25th ACM SIGIR conference on Research and development in information retrieval", url = "http://dx.doi.org/10.1145/564376.564412") public class EditDistance { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/Entropy.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/Entropy.java index b7770f71..17e3abca 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/Entropy.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/Entropy.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Sascha Goldhofer + * @since 0.5.0 */ @Reference(authors = "Meilă, M.", // title = "Comparing clusterings by the variation of information", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/EvaluateClustering.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/EvaluateClustering.java index a4c46191..473e713c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/EvaluateClustering.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/EvaluateClustering.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.result.EvaluationResult; import de.lmu.ifi.dbs.elki.result.Result; import de.lmu.ifi.dbs.elki.result.ResultHierarchy; import de.lmu.ifi.dbs.elki.result.ResultUtil; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.FormatUtil; import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; @@ -48,11 +49,13 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Evaluate a clustering result by comparing it to an existing cluster label. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.uses ClusterContingencyTable * @apiviz.has EvaluateClustering.ScoreResult oneway - - «create» */ +@Alias("de.lmu.ifi.dbs.elki.evaluation.paircounting.EvaluatePairCountingFMeasure") public class EvaluateClustering implements Evaluator { /** * Logger for debug output. @@ -313,4 +316,4 @@ public class EvaluateClustering implements Evaluator { return new EvaluateClustering(referencealg, noiseSpecialHandling, !selfPairing); } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/LogClusterSizes.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/LogClusterSizes.java index 9b4c2512..2b801cfb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/LogClusterSizes.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/LogClusterSizes.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.hierarchy.Hierarchy.Iter; * cluster sizes and the number of clusters. * * @author Erich Schubert + * @since 0.7.0 */ public class LogClusterSizes implements Evaluator { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/PairCounting.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/PairCounting.java index 3025f367..26f2d5db 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/PairCounting.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/PairCounting.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * Pair-counting measures. * * @author Erich Schubert + * @since 0.5.0 */ public class PairCounting { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/SetMatchingPurity.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/SetMatchingPurity.java index bbef4b5f..46bddd77 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/SetMatchingPurity.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/SetMatchingPurity.java @@ -54,6 +54,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Sascha Goldhofer + * @since 0.5.0 */ @Reference(authors = "Meilă, M", // title = "Comparing clusterings", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/extractor/ExtractFlatClusteringFromHierarchyEvaluator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/extractor/ExtractFlatClusteringFromHierarchyEvaluator.java index 258b983d..60f22623 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/extractor/ExtractFlatClusteringFromHierarchyEvaluator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/extractor/ExtractFlatClusteringFromHierarchyEvaluator.java @@ -54,6 +54,7 @@ import de.lmu.ifi.dbs.elki.workflow.AlgorithmStep; * from the same clustering, this can be useful. * * @author Erich Schubert + * @since 0.7.0 */ public class ExtractFlatClusteringFromHierarchyEvaluator implements Evaluator { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/extractor/HDBSCANHierarchyExtractionEvaluator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/extractor/HDBSCANHierarchyExtractionEvaluator.java index 4fa9f44f..456d1fc6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/extractor/HDBSCANHierarchyExtractionEvaluator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/extractor/HDBSCANHierarchyExtractionEvaluator.java @@ -52,6 +52,7 @@ import de.lmu.ifi.dbs.elki.workflow.AlgorithmStep; * from the same clustering, this can be useful. * * @author Erich Schubert + * @since 0.7.0 */ public class HDBSCANHierarchyExtractionEvaluator implements Evaluator { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/extractor/SimplifiedHierarchyExtractionEvaluator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/extractor/SimplifiedHierarchyExtractionEvaluator.java index 871ab121..0644a16c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/extractor/SimplifiedHierarchyExtractionEvaluator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/extractor/SimplifiedHierarchyExtractionEvaluator.java @@ -52,6 +52,7 @@ import de.lmu.ifi.dbs.elki.workflow.AlgorithmStep; * from the same clustering, this can be useful. * * @author Erich Schubert + * @since 0.7.0 */ public class SimplifiedHierarchyExtractionEvaluator implements Evaluator { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateCIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateCIndex.java index e43d9cc5..a96dfc91 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateCIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateCIndex.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction; import de.lmu.ifi.dbs.elki.distance.distancefunction.minkowski.EuclideanDistanceFunction; import de.lmu.ifi.dbs.elki.evaluation.Evaluator; import de.lmu.ifi.dbs.elki.logging.Logging; +import de.lmu.ifi.dbs.elki.logging.progress.FiniteProgress; import de.lmu.ifi.dbs.elki.logging.statistics.DoubleStatistic; import de.lmu.ifi.dbs.elki.logging.statistics.LongStatistic; import de.lmu.ifi.dbs.elki.logging.statistics.StringStatistic; @@ -43,7 +44,9 @@ import de.lmu.ifi.dbs.elki.result.EvaluationResult.MeasurementGroup; import de.lmu.ifi.dbs.elki.result.Result; import de.lmu.ifi.dbs.elki.result.ResultHierarchy; import de.lmu.ifi.dbs.elki.result.ResultUtil; -import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.DoubleArray; +import de.lmu.ifi.dbs.elki.utilities.datastructures.heap.DoubleHeap; +import de.lmu.ifi.dbs.elki.utilities.datastructures.heap.DoubleMaxHeap; +import de.lmu.ifi.dbs.elki.utilities.datastructures.heap.DoubleMinHeap; import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; @@ -53,10 +56,13 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; /** * Compute the C-index of a data set. + * + * Note: This requires pairwise distance computations, so it is not recommended + * to use this on larger data sets. * * Reference: * <p> - * L. J. Hubert and J.R. Levin <br /> + * L. J. Hubert and J. R. Levin <br /> * A general statistical framework for assessing categorical clustering in free * recall<br /> * Psychological Bulletin, Vol. 83(6) @@ -64,6 +70,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * * @author Stephan Baier * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf NoiseHandling */ @@ -115,15 +122,9 @@ public class EvaluateCIndex<O> implements Evaluator { public double evaluateClustering(Database db, Relation<? extends O> rel, DistanceQuery<O> dq, Clustering<?> c) { List<? extends Cluster<?>> clusters = c.getAllClusters(); - // theta is the sum, w the number of within group distances - double theta = 0; - int w = 0; - int ignorednoise = 0; - int isize = clusters.size() <= 1 ? rel.size() : rel.size() / (clusters.size() - 1); - DoubleArray pairDists = new DoubleArray(isize); - - for(int i = 0; i < clusters.size(); i++) { - Cluster<?> cluster = clusters.get(i); + // Count ignored noise, and within-cluster distances + int ignorednoise = 0, w = 0; + for(Cluster<?> cluster : clusters) { if(cluster.size() <= 1 || cluster.isNoise()) { switch(noiseOption){ case IGNORE_NOISE: @@ -135,41 +136,51 @@ public class EvaluateCIndex<O> implements Evaluator { break; // Treat like a cluster } } - for(DBIDIter it1 = cluster.getIDs().iter(); it1.valid(); it1.advance()) { - O obj = rel.get(it1); - // Compare object to every cluster, but only once - for(int j = i; j < clusters.size(); j++) { - Cluster<?> ocluster = clusters.get(j); - if(ocluster.size() <= 1 || ocluster.isNoise()) { - switch(noiseOption){ - case IGNORE_NOISE: - continue; // Ignore this cluster. - case TREAT_NOISE_AS_SINGLETONS: - case MERGE_NOISE: - break; // Treat like a cluster - } - } - for(DBIDIter it2 = ocluster.getIDs().iter(); it2.valid(); it2.advance()) { - if(DBIDUtil.compare(it1, it2) <= 0) { // Only once. - continue; - } - double dist = dq.distance(obj, rel.get(it2)); - pairDists.add(dist); - if(ocluster == cluster) { // Within-cluster distances. - theta += dist; - w++; - } + w += (cluster.size() * (cluster.size() - 1)) >>> 1; + } + + double theta = 0.; // Sum of within-cluster distances + double min = 0, max = 0; // Sum of larges and smallest + if(w <= (rel.size() * (rel.size() - 1L)) >>> 2) { + DoubleHeap maxDists = new DoubleMinHeap(w); // Careful: REALLY minHeap! + DoubleHeap minDists = new DoubleMaxHeap(w); // Careful: REALLY maxHeap! + + FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("Processing clusters for C-Index", clusters.size(), LOG) : null; + for(int i = 0; i < clusters.size(); i++) { + Cluster<?> cluster = clusters.get(i); + if(cluster.size() <= 1 || cluster.isNoise()) { + switch(noiseOption){ + case IGNORE_NOISE: + LOG.incrementProcessed(prog); + continue; // Ignore + case TREAT_NOISE_AS_SINGLETONS: + processSingleton(cluster, rel, dq, maxDists, minDists, w); + LOG.incrementProcessed(prog); + continue; + case MERGE_NOISE: + break; // Treat like a cluster, below } } + theta += processCluster(cluster, clusters, i, dq, maxDists, minDists, w); + LOG.incrementProcessed(prog); } - } + LOG.ensureCompleted(prog); - // Simulate best and worst cases: - pairDists.sort(); - double min = 0, max = 0; - for(int i = 0, j = pairDists.size() - 1; i < w; i++, j--) { - min += pairDists.get(i); - max += pairDists.get(j); + // Simulate best and worst cases: + assert (minDists.size() == w); + assert (maxDists.size() == w); + for(DoubleHeap.UnsortedIter it = minDists.unsortedIter(); it.valid(); it.advance()) { + min += it.get(); + } + for(DoubleHeap.UnsortedIter it = maxDists.unsortedIter(); it.valid(); it.advance()) { + max += it.get(); + } + assert (max >= min); + } + else { + // Since we have fewer cross-cluster distances than within-cluster + // distances, min=max and cIndex = 0. + theta = min = max = 0; } double cIndex = (max > min) ? (theta - min) / (max - min) : 0.; @@ -189,6 +200,52 @@ public class EvaluateCIndex<O> implements Evaluator { return cIndex; } + protected double processCluster(Cluster<?> cluster, List<? extends Cluster<?>> clusters, int i, DistanceQuery<O> dq, DoubleHeap maxDists, DoubleHeap minDists, int w) { + double theta = 0.; + for(DBIDIter it1 = cluster.getIDs().iter(); it1.valid(); it1.advance()) { + // Compare object to every cluster, but only once + for(int j = i; j < clusters.size(); j++) { + Cluster<?> ocluster = clusters.get(j); + if(ocluster.size() <= 1 || ocluster.isNoise()) { + switch(noiseOption){ + case IGNORE_NOISE: + continue; // Ignore this cluster. + case TREAT_NOISE_AS_SINGLETONS: + break; // Treat like a cluster + case MERGE_NOISE: + break; // Treat like a cluster + } + } + for(DBIDIter it2 = ocluster.getIDs().iter(); it2.valid(); it2.advance()) { + if(DBIDUtil.compare(it1, it2) <= 0) { // Only once. + continue; + } + double dist = dq.distance(it1, it2); + minDists.add(dist, w); + maxDists.add(dist, w); + if(ocluster == cluster) { // Within-cluster distances. + theta += dist; + } + } + } + } + return theta; + } + + protected void processSingleton(Cluster<?> cluster, Relation<? extends O> rel, DistanceQuery<O> dq, DoubleHeap maxDists, DoubleHeap minDists, int w) { + // All other objects are in other clusters! + for(DBIDIter it1 = cluster.getIDs().iter(); it1.valid(); it1.advance()) { + for(DBIDIter it2 = rel.iterDBIDs(); it2.valid(); it2.advance()) { + if(DBIDUtil.compare(it1, it2) <= 0) { // Only once. + continue; + } + double dist = dq.distance(it1, it2); + minDists.add(dist, w); + maxDists.add(dist, w); + } + } + } + @Override public void processNewResult(ResultHierarchy hier, Result result) { List<Clustering<?>> crs = ResultUtil.getClusteringResults(result); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateConcordantPairs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateConcordantPairs.java index c5d2c199..119e9006 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateConcordantPairs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateConcordantPairs.java @@ -73,6 +73,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * * @author Stephan Baier * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf NoiseHandling */ @@ -312,7 +313,7 @@ public class EvaluateConcordantPairs<O> implements Evaluator { /** * Parameter for the option, how noise should be treated. */ - public static final OptionID NOISE_ID = new OptionID("davies-bouldin.noisehandling", "option, how noise should be treated."); + public static final OptionID NOISE_ID = new OptionID("concordant-pairs.noisehandling", "Control how noise should be treated."); /** * Distance function to use. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateDaviesBouldin.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateDaviesBouldin.java index ddeef150..d652a13a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateDaviesBouldin.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateDaviesBouldin.java @@ -63,6 +63,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Stephan Baier + * @since 0.7.0 * * @apiviz.composedOf NoiseHandling */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluatePBMIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluatePBMIndex.java index 2c3a20e0..5a893887 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluatePBMIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluatePBMIndex.java @@ -67,6 +67,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * * @author Stephan Baier * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf NoiseHandling */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateSilhouette.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateSilhouette.java index b40e6086..257ff1ea 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateSilhouette.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateSilhouette.java @@ -92,6 +92,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * TODO: keep all silhouette values, and allow visualization! * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf NoiseHandling * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateSimplifiedSilhouette.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateSimplifiedSilhouette.java index a3f7e889..7ae8193c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateSimplifiedSilhouette.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateSimplifiedSilhouette.java @@ -60,6 +60,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * * @author Stephan Baier * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf NoiseHandling */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateSquaredErrors.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateSquaredErrors.java index eec64fc4..0ea8cbf8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateSquaredErrors.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateSquaredErrors.java @@ -87,6 +87,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * by k-means. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf NoiseHandling */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateVarianceRatioCriteria.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateVarianceRatioCriteria.java index a48a410c..e8935593 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateVarianceRatioCriteria.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/EvaluateVarianceRatioCriteria.java @@ -65,6 +65,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag; * * @author Stephan Baier * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf NoiseHandling */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/NoiseHandling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/NoiseHandling.java index 7145ed94..759636d8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/NoiseHandling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/internal/NoiseHandling.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.evaluation.clustering.internal; * * @author Stephan Baier * @author Erich Schubert + * @since 0.7.0 */ public enum NoiseHandling { /** Merge all noise into a cluster */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/pairsegments/ClusterPairSegmentAnalysis.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/pairsegments/ClusterPairSegmentAnalysis.java index 08d92c28..50deb3ce 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/pairsegments/ClusterPairSegmentAnalysis.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/pairsegments/ClusterPairSegmentAnalysis.java @@ -29,17 +29,31 @@ import de.lmu.ifi.dbs.elki.evaluation.Evaluator; import de.lmu.ifi.dbs.elki.result.Result; import de.lmu.ifi.dbs.elki.result.ResultHierarchy; import de.lmu.ifi.dbs.elki.result.ResultUtil; +import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; /** * Evaluate clustering results by building segments for their pairs: shared * pairs and differences. * + * Reference: + * <p> + * Evaluation of Clusterings – Metrics and Visual Support<br /> + * Elke Achtert, Sascha Goldhofer, Hans-Peter Kriegel, Erich Schubert, Arthur + * Zimek<br /> + * In: Proc. 28th International Conference on Data Engineering (ICDE) 2012 + * </p> + * * @author Sascha Goldhofer * @author Erich Schubert + * @since 0.5.0 * * @apiviz.uses Clustering * @apiviz.uses Segments */ +@Reference(title = "Evaluation of Clusterings – Metrics and Visual Support", // +authors = "Elke Achtert, Sascha Goldhofer, Hans-Peter Kriegel, Erich Schubert, Arthur Zimek", // +booktitle = "Proc. 28th International Conference on Data Engineering (ICDE) 2012", // +url = "http://dx.doi.org/10.1109/ICDE.2012.128") public class ClusterPairSegmentAnalysis implements Evaluator { /** * Constructor. @@ -55,7 +69,7 @@ public class ClusterPairSegmentAnalysis implements Evaluator { public void processNewResult(ResultHierarchy hier, Result result) { // Get all new clusterings // TODO: handle clusterings added later, too. Can we update the result? - + List<Clustering<?>> clusterings = ResultUtil.getClusteringResults(result); // Abort if not enough clusterings to compare if(clusterings.size() < 2) { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/pairsegments/Segment.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/pairsegments/Segment.java index 1ed31b03..4df28760 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/pairsegments/Segment.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/pairsegments/Segment.java @@ -33,6 +33,10 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDs; * * As such, for each ring (= clustering), a cluster number (or the constant * {@link #UNCLUSTERED}) is stored. + * + * @author Sascha Goldhofer + * @author Erich Schubert + * @since 0.5.0 */ public class Segment implements Comparable<Segment> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/pairsegments/Segments.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/pairsegments/Segments.java index 8b91d5f6..5b59b17f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/pairsegments/Segments.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/clustering/pairsegments/Segments.java @@ -59,8 +59,8 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * a corresponding object Segment. * </p> * + * Reference: * <p> - * Reference:<br /> * Evaluation of Clusterings – Metrics and Visual Support<br /> * Elke Achtert, Sascha Goldhofer, Hans-Peter Kriegel, Erich Schubert, Arthur * Zimek<br /> @@ -68,17 +68,21 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * <p> - * Details on the experimental setup can be found at: <a - * href="http://elki.dbs.ifi.lmu.de/wiki/Examples/ClusterEvaluation" - * >wiki/Examples/ClusterEvaluation</a> + * Details on the experimental setup can be found at: + * <a href="http://elki.dbs.ifi.lmu.de/wiki/Examples/ClusterEvaluation" >wiki/ + * Examples/ClusterEvaluation</a> * </p> * * @author Sascha Goldhofer * @author Erich Schubert + * @since 0.5.0 * * @apiviz.composedOf Segment */ -@Reference(title = "Evaluation of Clusterings – Metrics and Visual Support", authors = "Elke Achtert, Sascha Goldhofer, Hans-Peter Kriegel, Erich Schubert, Arthur Zimek", booktitle = "Proc. 28th International Conference on Data Engineering (ICDE) 2012", url = "http://dx.doi.org/10.1109/ICDE.2012.128") +@Reference(title = "Evaluation of Clusterings – Metrics and Visual Support", // +authors = "Elke Achtert, Sascha Goldhofer, Hans-Peter Kriegel, Erich Schubert, Arthur Zimek", // +booktitle = "Proc. 28th International Conference on Data Engineering (ICDE) 2012", // +url = "http://dx.doi.org/10.1109/ICDE.2012.128") public class Segments extends BasicResult implements Iterable<Segment> { /** * Class logger diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/histogram/ComputeOutlierHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/histogram/ComputeOutlierHistogram.java index 8a6bd542..64a1ce3c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/histogram/ComputeOutlierHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/histogram/ComputeOutlierHistogram.java @@ -66,6 +66,7 @@ import de.lmu.ifi.dbs.elki.utilities.scaling.outlier.OutlierScalingFunction; * * @author Lisa Reichert * @author Erich Schubert + * @since 0.3 * * @apiviz.landmark * @apiviz.uses OutlierResult diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/index/IndexPurity.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/index/IndexPurity.java index bde4eaa3..30d3590d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/index/IndexPurity.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/index/IndexPurity.java @@ -51,6 +51,7 @@ import de.lmu.ifi.dbs.elki.utilities.DatabaseUtil; * capabilities using the Gini index. * * @author Erich Schubert + * @since 0.5.0 */ public class IndexPurity implements Evaluator { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/index/IndexStatistics.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/index/IndexStatistics.java index a137b455..5e01462f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/index/IndexStatistics.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/index/IndexStatistics.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; * information. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.has IndexMetaResult oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/JudgeOutlierScores.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/JudgeOutlierScores.java index 6674293d..6c84be65 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/JudgeOutlierScores.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/JudgeOutlierScores.java @@ -60,6 +60,7 @@ import de.lmu.ifi.dbs.elki.utilities.scaling.outlier.OutlierScalingFunction; * hits. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.has ScoreResult oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierPrecisionAtKCurve.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierPrecisionAtKCurve.java index 3ce0e782..a52b829a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierPrecisionAtKCurve.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierPrecisionAtKCurve.java @@ -52,6 +52,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.PatternParameter; * method. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.has PrecisionAtKCurve */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierPrecisionRecallCurve.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierPrecisionRecallCurve.java index 3b1d7375..576a0c9b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierPrecisionRecallCurve.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierPrecisionRecallCurve.java @@ -52,6 +52,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.PatternParameter; * method. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.has PRCurve */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierROCCurve.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierROCCurve.java index f0ebcd88..540cba6d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierROCCurve.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierROCCurve.java @@ -62,13 +62,15 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.PatternParameter; * clustering obtained via the given class label. * * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark * * @apiviz.uses OutlierResult * @apiviz.has ROCResult oneway - - «create» */ -@Alias({ "ComputeROCCurve", "de.lmu.ifi.dbs.elki.evaluation.roc.ComputeROCCurve" }) +@Alias({ "de.lmu.ifi.dbs.elki.evaluation.roc.ComputeROCCurve", // +"de.lmu.ifi.dbs.elki.evaluation.ComputeROCCurve" }) public class OutlierROCCurve implements Evaluator { /** * The label we use for marking ROCAUC values. @@ -142,7 +144,8 @@ public class OutlierROCCurve implements Evaluator { if(nonefound) { return; - // logger.warning("No results found to process with ROC curve analyzer. Got "+iterables.size()+" iterables, "+orderings.size()+" orderings."); + // logger.warning("No results found to process with ROC curve analyzer. + // Got "+iterables.size()+" iterables, "+orderings.size()+" orderings."); } } @@ -209,6 +212,7 @@ public class OutlierROCCurve implements Evaluator { * </p> */ public static final OptionID POSITIVE_CLASS_NAME_ID = new OptionID("rocauc.positive", "Class label for the 'positive' class."); + /** * Pattern for positive class. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierRankingEvaluation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierRankingEvaluation.java index 43612178..407b4ec9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierRankingEvaluation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierRankingEvaluation.java @@ -57,6 +57,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.PatternParameter; * Evaluate outlier scores by their ranking * * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierSmROCCurve.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierSmROCCurve.java index b39211df..49ff1a42 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierSmROCCurve.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierSmROCCurve.java @@ -67,6 +67,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.PatternParameter; * </p> * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.uses OutlierResult * @apiviz.has SmROCResult oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierThresholdClustering.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierThresholdClustering.java index 9220d06e..9993e457 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierThresholdClustering.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/outlier/OutlierThresholdClustering.java @@ -54,6 +54,7 @@ import de.lmu.ifi.dbs.elki.utilities.scaling.outlier.OutlierScalingFunction; * dataset. * * @author Erich Schubert + * @since 0.5.0 */ public class OutlierThresholdClustering implements Evaluator { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/AbstractScoreEvaluation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/AbstractScoreEvaluation.java index 9f8e66df..bebb3e71 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/AbstractScoreEvaluation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/AbstractScoreEvaluation.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; * Abstract base class for evaluating a scoring result. * * @author Erich Schubert + * @since 0.7.0 */ public abstract class AbstractScoreEvaluation implements ScoreEvaluation { @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/AveragePrecisionEvaluation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/AveragePrecisionEvaluation.java index fadcb3cf..51fe6c59 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/AveragePrecisionEvaluation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/AveragePrecisionEvaluation.java @@ -28,6 +28,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Evaluate using average precision. * * @author Erich Schubert + * @since 0.7.0 */ public class AveragePrecisionEvaluation extends AbstractScoreEvaluation { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/MaximumF1Evaluation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/MaximumF1Evaluation.java index dce8a84b..4d96eaaa 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/MaximumF1Evaluation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/MaximumF1Evaluation.java @@ -28,6 +28,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Evaluate using the maximum F1 score. * * @author Erich Schubert + * @since 0.7.0 */ public class MaximumF1Evaluation extends AbstractScoreEvaluation { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/PrecisionAtKEvaluation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/PrecisionAtKEvaluation.java index 3850dd3a..ba6786b9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/PrecisionAtKEvaluation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/PrecisionAtKEvaluation.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * (BEP). * * @author Erich Schubert + * @since 0.7.0 */ public class PrecisionAtKEvaluation extends AbstractScoreEvaluation { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/ROCEvaluation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/ROCEvaluation.java index 32551238..416ecda1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/ROCEvaluation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/ROCEvaluation.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * has been used the wrong way, and should be used backwards. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has XYCurve */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/ScoreEvaluation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/ScoreEvaluation.java index 2f989609..053033e9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/ScoreEvaluation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/ScoreEvaluation.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.iterator.Iter; * Compute ranking/scoring based evaluation measures. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has ScoreIter * @apiviz.uses Predicate diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/AbstractVectorIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/AbstractVectorIter.java index f75844a0..70e6618c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/AbstractVectorIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/AbstractVectorIter.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.iterator.ArrayIter; * Class to iterate over a number vector in decreasing order. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf NumberVector */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/DBIDRefIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/DBIDRefIter.java index 3b246327..918a235c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/DBIDRefIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/DBIDRefIter.java @@ -28,6 +28,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; * A score iterator wrapping a DBIDRef object. * * @author Erich Schubert + * @since 0.4.0 */ public interface DBIDRefIter { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/DBIDsTest.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/DBIDsTest.java index 9e1b29e9..d1c65fbe 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/DBIDsTest.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/DBIDsTest.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.evaluation.scores.ScoreEvaluation.Predicate; * @apiviz.composedOf DBIDs * * @author Erich Schubert + * @since 0.7.0 */ public class DBIDsTest implements Predicate<DBIDRefIter> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/DecreasingVectorIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/DecreasingVectorIter.java index 953f656c..9da00a3e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/DecreasingVectorIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/DecreasingVectorIter.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arrays.IntegerComparator; * Class to iterate over a number vector in decreasing order. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf NumberVector */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/DistanceResultAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/DistanceResultAdapter.java index cd1a5142..53a165ba 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/DistanceResultAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/DistanceResultAdapter.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.evaluation.scores.ScoreEvaluation.ScoreIter; * ties. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf DoubleDBIDListIter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/FilteredDistanceResultAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/FilteredDistanceResultAdapter.java index 28c23251..4309e138 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/FilteredDistanceResultAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/FilteredDistanceResultAdapter.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DoubleDBIDListIter; * appropriately, the score is only used to detect ties. * * @author Erich Schubert + * @since 0.7.0 */ public class FilteredDistanceResultAdapter extends DistanceResultAdapter { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/IncreasingVectorIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/IncreasingVectorIter.java index 091a6fa1..d94c2990 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/IncreasingVectorIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/IncreasingVectorIter.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arrays.IntegerComparator; * Class to iterate over a number vector in decreasing order. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf NumberVector */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/OutlierScoreAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/OutlierScoreAdapter.java index 6dcf516a..3ff35876 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/OutlierScoreAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/OutlierScoreAdapter.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.result.outlier.OutlierResult; * The ROC values would be incorrect then anyway! * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf OutlierResult */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/SimpleAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/SimpleAdapter.java index e91f0f6d..681cdcdd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/SimpleAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/SimpleAdapter.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.evaluation.scores.ScoreEvaluation.ScoreIter; * The ROC values would be incorrect then anyway! * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf DBIDIter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/VectorNonZero.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/VectorNonZero.java index 343fa662..52753243 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/VectorNonZero.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/VectorNonZero.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.data.NumberVector; * @apiviz.composedOf NumberVector * * @author Erich Schubert + * @since 0.7.0 */ public class VectorNonZero extends VectorOverThreshold { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/VectorOverThreshold.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/VectorOverThreshold.java index e35db2ee..b77df57b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/VectorOverThreshold.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/VectorOverThreshold.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.evaluation.scores.ScoreEvaluation.Predicate; * @apiviz.composedOf NumberVector * * @author Erich Schubert + * @since 0.7.0 */ public class VectorOverThreshold implements Predicate<AbstractVectorIter> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/VectorZero.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/VectorZero.java index 08e694f9..aeead25b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/VectorZero.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/scores/adapter/VectorZero.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.evaluation.scores.ScoreEvaluation.Predicate; * @apiviz.composedOf NumberVector * * @author Erich Schubert + * @since 0.7.0 */ public class VectorZero implements Predicate<IncreasingVectorIter> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/similaritymatrix/ComputeSimilarityMatrixImage.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/similaritymatrix/ComputeSimilarityMatrixImage.java index d7883620..a5cf462c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/similaritymatrix/ComputeSimilarityMatrixImage.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/evaluation/similaritymatrix/ComputeSimilarityMatrixImage.java @@ -65,6 +65,7 @@ import de.lmu.ifi.dbs.elki.utilities.scaling.ScalingFunction; * Compute a similarity matrix for a distance function. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has SimilarityMatrix oneway - - «create» * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/GUIUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/GUIUtil.java index b7d4ee18..210f4e2e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/GUIUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/GUIUtil.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * GUI utilities. * * @author Erich Schubert + * @since 0.5.5 */ public final class GUIUtil { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/AbstractParameterConfigurator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/AbstractParameterConfigurator.java index d1d89d69..9905ad59 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/AbstractParameterConfigurator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/AbstractParameterConfigurator.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * Abstract class to produce a configurator for a particular parameter. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has StockIcon * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/AbstractSingleParameterConfigurator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/AbstractSingleParameterConfigurator.java index de040cc7..bb298994 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/AbstractSingleParameterConfigurator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/AbstractSingleParameterConfigurator.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * Base class for MiniGUI input helpers * * @author Erich Schubert + * @since 0.4.0 * * @param <T> Parameter type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/ClassListParameterConfigurator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/ClassListParameterConfigurator.java index ddc25f2e..0d76aa95 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/ClassListParameterConfigurator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/ClassListParameterConfigurator.java @@ -56,6 +56,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * Additionally, the classes can in turn have additional parameters. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses ClassListParameter * @apiviz.uses ClassTree diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/ClassParameterConfigurator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/ClassParameterConfigurator.java index 7bc81fed..07f1e14f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/ClassParameterConfigurator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/ClassParameterConfigurator.java @@ -59,6 +59,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * Additionally, the classes can in turn have additional parameters. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses ClassParameter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/ConfiguratorPanel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/ConfiguratorPanel.java index 873417a0..b07aed06 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/ConfiguratorPanel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/ConfiguratorPanel.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * A panel that contains configurators for parameters. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.has de.lmu.ifi.dbs.elki.gui.configurator.ParameterConfigurator diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/EnumParameterConfigurator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/EnumParameterConfigurator.java index 416b47bb..95ae3a04 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/EnumParameterConfigurator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/EnumParameterConfigurator.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.EnumParameter; * TODO: offer radio buttons when just a few choices are available? * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses EnumParameter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/FileParameterConfigurator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/FileParameterConfigurator.java index f7218f35..9d3d53e5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/FileParameterConfigurator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/FileParameterConfigurator.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.FileParameter; * Provide a configuration panel to choose a file with a file selector button. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses FileParameter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/FlagParameterConfigurator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/FlagParameterConfigurator.java index 052c6ac6..5b3d42c7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/FlagParameterConfigurator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/FlagParameterConfigurator.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag; * Provide a configuration panel to modify a boolean via a checkbox. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses Flag */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/ParameterConfigurator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/ParameterConfigurator.java index 217f3632..88b93d25 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/ParameterConfigurator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/ParameterConfigurator.java @@ -29,12 +29,40 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParamet import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.TrackParameters; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; +/** + * Interface for different configuration assistants for the multistep GUI. + * + * @author Erich Schubert + * @since 0.4.0 + */ public interface ParameterConfigurator { + /** + * Add a parameter to the panel. + * + * @param owner Owning ("parent") object + * @param param Parameter + * @param track Parameter tracker + */ public void addParameter(Object owner, Parameter<?> param, TrackParameters track); + /** + * Add a change listener + * + * @param listener Change listener + */ public void addChangeListener(ChangeListener listener); + /** + * Remove a change listener + * + * @param listener Change listener + */ public void removeChangeListener(ChangeListener listener); + /** + * Append the parameters to a list. + * + * @param params Parameter list (output) + */ public void appendParameters(ListParameterization params); }
\ No newline at end of file diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/TextParameterConfigurator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/TextParameterConfigurator.java index 27c9d531..6c86f18a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/TextParameterConfigurator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/configurator/TextParameterConfigurator.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * Provide a configuration panel to input an arbitrary text parameter. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses Parameter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/icons/StockIcon.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/icons/StockIcon.java index c0c7b91c..de450f4a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/icons/StockIcon.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/icons/StockIcon.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.logging.LoggingUtil; * Stock icon library for use in the GUI. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/minigui/MiniGUI.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/minigui/MiniGUI.java index 6edaa95d..7cba1e97 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/minigui/MiniGUI.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/minigui/MiniGUI.java @@ -4,7 +4,7 @@ package de.lmu.ifi.dbs.elki.gui.minigui; This file is part of ELKI: Environment for Developing KDD-Applications Supported by Index-Structures - Copyright (C) 2015 + Copyright (C) 2016 Ludwig-Maximilians-Universität München Lehr- und Forschungseinheit für Datenbanksysteme ELKI Development Team @@ -36,7 +36,6 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; -import java.util.logging.Level; import javax.swing.AbstractAction; import javax.swing.AbstractListModel; @@ -46,8 +45,10 @@ import javax.swing.ImageIcon; import javax.swing.JButton; import javax.swing.JComboBox; import javax.swing.JFrame; +import javax.swing.JOptionPane; import javax.swing.JPanel; import javax.swing.JScrollPane; +import javax.swing.JTextField; import javax.swing.KeyStroke; import javax.swing.SwingWorker; import javax.swing.event.TableModelEvent; @@ -81,6 +82,7 @@ import de.lmu.ifi.dbs.elki.workflow.OutputStep; * Minimal GUI built around a table-based parameter editor. * * @author Erich Schubert + * @since 0.3 * * @apiviz.composedOf SettingsComboboxModel * @apiviz.composedOf LoggingStep @@ -140,6 +142,11 @@ public class MiniGUI extends AbstractApplication { protected SavedSettingsFile store = new SavedSettingsFile(SAVED_SETTINGS_FILENAME); /** + * Combo box for choosing the application to run. + */ + protected JComboBox<String> appCombo; + + /** * Combo box for saved settings. */ protected JComboBox<String> savedCombo; @@ -160,12 +167,22 @@ public class MiniGUI extends AbstractApplication { private Class<? extends AbstractApplication> maincls = KDDCLIApplication.class; /** + * Command line output field. + */ + private JTextField commandLine; + + /** + * Prefix for application package. + */ + private String APP_PREFIX = AbstractApplication.class.getPackage().getName() + "."; + + /** * Constructor. */ public MiniGUI() { super(); // Create and set up the window. - frame = new JFrame("ELKI MiniGUI"); + frame = new JFrame("ELKI MiniGUI Command Line Builder"); frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); try { frame.setIconImage(new ImageIcon(KDDTask.class.getResource("elki-icon.png")).getImage()); @@ -178,138 +195,11 @@ public class MiniGUI extends AbstractApplication { panel.setOpaque(true); // content panes must be opaque panel.setLayout(new GridBagLayout()); - { - // Button panel - JPanel buttonPanel = new JPanel(); - buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.X_AXIS)); - - // Combo box for saved settings - savedSettingsModel = new SettingsComboboxModel(store); - savedCombo = new JComboBox<>(savedSettingsModel); - savedCombo.setEditable(true); - savedCombo.setSelectedItem("[Saved Settings]"); - buttonPanel.add(savedCombo); - - // button to load settings - JButton loadButton = new JButton("Load"); - loadButton.setMnemonic(KeyEvent.VK_L); - loadButton.addActionListener(new ActionListener() { - @Override - public void actionPerformed(ActionEvent e) { - String key = savedSettingsModel.getSelectedItem(); - ArrayList<String> settings = store.get(key); - if(settings != null) { - outputArea.clear(); - outputArea.publish("Parameters: " + FormatUtil.format(settings, " ") + NEWLINE, Level.INFO); - doSetParameters(settings); - } - } - }); - buttonPanel.add(loadButton); - // button to save settings - JButton saveButton = new JButton("Save"); - saveButton.setMnemonic(KeyEvent.VK_S); - saveButton.addActionListener(new ActionListener() { - @Override - public void actionPerformed(ActionEvent e) { - String key = savedSettingsModel.getSelectedItem(); - // Stop editing the table. - parameterTable.editCellAt(-1, -1); - store.put(key, parameters.serializeParameters()); - try { - store.save(); - } - catch(IOException e1) { - LOG.exception(e1); - } - savedSettingsModel.update(); - } - }); - buttonPanel.add(saveButton); - // button to remove saved settings - JButton removeButton = new JButton("Remove"); - removeButton.setMnemonic(KeyEvent.VK_E); - removeButton.addActionListener(new ActionListener() { - @Override - public void actionPerformed(ActionEvent e) { - String key = savedSettingsModel.getSelectedItem(); - store.remove(key); - try { - store.save(); - } - catch(IOException e1) { - LOG.exception(e1); - } - savedCombo.setSelectedItem("[Saved Settings]"); - savedSettingsModel.update(); - } - }); - buttonPanel.add(removeButton); - - // button to launch the task - runButton = new JButton("Run Task"); - runButton.setMnemonic(KeyEvent.VK_R); - runButton.addActionListener(new ActionListener() { - @Override - public void actionPerformed(ActionEvent e) { - startTask(); - } - }); - buttonPanel.add(runButton); - - GridBagConstraints constraints = new GridBagConstraints(); - constraints.fill = GridBagConstraints.HORIZONTAL; - constraints.gridx = 0; - constraints.gridy = 1; - constraints.weightx = 1.0; - constraints.weighty = 0.01; - panel.add(buttonPanel, constraints); - } - - { - // Setup parameter storage and table model - this.parameters = new DynamicParameters(); - ParametersModel parameterModel = new ParametersModel(parameters); - parameterModel.addTableModelListener(new TableModelListener() { - @Override - public void tableChanged(TableModelEvent e) { - // logger.debug("Change event."); - updateParameterTable(); - } - }); - - // Create parameter table - parameterTable = new ParameterTable(frame, parameterModel, parameters); - // Create the scroll pane and add the table to it. - JScrollPane scrollPane = new JScrollPane(parameterTable); - - // Add the scroll pane to this panel. - GridBagConstraints constraints = new GridBagConstraints(); - constraints.fill = GridBagConstraints.BOTH; - constraints.gridx = 0; - constraints.gridy = 0; - constraints.weightx = 1; - constraints.weighty = 1; - panel.add(scrollPane, constraints); - } - - { - // setup text output area - outputArea = new LogPanel(); - - // Create the scroll pane and add the table to it. - JScrollPane outputPane = new JScrollPane(outputArea); - outputPane.setPreferredSize(new Dimension(800, 400)); - - // Add the output pane to the bottom - GridBagConstraints constraints = new GridBagConstraints(); - constraints.fill = GridBagConstraints.BOTH; - constraints.gridx = 0; - constraints.gridy = 2; - constraints.weightx = 1; - constraints.weighty = 1; - panel.add(outputPane, constraints); - } + setupAppChooser(); + setupParameterTable(); + setupLoadSaveButtons(); + setupCommandLine(); + setupLoggingArea(); // load saved settings (we wanted to have the logger first!) try { @@ -349,14 +239,222 @@ public class MiniGUI extends AbstractApplication { } /** + * Setup the application chooser. + */ + private void setupAppChooser() { + // Configurator to choose the main application + appCombo = new JComboBox<>(); + for(Class<?> clz : ELKIServiceRegistry.findAllImplementations(AbstractApplication.class)) { + String nam = clz.getCanonicalName(); + if(nam == null || clz.getCanonicalName().contains("GUI")) { + continue; + } + if(nam.startsWith(APP_PREFIX)) { + nam = nam.substring(APP_PREFIX.length()); + } + appCombo.addItem(nam); + } + appCombo.setEditable(true); + String sel = maincls.getCanonicalName(); + if(sel.startsWith(APP_PREFIX)) { + sel = sel.substring(APP_PREFIX.length()); + } + appCombo.setSelectedItem(sel); + appCombo.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + if("comboBoxChanged".equals(e.getActionCommand())) { + Class<? extends AbstractApplication> clz = ELKIServiceRegistry.findImplementation(AbstractApplication.class, (String) appCombo.getSelectedItem()); + if(clz != null) { + maincls = clz; + updateParameterTable(); + } + else { + LOG.warning("Main class name not found."); + } + } + } + }); + + GridBagConstraints constraints = new GridBagConstraints(); + constraints.fill = GridBagConstraints.BOTH; + constraints.gridx = 0; + constraints.gridy = 0; + constraints.weightx = 1; + constraints.weighty = .01; + panel.add(appCombo, constraints); + } + + /** + * Setup the parameter table + */ + private void setupParameterTable() { + // Setup parameter storage and table model + this.parameters = new DynamicParameters(); + ParametersModel parameterModel = new ParametersModel(parameters); + parameterModel.addTableModelListener(new TableModelListener() { + @Override + public void tableChanged(TableModelEvent e) { + // logger.debug("Change event."); + updateParameterTable(); + } + }); + + // Create parameter table + parameterTable = new ParameterTable(frame, parameterModel, parameters); + // Create the scroll pane and add the table to it. + JScrollPane scrollPane = new JScrollPane(parameterTable); + + // Add the scroll pane to this panel. + GridBagConstraints constraints = new GridBagConstraints(); + constraints.fill = GridBagConstraints.BOTH; + constraints.gridx = 0; + constraints.gridy = 1; + constraints.weightx = 1; + constraints.weighty = 1; + panel.add(scrollPane, constraints); + } + + /** + * Create the load and save buttons. + */ + private void setupLoadSaveButtons() { + // Button panel + JPanel buttonPanel = new JPanel(); + buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.X_AXIS)); + + // Combo box for saved settings + savedSettingsModel = new SettingsComboboxModel(store); + savedCombo = new JComboBox<>(savedSettingsModel); + savedCombo.setEditable(true); + savedCombo.setSelectedItem("[Saved Settings]"); + buttonPanel.add(savedCombo); + + // button to load settings + JButton loadButton = new JButton("Load"); + loadButton.setMnemonic(KeyEvent.VK_L); + loadButton.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + String key = savedSettingsModel.getSelectedItem(); + ArrayList<String> settings = store.get(key); + if(settings != null) { + doSetParameters(settings); + } + } + }); + buttonPanel.add(loadButton); + // button to save settings + JButton saveButton = new JButton("Save"); + saveButton.setMnemonic(KeyEvent.VK_S); + saveButton.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + String key = savedSettingsModel.getSelectedItem(); + // Stop editing the table. + parameterTable.editCellAt(-1, -1); + ArrayList<String> list = new ArrayList<>(parameters.size() * 2 + 1); + list.add(maincls.getCanonicalName()); + parameters.serializeParameters(list); + store.put(key, list); + try { + store.save(); + } + catch(IOException e1) { + LOG.exception(e1); + } + savedSettingsModel.update(); + } + }); + buttonPanel.add(saveButton); + // button to remove saved settings + JButton removeButton = new JButton("Remove"); + removeButton.setMnemonic(KeyEvent.VK_E); + removeButton.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + String key = savedSettingsModel.getSelectedItem(); + store.remove(key); + try { + store.save(); + } + catch(IOException e1) { + LOG.exception(e1); + } + savedCombo.setSelectedItem("[Saved Settings]"); + savedSettingsModel.update(); + } + }); + buttonPanel.add(removeButton); + + // button to launch the task + runButton = new JButton("Run Task"); + runButton.setMnemonic(KeyEvent.VK_R); + runButton.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + startTask(); + } + }); + buttonPanel.add(runButton); + + GridBagConstraints constraints = new GridBagConstraints(); + constraints.fill = GridBagConstraints.HORIZONTAL; + constraints.gridx = 0; + constraints.gridy = 2; + constraints.weightx = 1.0; + constraints.weighty = 0.01; + panel.add(buttonPanel, constraints); + } + + /** + * Setup command line field + */ + private void setupCommandLine() { + // setup text output area + commandLine = new JTextField(); + commandLine.setEditable(false); // FIXME: Make editable! + + // Add the output pane to the bottom + GridBagConstraints constraints = new GridBagConstraints(); + constraints.fill = GridBagConstraints.BOTH; + constraints.gridx = 0; + constraints.gridy = 3; + constraints.weightx = 1; + constraints.weighty = .01; + panel.add(commandLine, constraints); + } + + /** + * Setup logging area + */ + private void setupLoggingArea() { + // setup text output area + outputArea = new LogPanel(); + + // Create the scroll pane and add the table to it. + JScrollPane outputPane = new JScrollPane(outputArea); + outputPane.setPreferredSize(new Dimension(800, 400)); + + // Add the output pane to the bottom + GridBagConstraints constraints = new GridBagConstraints(); + constraints.fill = GridBagConstraints.BOTH; + constraints.gridx = 0; + constraints.gridy = 4; + constraints.weightx = 1; + constraints.weighty = 1; + panel.add(outputPane, constraints); + } + + /** * Serialize the parameter table and run setParameters(). */ protected void updateParameterTable() { parameterTable.setEnabled(false); - ArrayList<String> params = parameters.serializeParameters(); - outputArea.clear(); - outputArea.publish("Parameters: " + FormatUtil.format(params, " ") + NEWLINE, Level.INFO); - doSetParameters(params); + ArrayList<String> list = new ArrayList<String>(parameters.size() * 2 + 1); + list.add(maincls.getCanonicalName()); + parameters.serializeParameters(list); + doSetParameters(list); parameterTable.setEnabled(true); } @@ -366,6 +464,16 @@ public class MiniGUI extends AbstractApplication { * @param params Parameters */ protected void doSetParameters(List<String> params) { + if(params.size() > 0) { + String first = params.get(0); + if(!first.startsWith("-")) { + Class<? extends AbstractApplication> c = ELKIServiceRegistry.findImplementation(AbstractApplication.class, first); + if(c != null) { + maincls = c; + params.remove(0); + } + } + } SerializedParameterization config = new SerializedParameterization(params); TrackParameters track = new TrackParameters(config); track.tryInstantiate(LoggingStep.class); @@ -380,6 +488,13 @@ public class MiniGUI extends AbstractApplication { List<String> remainingParameters = config.getRemainingParameters(); + outputArea.clear(); + String mainnam = maincls.getCanonicalName(); + if(mainnam.startsWith(APP_PREFIX)) { + mainnam = mainnam.substring(APP_PREFIX.length()); + } + commandLine.setText(format(mainnam, params)); + // update table: parameterTable.removeEditor(); parameterTable.setEnabled(false); @@ -403,6 +518,97 @@ public class MiniGUI extends AbstractApplication { } /** + * Format objects to a command line. + * + * @param params Parameters to format (Strings, or list of strings) + * @return Formatted string + */ + private String format(Object... params) { + StringBuilder buf = new StringBuilder(); + for(Object p : params) { + if(p instanceof String) { + formatTo(buf, (String) p); + } + else if(p instanceof List) { + formatTo(buf, (List<?>) p); + } + else { + LOG.warning("Incorrect object type: " + p.getClass()); + } + } + return buf.toString(); + } + + /** + * Format a list of strings to a buffer. + * + * @param buf Output buffer + * @param params List of strings + */ + private void formatTo(StringBuilder buf, List<?> params) { + for(Object p : params) { + if(p instanceof String) { + formatTo(buf, (String) p); + } + else { + LOG.warning("Incorrect object type: " + p.getClass()); + } + } + } + + /** + * Format a single string for the command line. + * + * @param buf Output buffer + * @param s String + */ + private void formatTo(StringBuilder buf, String s) { + if(s == null || s.length() == 0) { + return; + } + if(buf.length() > 0) { + buf.append(' '); + } + // Test for escaping necessary + int escape = 0; + for(int i = 0, l = s.length(); i < l; i++) { + char c = s.charAt(i); + if(c == '\\') { + escape |= 8; + } + else if(c <= ' ' || c >= 128 || c == '<' || c == '>' || c == '|' || c == '$') { + escape |= 1; + } + else if(c == '"') { + escape |= 2; + } + else if(c == '\'') { + escape |= 4; + } + } + if(escape == 0) { + buf.append(s); // No escaping. + } + else if((escape & 10) == 0) { + buf.append('"').append(s).append('"'); + } + else if((escape & 12) == 0) { + buf.append('\'').append(s).append('\''); + } + else { // Full escaping. + buf.append('"'); + for(int i = 0, l = s.length(); i < l; i++) { + char c = s.charAt(i); + if(c == '"' || c == '\\' || c == '$') { + buf.append('\\'); + } + buf.append(c); + } + buf.append('"'); + } + } + + /** * Auto-load the last task from the history file. */ protected void loadLatest() { @@ -420,14 +626,13 @@ public class MiniGUI extends AbstractApplication { protected void startTask() { parameterTable.editCellAt(-1, -1); parameterTable.setEnabled(false); - final ArrayList<String> params = parameters.serializeParameters(); + final ArrayList<String> params = new ArrayList<>(parameters.size() * 2); + parameters.serializeParameters(params); parameterTable.setEnabled(true); runButton.setEnabled(false); outputArea.clear(); - outputArea.publish("Running: " + FormatUtil.format(params, " ") + NEWLINE, Level.INFO); - SwingWorker<Void, Void> r = new SwingWorker<Void, Void>() { @Override public Void doInBackground() { @@ -493,6 +698,34 @@ public class MiniGUI extends AbstractApplication { * @param args command line parameters */ public static void main(final String[] args) { + // Detect the common problem of an incomplete class path: + try { + Class<?> clz = ClassLoader.getSystemClassLoader().loadClass("de.lmu.ifi.dbs.elki.database.ids.DBIDUtil"); + clz.getMethod("newHashSet").invoke(null); + } + catch(ReflectiveOperationException e) { + StringBuilder msg = new StringBuilder(); + msg.append("Your Java class path is incomplete.\n"); + if(e.getCause() != null) { + msg.append(e.getCause().toString()).append("\n"); + } + else { + msg.append(e.toString()).append("\n"); + } + msg.append("Make sure you have all the required jars on the classpath.\n"); + msg.append("On the home page, you can find a 'elki-bundle' which should include everything."); + JOptionPane.showMessageDialog(null, msg, "ClassPath incomplete", JOptionPane.ERROR_MESSAGE); + return; + } + // Detect the broken Ubuntu jAyatana hack; + String toolopt = System.getenv("JAVA_TOOL_OPTION"); + if(toolopt != null && toolopt.indexOf("jayatana") >= 0) { + StringBuilder msg = new StringBuilder(); + msg.append("The Ubuntu JAyatana 'global menu support' hack is known to cause problems with many Java applications.\n"); + msg.append("Please unset JAVA_TOOL_OPTION."); + JOptionPane.showMessageDialog(null, msg, "Incompatible with JAyatana", JOptionPane.ERROR_MESSAGE); + return; + } GUIUtil.logUncaughtExceptions(LOG); GUIUtil.setLookAndFeel(); OutputStep.setDefaultHandlerVisualizer(); @@ -549,7 +782,7 @@ public class MiniGUI extends AbstractApplication { * * @apiviz.composedOf de.lmu.ifi.dbs.elki.gui.util.SavedSettingsFile */ - class SettingsComboboxModel extends AbstractListModel<String>implements ComboBoxModel<String> { + class SettingsComboboxModel extends AbstractListModel<String> implements ComboBoxModel<String> { /** * Serial version. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/MultiStepGUI.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/MultiStepGUI.java index dacbe361..36aa79fe 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/MultiStepGUI.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/MultiStepGUI.java @@ -61,6 +61,7 @@ import de.lmu.ifi.dbs.elki.workflow.OutputStep; * Experimenter-style multi step GUI. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.composedOf AlgorithmTabPanel diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/AlgorithmTabPanel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/AlgorithmTabPanel.java index c0dda863..fb9bd116 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/AlgorithmTabPanel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/AlgorithmTabPanel.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.workflow.AlgorithmStep; * Panel to handle data processing * * @author Erich Schubert + * @since 0.4.0 */ public class AlgorithmTabPanel extends ParameterTabPanel { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/EvaluationTabPanel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/EvaluationTabPanel.java index 65d53d20..8a8d10b5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/EvaluationTabPanel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/EvaluationTabPanel.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.workflow.EvaluationStep; * Panel to handle result evaluation * * @author Erich Schubert + * @since 0.4.0 */ public class EvaluationTabPanel extends ParameterTabPanel { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/InputTabPanel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/InputTabPanel.java index 7a3ea1f5..cd83a860 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/InputTabPanel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/InputTabPanel.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.workflow.InputStep; * Panel to handle data input. * * @author Erich Schubert + * @since 0.4.0 */ public class InputTabPanel extends ParameterTabPanel { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/LoggingTabPanel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/LoggingTabPanel.java index 2dcc38d4..902995ce 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/LoggingTabPanel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/LoggingTabPanel.java @@ -24,9 +24,8 @@ package de.lmu.ifi.dbs.elki.gui.multistep.panels; */ import de.lmu.ifi.dbs.elki.application.AbstractApplication; -import de.lmu.ifi.dbs.elki.logging.LoggingConfiguration; -import de.lmu.ifi.dbs.elki.logging.LoggingUtil; import de.lmu.ifi.dbs.elki.logging.Logging.Level; +import de.lmu.ifi.dbs.elki.logging.LoggingConfiguration; import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag; @@ -36,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.StringParameter; * Panel to handle logging * * @author Erich Schubert + * @since 0.4.0 */ public class LoggingTabPanel extends ParameterTabPanel { /** @@ -62,7 +62,7 @@ public class LoggingTabPanel extends ParameterTabPanel { // FIXME: add second level of verbosity! if (config.grab(debugParam)) { try { - LoggingUtil.parseDebugParameter(debugParam); + AbstractApplication.Parameterizer.parseDebugParameter(debugParam); } catch (WrongParameterValueException e) { de.lmu.ifi.dbs.elki.logging.LoggingUtil.exception(e); } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/OutputTabPanel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/OutputTabPanel.java index cedc5765..29fdf7ff 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/OutputTabPanel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/OutputTabPanel.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.workflow.OutputStep; * Panel to handle result output / visualization * * @author Erich Schubert + * @since 0.4.0 */ public class OutputTabPanel extends ParameterTabPanel { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/ParameterTabPanel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/ParameterTabPanel.java index caf9c066..f6985f4f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/ParameterTabPanel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/ParameterTabPanel.java @@ -51,6 +51,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.TrackParame * Abstract panel, showing particular options. * * @author Erich Schubert + * @since 0.4.0 */ public abstract class ParameterTabPanel extends JPanel implements ChangeListener { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/SavedSettingsTabPanel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/SavedSettingsTabPanel.java index 0ea2a34f..ec7b66e6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/SavedSettingsTabPanel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/multistep/panels/SavedSettingsTabPanel.java @@ -47,6 +47,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.SerializedP * Tab panel to manage saved settings. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf SavedSettingsTabPanel.SettingsComboboxModel */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/ClassTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/ClassTree.java index 8c524cdd..3c2a6373 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/ClassTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/ClassTree.java @@ -31,15 +31,16 @@ import javax.swing.tree.TreeNode; /** * Build a tree of available classes for use in Swing UIs. - * + * * @author Erich Schubert - * + * @since 0.7.0 + * * @apiviz.has TreeNode */ public class ClassTree { /** * Build the class tree for a given set of choices. - * + * * @param choices Class choices * @param rootpkg Root package name (to strip / hide) * @return Root node. @@ -59,7 +60,8 @@ public class ClassTree { for(Class<?> impl : choices) { String name = impl.getName(); name = (prefix != null && name.startsWith(prefix)) ? name.substring(prefix.length()) : name; - MutableTreeNode c = new ClassNode(impl.getName().substring(impl.getPackage().getName().length() + 1), name); + int plen = (impl.getPackage() != null) ? impl.getPackage().getName().length() + 1 : 0; + MutableTreeNode c = new ClassNode(impl.getName().substring(plen), name); MutableTreeNode p = null; int l = name.lastIndexOf('.'); @@ -96,7 +98,7 @@ public class ClassTree { /** * Simplify the tree. - * + * * @param cur Current node * @param prefix Prefix to add * @return Replacement node @@ -133,9 +135,9 @@ public class ClassTree { /** * Tree node representing a single class. - * + * * @author Erich Schubert - * + * * @apiviz.exclude */ public static class PackageNode extends DefaultMutableTreeNode { @@ -151,7 +153,7 @@ public class ClassTree { /** * Current class name. - * + * * @param display Displayed name * @param pkgname Actual class name */ @@ -162,7 +164,7 @@ public class ClassTree { /** * Return the package name. - * + * * @return Package name */ public String getPackageName() { @@ -172,9 +174,9 @@ public class ClassTree { /** * Tree node representing a single class. - * + * * @author Erich Schubert - * + * * @apiviz.exclude */ public static class ClassNode extends DefaultMutableTreeNode { @@ -190,7 +192,7 @@ public class ClassTree { /** * Current class name. - * + * * @param display Displayed name * @param clsname Actual class name */ @@ -201,7 +203,7 @@ public class ClassTree { /** * Return the class name. - * + * * @return Class name */ public String getClassName() { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/DynamicParameters.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/DynamicParameters.java index 2aae45d4..10cc79a3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/DynamicParameters.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/DynamicParameters.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.StringParameter; * correct. * * @author Erich Schubert + * @since 0.3 * * @apiviz.owns de.lmu.ifi.dbs.elki.gui.util.DynamicParameters.RemainingOptions */ @@ -206,10 +207,9 @@ public class DynamicParameters { /** * Serialize parameters into an array list to pass to setParameters() * - * @return Array list of String parameters. + * @param p Output list (will not be emptied) */ - public synchronized ArrayList<String> serializeParameters() { - ArrayList<String> p = new ArrayList<>(2 * parameters.size()); + public synchronized void serializeParameters(ArrayList<String> p) { for(Node t : parameters) { if(t.param != null) { if(t.param instanceof RemainingOptions) { @@ -232,7 +232,6 @@ public class DynamicParameters { } } } - return p; } /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/LogPane.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/LogPane.java index 17c52cea..c42a2ed7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/LogPane.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/LogPane.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.logging.progress.ProgressLogRecord; * {@link #becomeDefaultLogger()} to register as default logger in ELKI. * * @author Erich Schubert + * @since 0.3 * * @apiviz.uses LoggingConfiguration * @apiviz.uses de.lmu.ifi.dbs.elki.logging.ELKILogRecord diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/LogPanel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/LogPanel.java index dbe87b58..9507c8eb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/LogPanel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/LogPanel.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.logging.progress.StepProgress; * Panel that contains a text logging pane ({@link LogPane}) and progress bars. * * @author Erich Schubert + * @since 0.3 * * @apiviz.owns LogPane * @apiviz.uses LoggingConfiguration diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/ParameterTable.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/ParameterTable.java index a08341db..a5782ca9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/ParameterTable.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/ParameterTable.java @@ -73,6 +73,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * Class showing a table of ELKI parameters. * * @author Erich Schubert + * @since 0.3 * * @apiviz.composedOf ParametersModel * @apiviz.owns de.lmu.ifi.dbs.elki.gui.util.ParameterTable.ColorfulRenderer diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/ParametersModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/ParametersModel.java index d864cc9b..66593c20 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/ParametersModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/ParametersModel.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * A Swing TableModel that uses a {@link DynamicParameters} object as storage. * * @author Erich Schubert + * @since 0.3 */ public class ParametersModel extends AbstractTableModel { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/SavedSettingsFile.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/SavedSettingsFile.java index f8f4c990..6f31a2c6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/SavedSettingsFile.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/SavedSettingsFile.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; * Class to manage saved settings in a text file. * * @author Erich Schubert + * @since 0.3 */ public class SavedSettingsFile implements Iterable<Pair<String, ArrayList<String>>> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/TreePopup.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/TreePopup.java index 19413c53..6bfb6a2a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/TreePopup.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/gui/util/TreePopup.java @@ -62,6 +62,7 @@ import javax.swing.tree.TreeModel; * Popup menu that contains a JTree. * * @author Erich Schubert + * @since 0.7.0 */ public class TreePopup extends JPopupMenu { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/AbstractIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/AbstractIndex.java index 63be2b06..8db3abe9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/AbstractIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/AbstractIndex.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * Abstract base class for indexes with some implementation defaults. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.excludeSubtypes * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/AbstractRefiningIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/AbstractRefiningIndex.java index c5a032c3..e0264cf7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/AbstractRefiningIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/AbstractRefiningIndex.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.logging.statistics.Counter; * The number of refinements will be counted as individual page accesses. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.excludeSubtypes * @apiviz.has AbstractRangeQuery diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/DistanceIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/DistanceIndex.java index f6fc929f..2fa6feff 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/DistanceIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/DistanceIndex.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction; * caches) * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.excludeSubtypes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/DynamicIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/DynamicIndex.java index 8179b5df..306b0a1f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/DynamicIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/DynamicIndex.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDs; * Index that supports dynamic insertions and removals. * * @author Erich Schubert + * @since 0.2 * * @apiviz.excludeSubtypes */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/Index.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/Index.java index b312eb37..d6f9ee16 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/Index.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/Index.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.result.Result; * See also: {@link IndexFactory}, {@link DynamicIndex} * * @author Elke Achtert + * @since 0.2 * * @apiviz.excludeSubtypes */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/IndexFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/IndexFactory.java index 154974f9..1a1d3fb2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/IndexFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/IndexFactory.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * Factory interface for indexes. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.stereotype factory,interface * @apiviz.has Index oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/KNNIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/KNNIndex.java index aa99e8e4..e3a29bf5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/KNNIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/KNNIndex.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.query.knn.KNNQuery; * Index with support for kNN queries. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.excludeSubtypes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/PagedIndexFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/PagedIndexFactory.java index 75c11499..e421e252 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/PagedIndexFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/PagedIndexFactory.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Abstract base class for tree-based indexes. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.stereotype factory,interface * @apiviz.excludeSubtypes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/RKNNIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/RKNNIndex.java index 71909004..770d1170 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/RKNNIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/RKNNIndex.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.query.rknn.RKNNQuery; * Index with support for kNN queries. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.excludeSubtypes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/RangeIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/RangeIndex.java index 464c3589..56845f37 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/RangeIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/RangeIndex.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.query.range.RangeQuery; * Index with support for kNN queries. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.excludeSubtypes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/distancematrix/PrecomputedDistanceMatrix.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/distancematrix/PrecomputedDistanceMatrix.java index 44ed6c84..4dbb79ea 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/distancematrix/PrecomputedDistanceMatrix.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/distancematrix/PrecomputedDistanceMatrix.java @@ -23,17 +23,31 @@ package de.lmu.ifi.dbs.elki.index.distancematrix; along with this program. If not, see <http://www.gnu.org/licenses/>. */ +import java.util.ArrayList; +import java.util.List; + import de.lmu.ifi.dbs.elki.data.type.TypeInformation; +import de.lmu.ifi.dbs.elki.database.ids.ArrayDBIDs; import de.lmu.ifi.dbs.elki.database.ids.DBIDArrayIter; +import de.lmu.ifi.dbs.elki.database.ids.DBIDIter; import de.lmu.ifi.dbs.elki.database.ids.DBIDRange; 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.DBIDs; +import de.lmu.ifi.dbs.elki.database.ids.DoubleDBIDList; +import de.lmu.ifi.dbs.elki.database.ids.KNNHeap; +import de.lmu.ifi.dbs.elki.database.ids.KNNList; +import de.lmu.ifi.dbs.elki.database.ids.ModifiableDoubleDBIDList; import de.lmu.ifi.dbs.elki.database.query.distance.DistanceQuery; +import de.lmu.ifi.dbs.elki.database.query.knn.KNNQuery; +import de.lmu.ifi.dbs.elki.database.query.range.RangeQuery; import de.lmu.ifi.dbs.elki.database.relation.Relation; import de.lmu.ifi.dbs.elki.distance.distancefunction.DistanceFunction; import de.lmu.ifi.dbs.elki.index.AbstractIndex; import de.lmu.ifi.dbs.elki.index.DistanceIndex; import de.lmu.ifi.dbs.elki.index.IndexFactory; +import de.lmu.ifi.dbs.elki.index.KNNIndex; +import de.lmu.ifi.dbs.elki.index.RangeIndex; import de.lmu.ifi.dbs.elki.logging.Logging; import de.lmu.ifi.dbs.elki.logging.progress.FiniteProgress; import de.lmu.ifi.dbs.elki.logging.statistics.LongStatistic; @@ -45,21 +59,24 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; /** * Distance matrix, for precomputing similarity for a small data set. - * + * * This class uses a linear memory layout (not a ragged array), and assumes * symmetry as well as strictness. This way, it only stores the upper triangle * matrix with double precision. It has to store (n-1) * (n-2) distance values * in memory, requiring 8 * (n-1) * (n-2) bytes. Since Java has a size limit of * arrays of 31 bits (signed integer), we can store at most 2^16 objects * (precisely, 65536 objects) in a single array, which needs about 16 GB of RAM. - * + * * @author Erich Schubert - * + * @since 0.7.0 + * * @apiviz.has PrecomputedDistanceQuery - * + * @apiviz.has PrecomputedKNNQuery + * @apiviz.has PrecomputedRangeQuery + * * @param <O> Object type */ -public class PrecomputedDistanceMatrix<O> extends AbstractIndex<O>implements DistanceIndex<O> { +public class PrecomputedDistanceMatrix<O> extends AbstractIndex<O> implements DistanceIndex<O>, RangeIndex<O>, KNNIndex<O> { /** * Class logger. */ @@ -92,7 +109,7 @@ public class PrecomputedDistanceMatrix<O> extends AbstractIndex<O>implements Dis /** * Constructor. - * + * * @param relation Data relation * @param distanceFunction Distance function */ @@ -119,7 +136,7 @@ public class PrecomputedDistanceMatrix<O> extends AbstractIndex<O>implements Dis distanceQuery = distanceFunction.instantiate(relation); - int msize = triangleSize(size); + final int msize = triangleSize(size); matrix = new double[msize]; DBIDArrayIter ix = ids.iter(), iy = ids.iter(); @@ -140,7 +157,7 @@ public class PrecomputedDistanceMatrix<O> extends AbstractIndex<O>implements Dis /** * Compute the size of a complete x by x triangle (minus diagonal) - * + * * @param x Offset * @return Size of complete triangle */ @@ -150,7 +167,7 @@ public class PrecomputedDistanceMatrix<O> extends AbstractIndex<O>implements Dis /** * Array offset computation. - * + * * @param x X parameter * @param y Y parameter * @return Array offset @@ -184,9 +201,25 @@ public class PrecomputedDistanceMatrix<O> extends AbstractIndex<O>implements Dis return null; } + @Override + public KNNQuery<O> getKNNQuery(DistanceQuery<O> distanceQuery, Object... hints) { + if(this.distanceQuery.getDistanceFunction().equals(distanceQuery.getDistanceFunction())) { + return new PrecomputedKNNQuery(); + } + return null; + } + + @Override + public RangeQuery<O> getRangeQuery(DistanceQuery<O> distanceQuery, Object... hints) { + if(this.distanceQuery.getDistanceFunction().equals(distanceQuery.getDistanceFunction())) { + return new PrecomputedRangeQuery(); + } + return null; + } + /** * Distance query using the precomputed matrix. - * + * * @author Erich Schubert */ private class PrecomputedDistanceQuery implements DistanceQuery<O> { @@ -223,12 +256,115 @@ public class PrecomputedDistanceMatrix<O> extends AbstractIndex<O>implements Dis } /** + * Range query using the distance matrix. + * + * @author Erich Schubert + */ + private class PrecomputedRangeQuery implements RangeQuery<O> { + @Override + public DoubleDBIDList getRangeForDBID(DBIDRef id, double range) { + ModifiableDoubleDBIDList ret = DBIDUtil.newDistanceDBIDList(); + getRangeForDBID(id, range, ret); + ret.sort(); + return ret; + } + + @Override + public void getRangeForDBID(DBIDRef id, double range, ModifiableDoubleDBIDList result) { + result.add(0., id); + DBIDArrayIter it = ids.iter(); + + final int x = ids.getOffset(id); + // Case y < x: triangleSize(x) + y + int pos = triangleSize(x); + for(int y = 0; y < x; y++) { + final double dist = matrix[pos]; + if(dist <= range) { + result.add(dist, it.seek(y)); + } + pos++; + } + assert (pos == triangleSize(x + 1)); + // Case y > x: triangleSize(y) + x + pos = triangleSize(x + 1) + x; + for(int y = x + 1; y < size; y++) { + final double dist = matrix[pos]; + if(dist <= range) { + result.add(dist, it.seek(y)); + } + pos += y; + } + } + + @Override + public DoubleDBIDList getRangeForObject(O obj, double range) { + throw new AbortException("Preprocessor KNN query only supports ID queries."); + } + + @Override + public void getRangeForObject(O obj, double range, ModifiableDoubleDBIDList result) { + throw new AbortException("Preprocessor KNN query only supports ID queries."); + } + } + + /** + * kNN query using the distance matrix. + * + * @author Erich Schubert + */ + private class PrecomputedKNNQuery implements KNNQuery<O> { + @Override + public KNNList getKNNForDBID(DBIDRef id, int k) { + KNNHeap heap = DBIDUtil.newHeap(k); + heap.insert(0., id); + DBIDArrayIter it = ids.iter(); + double max = Double.POSITIVE_INFINITY; + final int x = ids.getOffset(id); + // Case y < x: triangleSize(x) + y + int pos = triangleSize(x); + for(int y = 0; y < x; y++) { + final double dist = matrix[pos]; + if(dist <= max) { + max = heap.insert(dist, it.seek(y)); + } + pos++; + } + assert (pos == triangleSize(x + 1)); + // Case y > x: triangleSize(y) + x + pos = triangleSize(x + 1) + x; + for(int y = x + 1; y < size; y++) { + final double dist = matrix[pos]; + if(dist <= max) { + max = heap.insert(dist, it.seek(y)); + } + pos += y; + } + return heap.toKNNList(); + } + + @Override + public List<? extends KNNList> getKNNForBulkDBIDs(ArrayDBIDs ids, int k) { + // TODO: optimize + List<KNNList> ret = new ArrayList<>(ids.size()); + for(DBIDIter iter = ids.iter(); iter.valid(); iter.advance()) { + ret.add(getKNNForDBID(iter, k)); + } + return ret; + } + + @Override + public KNNList getKNNForObject(O obj, int k) { + throw new AbortException("Preprocessor KNN query only supports ID queries."); + } + } + + /** * Factory for the index. - * + * * @author Erich Schubert - * + * * @apiviz.has PrecomputedDistanceMatrix - * + * * @param <O> Object type */ public static class Factory<O> implements IndexFactory<O, PrecomputedDistanceMatrix<O>> { @@ -239,7 +375,7 @@ public class PrecomputedDistanceMatrix<O> extends AbstractIndex<O>implements Dis /** * Constructor. - * + * * @param distanceFunction Distance function */ public Factory(DistanceFunction<? super O> distanceFunction) { @@ -259,11 +395,11 @@ public class PrecomputedDistanceMatrix<O> extends AbstractIndex<O>implements Dis /** * Parameterizer. - * + * * @author Erich Schubert - * + * * @apiviz.exclude - * + * * @param <O> Object type */ public static class Parameterizer<O> extends AbstractParameterizer { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/idistance/InMemoryIDistanceIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/idistance/InMemoryIDistanceIndex.java index 2fca801c..6ced1fbd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/idistance/InMemoryIDistanceIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/idistance/InMemoryIDistanceIndex.java @@ -87,6 +87,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.DoubleIntPair; * </p> * * @author Erich Schubert + * @since 0.7.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/invertedlist/InMemoryInvertedIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/invertedlist/InMemoryInvertedIndex.java index 7a3087ba..101b7ed1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/invertedlist/InMemoryInvertedIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/invertedlist/InMemoryInvertedIndex.java @@ -60,6 +60,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Simple index using inverted lists. * * @author Erich Schubert + * @since 0.7.0 * * @param <V> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/InMemoryLSHIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/InMemoryLSHIndex.java index b55799af..a1940da7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/InMemoryLSHIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/InMemoryLSHIndex.java @@ -63,6 +63,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Locality Sensitive Hashing. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has LocalitySensitiveHashFunctionFamily * @apiviz.has Instance @@ -169,7 +170,7 @@ public class InMemoryLSHIndex<V> implements IndexFactory<V, InMemoryLSHIndex<V>. // TODO: We assume all hash functions have the same dimensionality. double[] buf = new double[hashfunctions.get(0).getNumberOfProjections()]; - FiniteProgress progress = LOG.isVerbose() ? new FiniteProgress("Building LSH index.", relation.size(), LOG) : null; + FiniteProgress progress = LOG.isVerbose() ? new FiniteProgress("Building LSH index", relation.size(), LOG) : null; int expect = Math.max(2, (int) Math.ceil(relation.size() / (double) numberOfBuckets)); for(DBIDIter iter = relation.getDBIDs().iter(); iter.valid(); iter.advance()) { V obj = relation.get(iter); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/AbstractProjectedHashFunctionFamily.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/AbstractProjectedHashFunctionFamily.java index 7d9b09e6..521b16c4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/AbstractProjectedHashFunctionFamily.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/AbstractProjectedHashFunctionFamily.java @@ -47,6 +47,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * Abstract base class for projection based hash functions. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.uses RandomProjectionFamily * @apiviz.has MultipleProjectionsLocalitySensitiveHashFunction diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/CosineHashFunctionFamily.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/CosineHashFunctionFamily.java index b46e30ae..78cf7eb4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/CosineHashFunctionFamily.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/CosineHashFunctionFamily.java @@ -65,6 +65,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * </p> * * @author Evgeniy Faerman + * @since 0.6.0 */ @Reference(authors = "M.S. Charikar", // title = "Similarity estimation techniques from rounding algorithms", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/EuclideanHashFunctionFamily.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/EuclideanHashFunctionFamily.java index e50766b0..620d2ef1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/EuclideanHashFunctionFamily.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/EuclideanHashFunctionFamily.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.uses GaussianRandomProjectionFamily */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/LocalitySensitiveHashFunctionFamily.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/LocalitySensitiveHashFunctionFamily.java index 4c232df4..94a9e181 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/LocalitySensitiveHashFunctionFamily.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/LocalitySensitiveHashFunctionFamily.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.index.lsh.hashfunctions.LocalitySensitiveHashFunction * LSH family of hash functions. * * @author Erich Schubert + * @since 0.6.0 * * @param <V> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/ManhattanHashFunctionFamily.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/ManhattanHashFunctionFamily.java index fbc122af..95577790 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/ManhattanHashFunctionFamily.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfamilies/ManhattanHashFunctionFamily.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.uses CauchyRandomProjectionFamily */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfunctions/CosineLocalitySensitiveHashFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfunctions/CosineLocalitySensitiveHashFunction.java index ae0af49e..9a68c7d6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfunctions/CosineLocalitySensitiveHashFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfunctions/CosineLocalitySensitiveHashFunction.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Evgeniy Faerman + * @since 0.3 */ @Reference(authors = "M.S. Charikar", // title = "Similarity estimation techniques from rounding algorithms", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfunctions/LocalitySensitiveHashFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfunctions/LocalitySensitiveHashFunction.java index 51dcd216..cb1c1584 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfunctions/LocalitySensitiveHashFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfunctions/LocalitySensitiveHashFunction.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.index.lsh.hashfunctions; * Hash functions as used by locality sensitive hashing. * * @author Erich Schubert + * @since 0.6.0 * * @param <V> Data type to hash. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfunctions/MultipleProjectionsLocalitySensitiveHashFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfunctions/MultipleProjectionsLocalitySensitiveHashFunction.java index a4976e59..ad266f19 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfunctions/MultipleProjectionsLocalitySensitiveHashFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/lsh/hashfunctions/MultipleProjectionsLocalitySensitiveHashFunction.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.6.0 */ @Reference(authors = "M. Datar and N. Immorlica and P. Indyk and V. S. Mirrokni", // title = "Locality-sensitive hashing scheme based on p-stable distributions", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/AbstractPreprocessorIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/AbstractPreprocessorIndex.java index 7377955b..3892c896 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/AbstractPreprocessorIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/AbstractPreprocessorIndex.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * object storage for preprocessing results. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf WritableDataStore * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/LocalProjectionIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/LocalProjectionIndex.java index af5fbcc9..66b30c9d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/LocalProjectionIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/LocalProjectionIndex.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.ProjectionResult; * Abstract index interface for local projections * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has ProjectionResult * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/fastoptics/RandomProjectedNeighborsAndDensities.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/fastoptics/RandomProjectedNeighborsAndDensities.java index e24852a9..f5615331 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/fastoptics/RandomProjectedNeighborsAndDensities.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/fastoptics/RandomProjectedNeighborsAndDensities.java @@ -85,6 +85,7 @@ import gnu.trove.list.array.TIntArrayList; * * @author Johannes Schneider * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "J. Schneider and M. Vlachos", // title = "Fast parameterless density-based clustering via random projections", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/AbstractMaterializeKNNPreprocessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/AbstractMaterializeKNNPreprocessor.java index 343f17b7..6d156c63 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/AbstractMaterializeKNNPreprocessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/AbstractMaterializeKNNPreprocessor.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Abstract base class for KNN Preprocessors. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/CachedDoubleDistanceKNNPreprocessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/CachedDoubleDistanceKNNPreprocessor.java index ae7ce384..7d9f6b19 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/CachedDoubleDistanceKNNPreprocessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/CachedDoubleDistanceKNNPreprocessor.java @@ -47,6 +47,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.FileParameter; * Preprocessor that loads an existing cached kNN result. * * @author Erich Schubert + * @since 0.6.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/KNNChangeEvent.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/KNNChangeEvent.java index 953a3baa..0963229a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/KNNChangeEvent.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/KNNChangeEvent.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDs; * subscribed {@link KNNListener} of the change. * * @author Elke Achtert + * @since 0.4.0 * * @apiviz.has DBIDs * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/KNNJoinMaterializeKNNPreprocessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/KNNJoinMaterializeKNNPreprocessor.java index 8a6af2fd..895d80c8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/KNNJoinMaterializeKNNPreprocessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/KNNJoinMaterializeKNNPreprocessor.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * Class to materialize the kNN using a spatial join on an R-tree. * * @author Erich Schubert + * @since 0.5.0 * * @param <V> vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/KNNListener.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/KNNListener.java index 40e772b1..166c4286 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/KNNListener.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/KNNListener.java @@ -30,6 +30,7 @@ import java.util.EventListener; * objects have been changed due to insertion or removals of objects. * * @author Elke Achtert + * @since 0.4.0 * * @apiviz.uses KNNChangeEvent oneway - - */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/MaterializeKNNAndRKNNPreprocessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/MaterializeKNNAndRKNNPreprocessor.java index c2577bf8..71098362 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/MaterializeKNNAndRKNNPreprocessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/MaterializeKNNAndRKNNPreprocessor.java @@ -67,6 +67,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * of the nearest neighbors! * * @author Elke Achtert + * @since 0.4.0 * * @param <O> the type of database objects the preprocessor can be applied to * @param the type of distance the used distance function will return diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/MaterializeKNNPreprocessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/MaterializeKNNPreprocessor.java index 5f21a165..24d4e677 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/MaterializeKNNPreprocessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/MaterializeKNNPreprocessor.java @@ -33,6 +33,7 @@ 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.DBIDs; +import de.lmu.ifi.dbs.elki.database.ids.DoubleDBIDListIter; import de.lmu.ifi.dbs.elki.database.ids.KNNHeap; import de.lmu.ifi.dbs.elki.database.ids.KNNList; import de.lmu.ifi.dbs.elki.database.ids.SetDBIDs; @@ -46,6 +47,7 @@ import de.lmu.ifi.dbs.elki.logging.progress.FiniteProgress; import de.lmu.ifi.dbs.elki.logging.progress.StepProgress; import de.lmu.ifi.dbs.elki.logging.statistics.Duration; import de.lmu.ifi.dbs.elki.logging.statistics.LongStatistic; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; import de.lmu.ifi.dbs.elki.utilities.documentation.Title; @@ -56,6 +58,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * Used for example by {@link de.lmu.ifi.dbs.elki.algorithm.outlier.lof.LOF}. * * @author Erich Schubert + * @since 0.2 * * @apiviz.has DistanceFunction * @apiviz.has KNNQuery @@ -65,6 +68,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; */ @Title("Materialize kNN Neighborhood preprocessor") @Description("Materializes the k nearest neighbors of objects of a database.") +@Alias("de.lmu.ifi.dbs.elki.preprocessing.MaterializeKNNPreprocessor") public class MaterializeKNNPreprocessor<O> extends AbstractMaterializeKNNPreprocessor<O> implements DynamicIndex { /** * Logger to use. @@ -105,14 +109,15 @@ public class MaterializeKNNPreprocessor<O> extends AbstractMaterializeKNNPreproc */ @Override protected void preprocess() { + final Logging log = getLogger(); // Could be subclass createStorage(); ArrayDBIDs ids = DBIDUtil.ensureArray(relation.getDBIDs()); - if(LOG.isStatistics()) { - LOG.statistics(new LongStatistic(this.getClass().getName() + ".k", k)); + if(log.isStatistics()) { + log.statistics(new LongStatistic(this.getClass().getName() + ".k", k)); } - Duration duration = LOG.isStatistics() ? LOG.newDuration(this.getClass().getName() + ".precomputation-time").begin() : null; + Duration duration = log.isStatistics() ? log.newDuration(this.getClass().getName() + ".precomputation-time").begin() : null; FiniteProgress progress = getLogger().isVerbose() ? new FiniteProgress("Materializing k nearest neighbors (k=" + k + ")", ids.size(), getLogger()) : null; // Try bulk List<? extends KNNList> kNNList = null; @@ -122,20 +127,30 @@ public class MaterializeKNNPreprocessor<O> extends AbstractMaterializeKNNPreproc int i = 0; for(DBIDIter id = ids.iter(); id.valid(); id.advance(), i++) { storage.put(id, kNNList.get(i)); - getLogger().incrementProcessed(progress); + log.incrementProcessed(progress); } } } else { + final boolean ismetric = getDistanceQuery().getDistanceFunction().isMetric(); for(DBIDIter iter = ids.iter(); iter.valid(); iter.advance()) { + if(ismetric && storage.get(iter) != null) { + log.incrementProcessed(progress); + continue; // Previously computed (duplicate point?) + } KNNList knn = knnQuery.getKNNForDBID(iter, k); storage.put(iter, knn); - getLogger().incrementProcessed(progress); + if(ismetric) { + for(DoubleDBIDListIter it = knn.iter(); it.valid() && it.doubleValue() == 0.; it.advance()) { + storage.put(it, knn); // Reuse + } + } + log.incrementProcessed(progress); } } - getLogger().ensureCompleted(progress); + log.ensureCompleted(progress); if(duration != null) { - LOG.statistics(duration.end()); + log.statistics(duration.end()); } } @@ -172,11 +187,12 @@ public class MaterializeKNNPreprocessor<O> extends AbstractMaterializeKNNPreproc * @param ids the ids of the newly inserted objects */ protected void objectsInserted(DBIDs ids) { - StepProgress stepprog = getLogger().isVerbose() ? new StepProgress(3) : null; + final Logging log = getLogger(); // Could be subclass + StepProgress stepprog = log.isVerbose() ? new StepProgress(3) : null; ArrayDBIDs aids = DBIDUtil.ensureArray(ids); // materialize the new kNNs - getLogger().beginStep(stepprog, 1, "New insertions ocurred, materialize their new kNNs."); + log.beginStep(stepprog, 1, "New insertions ocurred, materialize their new kNNs."); // Bulk-query kNNs List<? extends KNNList> kNNList = knnQuery.getKNNForBulkDBIDs(aids, k); // Store in storage @@ -186,14 +202,14 @@ public class MaterializeKNNPreprocessor<O> extends AbstractMaterializeKNNPreproc } // update the affected kNNs - getLogger().beginStep(stepprog, 2, "New insertions ocurred, update the affected kNNs."); + log.beginStep(stepprog, 2, "New insertions ocurred, update the affected kNNs."); ArrayDBIDs rkNN_ids = updateKNNsAfterInsertion(ids); // inform listener - getLogger().beginStep(stepprog, 3, "New insertions ocurred, inform listeners."); + log.beginStep(stepprog, 3, "New insertions ocurred, inform listeners."); fireKNNsInserted(ids, rkNN_ids); - getLogger().setCompleted(stepprog); + log.setCompleted(stepprog); } /** @@ -267,23 +283,24 @@ public class MaterializeKNNPreprocessor<O> extends AbstractMaterializeKNNPreproc * @param ids the ids of the removed objects */ protected void objectsRemoved(DBIDs ids) { - StepProgress stepprog = getLogger().isVerbose() ? new StepProgress(3) : null; + final Logging log = getLogger(); + StepProgress stepprog = log.isVerbose() ? new StepProgress(3) : null; // delete the materialized (old) kNNs - getLogger().beginStep(stepprog, 1, "New deletions ocurred, remove their materialized kNNs."); + log.beginStep(stepprog, 1, "New deletions ocurred, remove their materialized kNNs."); for(DBIDIter iter = ids.iter(); iter.valid(); iter.advance()) { storage.delete(iter); } // update the affected kNNs - getLogger().beginStep(stepprog, 2, "New deletions ocurred, update the affected kNNs."); + log.beginStep(stepprog, 2, "New deletions ocurred, update the affected kNNs."); ArrayDBIDs rkNN_ids = updateKNNsAfterDeletion(ids); // inform listener - getLogger().beginStep(stepprog, 3, "New deletions ocurred, inform listeners."); + log.beginStep(stepprog, 3, "New deletions ocurred, inform listeners."); fireKNNsRemoved(ids, rkNN_ids); - getLogger().ensureCompleted(stepprog); + log.ensureCompleted(stepprog); } /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/MetricalIndexApproximationMaterializeKNNPreprocessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/MetricalIndexApproximationMaterializeKNNPreprocessor.java index a78b06e0..7823d872 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/MetricalIndexApproximationMaterializeKNNPreprocessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/MetricalIndexApproximationMaterializeKNNPreprocessor.java @@ -59,6 +59,7 @@ import gnu.trove.map.hash.TObjectDoubleHashMap; * TODO correct handling of datastore events * * @author Erich Schubert + * @since 0.2 * * @apiviz.uses MetricalIndexTree * @@ -99,7 +100,7 @@ public class MetricalIndexApproximationMaterializeKNNPreprocessor<O extends Numb } List<E> leaves = index.getLeaves(); - FiniteProgress progress = getLogger().isVerbose() ? new FiniteProgress("Processing leaf nodes.", leaves.size(), getLogger()) : null; + FiniteProgress progress = getLogger().isVerbose() ? new FiniteProgress("Processing leaf nodes", leaves.size(), getLogger()) : null; for(E leaf : leaves) { N node = index.getNode(leaf); int size = node.getNumEntries(); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/NaiveProjectedKNNPreprocessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/NaiveProjectedKNNPreprocessor.java index 6b946474..f4911aef 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/NaiveProjectedKNNPreprocessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/NaiveProjectedKNNPreprocessor.java @@ -79,6 +79,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * </p> * * @author Erich Schubert + * @since 0.7.0 * @apiviz.has NaiveProjectedKNNQuery */ @Reference(authors = "E. Schubert, A. Zimek, H.-P. Kriegel", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/PartitionApproximationMaterializeKNNPreprocessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/PartitionApproximationMaterializeKNNPreprocessor.java index cdb314dc..b8a9f6fe 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/PartitionApproximationMaterializeKNNPreprocessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/PartitionApproximationMaterializeKNNPreprocessor.java @@ -55,6 +55,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * Used for example by {@link de.lmu.ifi.dbs.elki.algorithm.outlier.lof.LOF}. * * @author Erich Schubert + * @since 0.2 * * @param <O> the type of database objects the preprocessor can be applied to */ @@ -103,7 +104,7 @@ public class PartitionApproximationMaterializeKNNPreprocessor<O> extends Abstrac // Produce a random shuffling of the IDs: ArrayDBIDs[] parts = DBIDUtil.randomSplit(relation.getDBIDs(), partitions, rnd); - FiniteProgress progress = LOG.isVerbose() ? new FiniteProgress("Processing partitions.", partitions, LOG) : null; + FiniteProgress progress = LOG.isVerbose() ? new FiniteProgress("Processing partitions", partitions, LOG) : null; for(int part = 0; part < partitions; part++) { final ArrayDBIDs ids = parts[part]; final int size = ids.size(); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/RandomSampleKNNPreprocessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/RandomSampleKNNPreprocessor.java index 39eb23f3..33a0c070 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/RandomSampleKNNPreprocessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/RandomSampleKNNPreprocessor.java @@ -59,6 +59,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * </p> * * @author Erich Schubert + * @since 0.5.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/SpacefillingKNNPreprocessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/SpacefillingKNNPreprocessor.java index 8aa1368c..22b378ae 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/SpacefillingKNNPreprocessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/SpacefillingKNNPreprocessor.java @@ -88,6 +88,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * </p> * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has SpaceFillingKNNQuery */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/SpacefillingMaterializeKNNPreprocessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/SpacefillingMaterializeKNNPreprocessor.java index 4b3864eb..257bda32 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/SpacefillingMaterializeKNNPreprocessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/SpacefillingMaterializeKNNPreprocessor.java @@ -77,6 +77,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * </p> * * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "E. Schubert, A. Zimek, H.-P. Kriegel", // title = "Fast and Scalable Outlier Detection with Approximate Nearest Neighbor Ensembles", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/SpatialApproximationMaterializeKNNPreprocessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/SpatialApproximationMaterializeKNNPreprocessor.java index 3706035c..49cdf239 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/SpatialApproximationMaterializeKNNPreprocessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/knn/SpatialApproximationMaterializeKNNPreprocessor.java @@ -23,8 +23,6 @@ package de.lmu.ifi.dbs.elki.index.preprocessed.knn; along with this program. If not, see <http://www.gnu.org/licenses/>. */ -import gnu.trove.impl.Constants; -import gnu.trove.map.hash.TObjectDoubleHashMap; import java.util.Collection; import java.util.List; @@ -49,9 +47,12 @@ import de.lmu.ifi.dbs.elki.logging.Logging; import de.lmu.ifi.dbs.elki.logging.progress.FiniteProgress; import de.lmu.ifi.dbs.elki.math.MeanVariance; import de.lmu.ifi.dbs.elki.result.ResultUtil; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Description; import de.lmu.ifi.dbs.elki.utilities.documentation.Title; import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; +import gnu.trove.impl.Constants; +import gnu.trove.map.hash.TObjectDoubleHashMap; /** * A preprocessor for annotation of the k nearest neighbors (and their @@ -62,6 +63,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * TODO correct handling of datastore events * * @author Erich Schubert + * @since 0.2 * * @apiviz.uses SpatialIndexTree * @@ -70,6 +72,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; */ @Title("Spatial Approximation Materialize kNN Preprocessor") @Description("Caterializes the (approximate) k nearest neighbors of objects of a database using a spatial approximation.") +@Alias("de.lmu.ifi.dbs.elki.preprocessing.SpatialApproximationMaterializeKNNPreprocessor") public class SpatialApproximationMaterializeKNNPreprocessor<O extends NumberVector, N extends SpatialNode<N, E>, E extends SpatialEntry> extends AbstractMaterializeKNNPreprocessor<O> { /** * Logger to use @@ -105,7 +108,7 @@ public class SpatialApproximationMaterializeKNNPreprocessor<O extends NumberVect } List<E> leaves = index.getLeaves(); - FiniteProgress progress = getLogger().isVerbose() ? new FiniteProgress("Processing leaf nodes.", leaves.size(), getLogger()) : null; + FiniteProgress progress = getLogger().isVerbose() ? new FiniteProgress("Processing leaf nodes", leaves.size(), getLogger()) : null; for(E leaf : leaves) { N node = index.getNode(leaf); int size = node.getNumEntries(); @@ -217,4 +220,4 @@ public class SpatialApproximationMaterializeKNNPreprocessor<O extends NumberVect } } } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/localpca/AbstractFilteredPCAIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/localpca/AbstractFilteredPCAIndex.java index f1da979e..3f7f6d93 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/localpca/AbstractFilteredPCAIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/localpca/AbstractFilteredPCAIndex.java @@ -51,6 +51,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * * @author Elke Achtert * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has PCAFilteredRunner * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/localpca/FilteredLocalPCAIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/localpca/FilteredLocalPCAIndex.java index c6504f54..9adef2e8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/localpca/FilteredLocalPCAIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/localpca/FilteredLocalPCAIndex.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.pca.PCAFilteredResult; * Interface for an index providing local PCA results. * * @author Erich Schubert + * @since 0.4.0 * * @param <NV> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/localpca/KNNQueryFilteredPCAIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/localpca/KNNQueryFilteredPCAIndex.java index 8e81d368..8dc06940 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/localpca/KNNQueryFilteredPCAIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/localpca/KNNQueryFilteredPCAIndex.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * * @author Elke Achtert * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * @apiviz.uses KNNQuery diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/preference/AbstractPreferenceVectorIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/preference/AbstractPreferenceVectorIndex.java index af1359d5..401a872f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/preference/AbstractPreferenceVectorIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/preference/AbstractPreferenceVectorIndex.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.index.preprocessed.AbstractPreprocessorIndex; * Abstract base class for preference vector based algorithms. * * @author Erich Schubert + * @since 0.4.0 * * @param <NV> Number vector */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/preference/DiSHPreferenceVectorIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/preference/DiSHPreferenceVectorIndex.java index 0653e1bb..5e0a954e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/preference/DiSHPreferenceVectorIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/preference/DiSHPreferenceVectorIndex.java @@ -70,6 +70,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * database. * * @author Elke Achtert + * @since 0.4.0 * * @param <V> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/preference/HiSCPreferenceVectorIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/preference/HiSCPreferenceVectorIndex.java index a196e5d4..54b01a0b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/preference/HiSCPreferenceVectorIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/preference/HiSCPreferenceVectorIndex.java @@ -56,6 +56,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * database. * * @author Elke Achtert + * @since 0.4.0 * * @see HiSC * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/preference/PreferenceVectorIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/preference/PreferenceVectorIndex.java index 3a4ed850..896783c3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/preference/PreferenceVectorIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/preference/PreferenceVectorIndex.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.index.IndexFactory; * Interface for an index providing preference vectors. * * @author Erich Schubert + * @since 0.4.0 * * @param <NV> Vector type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/snn/SharedNearestNeighborIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/snn/SharedNearestNeighborIndex.java index 2b689d8d..22ebacc1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/snn/SharedNearestNeighborIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/snn/SharedNearestNeighborIndex.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.index.IndexFactory; * Interface for an index providing nearest neighbor sets. * * @author Erich Schubert + * @since 0.4.0 */ public interface SharedNearestNeighborIndex<O> extends Index { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/snn/SharedNearestNeighborPreprocessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/snn/SharedNearestNeighborPreprocessor.java index 81ce777d..7e65ff80 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/snn/SharedNearestNeighborPreprocessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/preprocessed/snn/SharedNearestNeighborPreprocessor.java @@ -63,6 +63,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * * @author Arthur Zimek * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has DistanceFunction * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/projected/LatLngAsECEFIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/projected/LatLngAsECEFIndex.java index e3bf3d88..3c38ea2d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/projected/LatLngAsECEFIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/projected/LatLngAsECEFIndex.java @@ -74,6 +74,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * {@link DatabaseQuery#HINT_EXACT} is set, it will not be used. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.composedOf LatLngToECEFProjection * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/projected/LngLatAsECEFIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/projected/LngLatAsECEFIndex.java index 794ecdd6..d247b4bf 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/projected/LngLatAsECEFIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/projected/LngLatAsECEFIndex.java @@ -74,6 +74,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * {@link DatabaseQuery#HINT_EXACT} is set, it will not be used. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.composedOf LngLatToECEFProjection * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/projected/PINN.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/projected/PINN.java index 61ab9e56..7c3dbb28 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/projected/PINN.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/projected/PINN.java @@ -51,6 +51,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.composedOf AchlioptasRandomProjectionFamily * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/projected/ProjectedIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/projected/ProjectedIndex.java index 090d00ac..daab827d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/projected/ProjectedIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/projected/ProjectedIndex.java @@ -79,6 +79,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * FIXME: add refinement to bulk queries! * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.composedOf Projection * @apiviz.has ProjectedKNNQuery diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/AbstractDirectoryEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/AbstractDirectoryEntry.java index 7918ed7d..9732469a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/AbstractDirectoryEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/AbstractDirectoryEntry.java @@ -31,6 +31,7 @@ import java.io.ObjectOutput; * Abstract superclass for entries in an tree based index structure. * * @author Elke Achtert + * @since 0.2 */ public abstract class AbstractDirectoryEntry implements DirectoryEntry { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/AbstractLeafEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/AbstractLeafEntry.java index 0ef87f34..b99adc16 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/AbstractLeafEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/AbstractLeafEntry.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDUtil; * Abstract superclass for entries in an tree based index structure. * * @author Elke Achtert + * @since 0.2 */ public abstract class AbstractLeafEntry implements LeafEntry { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/AbstractNode.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/AbstractNode.java index e1bbdb29..b2922e55 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/AbstractNode.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/AbstractNode.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * Abstract superclass for nodes in an tree based index structure. * * @author Elke Achtert + * @since 0.2 * @param <E> the type of Entry used in the index */ public abstract class AbstractNode<E extends Entry> extends AbstractExternalizablePage implements Node<E> { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/BreadthFirstEnumeration.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/BreadthFirstEnumeration.java index ee86c3fa..14c3e434 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/BreadthFirstEnumeration.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/BreadthFirstEnumeration.java @@ -32,6 +32,7 @@ import java.util.Queue; * Breadth first enumeration over the nodes of an index structure. * * @author Elke Achtert + * @since 0.2 * * @apiviz.uses IndexTree * @apiviz.has IndexTreePath diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/DirectoryEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/DirectoryEntry.java index cc335e90..2edf3fa5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/DirectoryEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/DirectoryEntry.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.index.tree; * Directory Entry * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.excludeSubtypes */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/Entry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/Entry.java index 47369bac..8558842e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/Entry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/Entry.java @@ -30,6 +30,7 @@ import java.io.Externalizable; * represent a node or a data object. * * @author Elke Achtert + * @since 0.2 * @apiviz.excludeSubtypes */ public interface Entry extends Externalizable { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/IndexTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/IndexTree.java index dd38bb6f..2024fa4c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/IndexTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/IndexTree.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * Abstract super class for all tree based index classes. * * @author Elke Achtert + * @since 0.2 * * @apiviz.composedOf PageFile * @apiviz.has Node oneway - - contains diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/IndexTreePath.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/IndexTreePath.java index 02aa2c68..91737ac8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/IndexTreePath.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/IndexTreePath.java @@ -29,6 +29,7 @@ import java.util.ArrayList; * Represents a path to a node in an index structure. * * @author Elke Achtert + * @since 0.2 * * @apiviz.has Entry oneway - - «contains» * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/LeafEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/LeafEntry.java index 8be982bd..b8e10035 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/LeafEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/LeafEntry.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBID; * Leaf entry * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.excludeSubtypes */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/Node.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/Node.java index 34ddfbeb..aaacfc2a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/Node.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/Node.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.persistent.Page; * has to provide an enumeration over its children. * * @author Elke Achtert + * @since 0.2 * * @apiviz.composedOf Entry * @apiviz.excludeSubtypes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/TreeIndexHeader.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/TreeIndexHeader.java index 0e40d2c1..44c520ea 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/TreeIndexHeader.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/TreeIndexHeader.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.persistent.DefaultPageHeader; * information is needed for persistent storage. * * @author Elke Achtert + * @since 0.2 */ public class TreeIndexHeader extends DefaultPageHeader { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/MetricalIndexTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/MetricalIndexTree.java index cd0be5e0..fffd7020 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/MetricalIndexTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/MetricalIndexTree.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.persistent.PageFile; * Abstract super class for all metrical index classes. * * @author Elke Achtert + * @since 0.2 * * @param <O> the type of objects stored in the index * @param <N> the type of nodes used in the metrical index diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/covertree/AbstractCoverTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/covertree/AbstractCoverTree.java index 84878486..891b353d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/covertree/AbstractCoverTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/covertree/AbstractCoverTree.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Abstract base class for cover tree variants. * * @author Erich Schubert + * @since 0.7.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/covertree/CoverTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/covertree/CoverTree.java index ca20af1e..ca07889b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/covertree/CoverTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/covertree/CoverTree.java @@ -70,6 +70,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * TODO: allow insertions and removals, as in the original publication. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has CoverTreeRangeQuery * @apiviz.has CoverTreeKNNQuery diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/covertree/SimplifiedCoverTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/covertree/SimplifiedCoverTree.java index a3daba34..2b85283f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/covertree/SimplifiedCoverTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/covertree/SimplifiedCoverTree.java @@ -71,6 +71,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.heap.DoubleObjectMinHeap; * TODO: allow insertions and removals, as in the original publication. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has CoverTreeRangeQuery * @apiviz.has CoverTreeKNNQuery diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/AbstractMTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/AbstractMTree.java index 7282a39a..073596ad 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/AbstractMTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/AbstractMTree.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.DoubleIntPair; * Abstract super class for all M-Tree variants. * * @author Elke Achtert + * @since 0.2 * * @apiviz.composedOf MTreeSettings * @apiviz.composedOf Statistics diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/AbstractMTreeFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/AbstractMTreeFactory.java index 0a7eb7cf..b3207656 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/AbstractMTreeFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/AbstractMTreeFactory.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Abstract factory for various MTrees * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.stereotype factory * @apiviz.uses AbstractMTree oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/AbstractMTreeNode.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/AbstractMTreeNode.java index d065891b..32ee5980 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/AbstractMTreeNode.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/AbstractMTreeNode.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.logging.LoggingConfiguration; * Abstract super class for nodes in M-Tree variants. * * @author Elke Achtert + * @since 0.2 * * @apiviz.has MTreeEntry oneway - - contains * @apiviz.excludeSubtypes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/MTreeDirectoryEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/MTreeDirectoryEntry.java index 46b556e5..604c9356 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/MTreeDirectoryEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/MTreeDirectoryEntry.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.index.tree.AbstractDirectoryEntry; * the routing object of the entry to its parent's routing object in the M-Tree. * * @author Elke Achtert + * @since 0.2 */ public class MTreeDirectoryEntry extends AbstractDirectoryEntry implements MTreeEntry { private static final long serialVersionUID = 2; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/MTreeEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/MTreeEntry.java index 8578ad54..d53dcf28 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/MTreeEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/MTreeEntry.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.index.tree.Entry; * Defines the requirements for an entry in an M-Tree node. * * @author Elke Achtert + * @since 0.2 */ public interface MTreeEntry extends Entry { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/MTreeLeafEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/MTreeLeafEntry.java index c52216be..dfa43a13 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/MTreeLeafEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/MTreeLeafEntry.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.index.tree.AbstractLeafEntry; * M-Tree. * * @author Elke Achtert + * @since 0.2 */ public class MTreeLeafEntry extends AbstractLeafEntry implements MTreeEntry { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/MTreeSettings.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/MTreeSettings.java index e139ad43..8f66f079 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/MTreeSettings.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/MTreeSettings.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.split.MT * Class to store the MTree settings. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type * @param <N> Node type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/AbstractMkTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/AbstractMkTree.java index dd55b525..0646ba3b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/AbstractMkTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/AbstractMkTree.java @@ -49,6 +49,7 @@ import de.lmu.ifi.dbs.elki.persistent.PageFile; * k is less than or equal to the given parameter. * * @author Elke Achtert + * @since 0.2 * @param <O> the type of DatabaseObject to be stored in the metrical index * @param <N> the type of MetricalNode used in the metrical index * @param <E> the type of MetricalEntry used in the metrical index diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/AbstractMkTreeUnified.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/AbstractMkTreeUnified.java index b3fc0f5f..462a4ed1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/AbstractMkTreeUnified.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/AbstractMkTreeUnified.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.persistent.PageFile; * k is less than or equal to the given parameter. * * @author Elke Achtert + * @since 0.2 * * @apiviz.has MkTreeHeader oneway * @apiviz.composedOf MkTreeSettings diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/AbstractMkTreeUnifiedFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/AbstractMkTreeUnifiedFactory.java index 577ca31f..5e98fc10 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/AbstractMkTreeUnifiedFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/AbstractMkTreeUnifiedFactory.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * Abstract factory for various Mk-Trees * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.stereotype factory * @apiviz.uses AbstractMkTreeUnified oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/MkTreeHeader.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/MkTreeHeader.java index 74b34471..f7a08db2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/MkTreeHeader.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/MkTreeHeader.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.index.tree.TreeIndexHeader; * This information is needed for persistent storage. * * @author Elke Achtert + * @since 0.2 */ public class MkTreeHeader extends TreeIndexHeader { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/MkTreeSettings.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/MkTreeSettings.java index a3410291..1f94da0a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/MkTreeSettings.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/MkTreeSettings.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeSettings; * Class with settings for MkTrees. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type * @param <N> Node type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppDirectoryEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppDirectoryEntry.java index a8cf62e0..3dc8786e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppDirectoryEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppDirectoryEntry.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeDirectoryEntry * of its knn-distances. * * @author Elke Achtert + * @since 0.2 */ class MkAppDirectoryEntry extends MTreeDirectoryEntry implements MkAppEntry { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppEntry.java index 53f769e1..88a4bc07 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppEntry.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeEntry; * provided. * * @author Elke Achtert + * @since 0.2 * * @apiviz.composedOf PolynomialApproximation */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppLeafEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppLeafEntry.java index 098e82ac..e5d92d00 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppLeafEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppLeafEntry.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeLeafEntry; * knn-distances. * * @author Elke Achtert + * @since 0.2 */ class MkAppLeafEntry extends MTreeLeafEntry implements MkAppEntry { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTree.java index ac9a00bb..14755f4b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTree.java @@ -54,6 +54,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteArrayUtil; * parameter k < kmax. * * @author Elke Achtert + * @since 0.2 * * @apiviz.composedOf MkAppTreeSettings * @apiviz.has MkAppTreeNode oneway - - contains diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTreeFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTreeFactory.java index b6a5792d..0c960da8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTreeFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTreeFactory.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * Factory for a MkApp-Tree * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.stereotype factory * @apiviz.uses MkAppTreeIndex oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTreeIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTreeIndex.java index 7e9f2332..0ecf04e4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTreeIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTreeIndex.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.persistent.PageFile; * MkAppTree used as database index. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTreeNode.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTreeNode.java index cb798e46..4d37e326 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTreeNode.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTreeNode.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.FormatUtil; * Represents a node in an MkApp-Tree. * * @author Elke Achtert + * @since 0.2 * * @apiviz.has MkAppEntry oneway - - contains * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTreeSettings.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTreeSettings.java index 993b198f..a373d472 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTreeSettings.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/MkAppTreeSettings.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.mktrees.MkTreeSetti * Settings class for the MkApp Tree. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/PolynomialApproximation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/PolynomialApproximation.java index fa795da7..b89e643d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/PolynomialApproximation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkapp/PolynomialApproximation.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.FormatUtil; * for knn-distances consisting of parameters b0, ..., bp. * * @author Elke Achtert + * @since 0.2 */ public class PolynomialApproximation implements Externalizable { private static final long serialVersionUID = 1; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/ApproximationLine.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/ApproximationLine.java index d11415d2..f4567186 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/ApproximationLine.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/ApproximationLine.java @@ -33,6 +33,7 @@ import java.io.ObjectOutput; * axes intercept t and a start value for k. * * @author Elke Achtert + * @since 0.2 */ public class ApproximationLine implements Externalizable { private static final long serialVersionUID = 1; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/ConvexHull.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/ConvexHull.java index f0e202e1..36490bc0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/ConvexHull.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/ConvexHull.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.mktrees.mkcop; * Holds the lower and upper hull for some values. * * @author Elke Achtert + * @since 0.2 */ public class ConvexHull { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPDirectoryEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPDirectoryEntry.java index 012728a3..92f514bc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPDirectoryEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPDirectoryEntry.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeDirectoryEntry * its knn-distances. * * @author Elke Achtert + * @since 0.2 */ class MkCoPDirectoryEntry extends MTreeDirectoryEntry implements MkCoPEntry { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPEntry.java index 05f93438..0a112325 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPEntry.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeEntry; * provided. * * @author Elke Achtert + * @since 0.2 * * @apiviz.composedOf ApproximationLine */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPLeafEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPLeafEntry.java index dbb463c8..fc7a10b5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPLeafEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPLeafEntry.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeLeafEntry; * approximation of its knn-distances. * * @author Elke Achtert + * @since 0.2 */ class MkCoPLeafEntry extends MTreeLeafEntry implements MkCoPEntry { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPTree.java index 322b832e..1165b9d5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPTree.java @@ -52,6 +52,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteArrayUtil; * parameter k < kmax. * * @author Elke Achtert + * @since 0.2 * * @apiviz.has MkCoPTreeNode oneway - - contains * @apiviz.has ConvexHull diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPTreeIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPTreeIndex.java index c0de7232..b17490a1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPTreeIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPTreeIndex.java @@ -47,6 +47,7 @@ import de.lmu.ifi.dbs.elki.persistent.PageFile; * MkCoPTree used as database index. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPTreeNode.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPTreeNode.java index 890887b7..0a23e15b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPTreeNode.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCoPTreeNode.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.AbstractMTreeNode; * Represents a node in an MkCop-Tree. * * @author Elke Achtert + * @since 0.2 * * @apiviz.has MkCoPEntry oneway - - contains * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCopTreeFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCopTreeFactory.java index d16dfa50..e8ac44f6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCopTreeFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkcop/MkCopTreeFactory.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * Factory for a MkCoPTree-Tree * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.stereotype factory * @apiviz.uses MkCoPTreeIndex oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxDirectoryEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxDirectoryEntry.java index 0fb9e0c6..c1aaa975 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxDirectoryEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxDirectoryEntry.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeDirectoryEntry * the underlying MkMax-Tree node. * * @author Elke Achtert + * @since 0.2 */ class MkMaxDirectoryEntry extends MTreeDirectoryEntry implements MkMaxEntry { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxEntry.java index 867343f4..b5dc4232 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxEntry.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeEntry; * neighbor distance of the underlying data object or MkMax-Tree node. * * @author Elke Achtert + * @since 0.2 */ interface MkMaxEntry extends MTreeEntry { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxLeafEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxLeafEntry.java index 699a6a2a..e5883f0c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxLeafEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxLeafEntry.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeLeafEntry; * the underlying data object. * * @author Elke Achtert + * @since 0.2 */ class MkMaxLeafEntry extends MTreeLeafEntry implements MkMaxEntry { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxTree.java index 3f2c807e..d2c64e43 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxTree.java @@ -51,6 +51,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.DoubleIntPair; * in each entry of a node. * * @author Elke Achtert + * @since 0.2 * * @apiviz.has MkMaxTreeNode oneway - - contains * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxTreeFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxTreeFactory.java index c8d0dc72..ee15dff6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxTreeFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxTreeFactory.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; * Factory for MkMaxTrees * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.stereotype factory * @apiviz.uses MkMaxTreeIndex oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxTreeIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxTreeIndex.java index 21e2d9df..6182ae26 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxTreeIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxTreeIndex.java @@ -53,6 +53,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.NotImplementedException; * MkMax tree * * @author Elke Achtert + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxTreeNode.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxTreeNode.java index 1e044098..3781bbd4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxTreeNode.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mkmax/MkMaxTreeNode.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.AbstractMTreeNode; * Represents a node in an {@link MkMaxTree}. * * @author Elke Achtert + * @since 0.2 * * @apiviz.has MkMaxEntry oneway - - contains * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabDirectoryEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabDirectoryEntry.java index 54345ca6..c16095e9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabDirectoryEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabDirectoryEntry.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeDirectoryEntry * parameters k <= k_max. * * @author Elke Achtert + * @since 0.2 */ class MkTabDirectoryEntry extends MTreeDirectoryEntry implements MkTabEntry { private static final long serialVersionUID = 2; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabEntry.java index 09dbb94c..2b2a247d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabEntry.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeEntry; * parameters k <= k_max of the underlying data object or MkTab-Tree node. * * @author Elke Achtert + * @since 0.2 */ interface MkTabEntry extends MTreeEntry { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabLeafEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabLeafEntry.java index 39627445..e3881745 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabLeafEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabLeafEntry.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeLeafEntry; * parameters k <= k_max. * * @author Elke Achtert + * @since 0.2 */ class MkTabLeafEntry extends MTreeLeafEntry implements MkTabEntry { private static final long serialVersionUID = 2; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabTree.java index 5f99fc95..e45fea67 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabTree.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteArrayUtil; * of a node. * * @author Elke Achtert + * @since 0.2 * * @apiviz.has MkTabTreeNode oneway - - contains * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabTreeFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabTreeFactory.java index ce4a1513..ad182b78 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabTreeFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabTreeFactory.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; * Factory for MkTabTrees * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.stereotype factory * @apiviz.uses MkTabTreeIndex oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabTreeIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabTreeIndex.java index 7fcc05fc..bef30432 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabTreeIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabTreeIndex.java @@ -49,6 +49,7 @@ import de.lmu.ifi.dbs.elki.persistent.PageFile; * MkTabTree used as database index. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabTreeNode.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabTreeNode.java index be7f0790..9c62f487 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabTreeNode.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mktrees/mktab/MkTabTreeNode.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.AbstractMTreeNode; * Represents a node in a MkMax-Tree. * * @author Elke Achtert + * @since 0.2 * * @apiviz.has MkTabEntry oneway - - contains * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/MTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/MTree.java index e7a1bdfa..631388b0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/MTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/MTree.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * </p> * * @author Elke Achtert + * @since 0.2 * * @apiviz.has MTreeNode oneway - - contains * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/MTreeFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/MTreeFactory.java index a65d96c7..faa1cd95 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/MTreeFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/MTreeFactory.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; * Factory for a M-Tree * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.stereotype factory * @apiviz.uses MTreeIndex oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/MTreeIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/MTreeIndex.java index 8d73bd58..d8b2bddd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/MTreeIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/MTreeIndex.java @@ -55,6 +55,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteArrayUtil; * Class for using an m-tree as database index. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/MTreeNode.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/MTreeNode.java index db8f4a19..b8dd882d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/MTreeNode.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/mtree/MTreeNode.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeEntry; * Represents a node in an M-Tree. * * @author Elke Achtert + * @since 0.2 * @param <O> Object type */ public class MTreeNode<O> extends AbstractMTreeNode<O, MTreeNode<O>, MTreeEntry> { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/query/MTreeQueryUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/query/MTreeQueryUtil.java index 44446fe3..35f2b40a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/query/MTreeQueryUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/query/MTreeQueryUtil.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.AbstractMTree; * Query utility classes for MTrees. * * @author Erich Schubert + * @since 0.5.5 */ public final class MTreeQueryUtil { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/query/MetricalIndexKNNQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/query/MetricalIndexKNNQuery.java index cd574b0e..73a21b69 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/query/MetricalIndexKNNQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/query/MetricalIndexKNNQuery.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.heap.ComparableMinHeap; * Instance of a KNN query for a particular spatial index. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses AbstractMTree * @apiviz.uses DoubleMTreeDistanceSearchCandidate diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/query/MetricalIndexRangeQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/query/MetricalIndexRangeQuery.java index 392b3e38..5b57ea4b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/query/MetricalIndexRangeQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/query/MetricalIndexRangeQuery.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeEntry; * Instance of a range query for a particular spatial index. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses AbstractMTree * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/query/MkTreeRKNNQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/query/MkTreeRKNNQuery.java index 9a2527f7..b69e4701 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/query/MkTreeRKNNQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/query/MkTreeRKNNQuery.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.NotImplementedException; * Instance of a rKNN query for a particular spatial index. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses AbstractMkTree */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/insert/MTreeInsert.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/insert/MTreeInsert.java index cf460fd8..c51979e1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/insert/MTreeInsert.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/insert/MTreeInsert.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeEntry; * FIXME: move this to the actual insert. * * @author Erich Schubert + * @since 0.2 */ public interface MTreeInsert<O, N extends AbstractMTreeNode<O, N, E>, E extends MTreeEntry> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/insert/MinimumEnlargementInsert.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/insert/MinimumEnlargementInsert.java index 22bd611f..58ab4f4f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/insert/MinimumEnlargementInsert.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/insert/MinimumEnlargementInsert.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.6.0 */ @Reference(authors = "P. Ciaccia, M. Patella, P. Zezula", // title = "M-tree: An Efficient Access Method for Similarity Search in Metric Spaces", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/Assignments.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/Assignments.java index 7095bd0a..d2fd6570 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/Assignments.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/Assignments.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeEntry; * Encapsulates the attributes of an assignment during a split. * * @author Elke Achtert + * @since 0.2 * * @apiviz.composedOf DistanceEntry * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/DistanceEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/DistanceEntry.java index 79d4668a..ac55a1d3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/DistanceEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/DistanceEntry.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.index.tree.Entry; * belonging to this entry. * * @author Elke Achtert + * @since 0.2 * * @apiviz.uses Entry * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/MLBDistSplit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/MLBDistSplit.java index f07ed672..648c97ee 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/MLBDistSplit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/MLBDistSplit.java @@ -26,6 +26,7 @@ package de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.split; import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.AbstractMTree; import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.AbstractMTreeNode; import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeEntry; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; /** @@ -41,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Elke Achtert + * @since 0.2 * * @param <O> the type of DatabaseObject to be stored in the M-Tree * @param <N> the type of AbstractMTreeNode used in the M-Tree @@ -50,6 +52,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; title = "M-tree: An Efficient Access Method for Similarity Search in Metric Spaces", // booktitle = "VLDB'97, Proceedings of 23rd International Conference on Very Large Data Bases, August 25-29, 1997, Athens, Greece", // url = "http://www.vldb.org/conf/1997/P426.PDF") +@Alias("de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.split.MLBDistSplit") public class MLBDistSplit<O, N extends AbstractMTreeNode<O, N, E>, E extends MTreeEntry> extends MTreeSplit<O, N, E> { /** * Creates a new split object. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/MMRadSplit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/MMRadSplit.java index 16687a20..6ef4e97a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/MMRadSplit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/MMRadSplit.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Elke Achtert + * @since 0.2 * * @param <O> the type of objects to be stored in the M-Tree * @param <N> the type of AbstractMTreeNode used in the M-Tree diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/MRadSplit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/MRadSplit.java index e364c61f..a53e02de 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/MRadSplit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/MRadSplit.java @@ -26,6 +26,7 @@ package de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.strategies.split; import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.AbstractMTree; import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.AbstractMTreeNode; import de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.MTreeEntry; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; /** @@ -41,12 +42,14 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Elke Achtert + * @since 0.2 * * @param <O> the type of DatabaseObject to be stored in the M-Tree * @param <N> the type of AbstractMTreeNode used in the M-Tree * @param <E> the type of MetricalEntry used in the M-Tree */ @Reference(authors = "P. Ciaccia, M. Patella, P. Zezula", title = "M-tree: An Efficient Access Method for Similarity Search in Metric Spaces", booktitle = "VLDB'97, Proceedings of 23rd International Conference on Very Large Data Bases, August 25-29, 1997, Athens, Greece", url = "http://www.vldb.org/conf/1997/P426.PDF") +@Alias("de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants.split.MRadSplit") public class MRadSplit<O, N extends AbstractMTreeNode<O, N, E>, E extends MTreeEntry> extends MTreeSplit<O, N, E> { /** * Creates a new split object. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/MTreeSplit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/MTreeSplit.java index 01c612c0..30487846 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/MTreeSplit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/MTreeSplit.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arrays.DoubleIntegerArrayQui * Abstract super class for splitting a node in an M-Tree. * * @author Elke Achtert + * @since 0.2 * * @apiviz.composedOf Assignments * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/RandomSplit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/RandomSplit.java index e7c6dbca..27970b25 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/RandomSplit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/metrical/mtreevariants/strategies/split/RandomSplit.java @@ -52,6 +52,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * </p> * * @author Elke Achtert + * @since 0.2 * * @param <O> the type of DatabaseObject to be stored in the M-Tree * @param <N> the type of AbstractMTreeNode used in the M-Tree diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/query/DoubleDistanceSearchCandidate.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/query/DoubleDistanceSearchCandidate.java index 46dbe003..a5d422f7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/query/DoubleDistanceSearchCandidate.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/query/DoubleDistanceSearchCandidate.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.index.tree.query; * implementation). * * @author Erich Schubert + * @since 0.4.0 */ public class DoubleDistanceSearchCandidate implements Comparable<DoubleDistanceSearchCandidate> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/query/DoubleMTreeDistanceSearchCandidate.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/query/DoubleMTreeDistanceSearchCandidate.java index bdd1e0f5..08562d4d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/query/DoubleMTreeDistanceSearchCandidate.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/query/DoubleMTreeDistanceSearchCandidate.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBID; * covering radius. * * @author Elke Achtert + * @since 0.4.0 */ public class DoubleMTreeDistanceSearchCandidate extends DoubleDistanceSearchCandidate { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/query/GenericMTreeDistanceSearchCandidate.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/query/GenericMTreeDistanceSearchCandidate.java index 575436db..2cdad822 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/query/GenericMTreeDistanceSearchCandidate.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/query/GenericMTreeDistanceSearchCandidate.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBID; * FIXME: Class naming in this package is inconsistent. * * @author Elke Achtert + * @since 0.4.0 */ public class GenericMTreeDistanceSearchCandidate implements Comparable<GenericMTreeDistanceSearchCandidate> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialDirectoryEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialDirectoryEntry.java index 56fd0e0c..71bfef66 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialDirectoryEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialDirectoryEntry.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.index.tree.AbstractDirectoryEntry; * spatial node. * * @author Elke Achtert + * @since 0.2 */ public class SpatialDirectoryEntry extends AbstractDirectoryEntry implements SpatialEntry { private static final long serialVersionUID = 1; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialEntry.java index 4122b90c..07d6bc17 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialEntry.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.index.tree.Entry; * Defines the requirements for an entry in a node of a Spatial Index. * * @author Elke Achtert + * @since 0.2 */ public interface SpatialEntry extends Entry, SpatialComparable { // Emtpy - just combining the two interfaces above. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialIndexTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialIndexTree.java index 52a92916..13acb8e4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialIndexTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialIndexTree.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.persistent.PageFile; * Abstract super class for all spatial index tree classes. * * @author Elke Achtert + * @since 0.2 * * @apiviz.landmark * @apiviz.has SpatialNode oneway - - contains diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialNode.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialNode.java index af88b35f..f2a584d1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialNode.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialNode.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.index.tree.Node; * leaf node. * * @author Elke Achtert + * @since 0.2 * * @apiviz.composedOf SpatialEntry * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialPair.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialPair.java index 0d4884ad..4f008337 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialPair.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialPair.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; * which are spatial nodes or data objects. * * @author Elke Achtert + * @since 0.4.0 */ public class SpatialPair<K, V extends SpatialComparable> extends Pair<K, V> implements SpatialComparable { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialPointLeafEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialPointLeafEntry.java index 705c54d6..bc25c0cd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialPointLeafEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/SpatialPointLeafEntry.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; * and the values of the underlying data object. * * @author Elke Achtert + * @since 0.2 */ public class SpatialPointLeafEntry extends AbstractLeafEntry implements SpatialEntry, NumberVector { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/kd/MinimalisticMemoryKDTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/kd/MinimalisticMemoryKDTree.java index 11bcb17a..90b07c9e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/kd/MinimalisticMemoryKDTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/kd/MinimalisticMemoryKDTree.java @@ -83,6 +83,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * TODO: add support for weighted Minkowski distances. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has KDTreeKNNQuery * @apiviz.has KDTreeRangeQuery diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/kd/SmallMemoryKDTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/kd/SmallMemoryKDTree.java index d44731f0..ca7c5821 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/kd/SmallMemoryKDTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/kd/SmallMemoryKDTree.java @@ -79,6 +79,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * TODO: add support for weighted Minkowski distances. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has KDTreeKNNQuery * @apiviz.has KDTreeRangeQuery diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/AbstractRStarTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/AbstractRStarTree.java index 5c3530ec..fd7fd8b5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/AbstractRStarTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/AbstractRStarTree.java @@ -59,6 +59,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * FeatureVector) is intentional, because we have spatial requirements. * * @author Elke Achtert + * @since 0.2 * * @apiviz.landmark * @apiviz.has AbstractRStarTreeNode oneway - - contains diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/AbstractRStarTreeFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/AbstractRStarTreeFactory.java index ae0e3389..44175e99 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/AbstractRStarTreeFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/AbstractRStarTreeFactory.java @@ -47,6 +47,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Abstract factory for R*-Tree based trees. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.stereotype factory * @apiviz.uses AbstractRStarTree oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/AbstractRStarTreeNode.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/AbstractRStarTreeNode.java index 77de9df4..56f85ae3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/AbstractRStarTreeNode.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/AbstractRStarTreeNode.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.logging.LoggingConfiguration; * Abstract superclass for nodes in a R*-Tree. * * @author Elke Achtert + * @since 0.2 * @param <N> Node type * @param <E> Entry type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/AbstractRTreeSettings.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/AbstractRTreeSettings.java index f8c6e732..87bad4ac 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/AbstractRTreeSettings.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/AbstractRTreeSettings.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.strategies.split.Top * Class to wrap common Rtree settings. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.composedOf BulkSplit * @apiviz.composedOf SplitStrategy diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/NonFlatRStarTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/NonFlatRStarTree.java index 5d65d605..bdb68439 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/NonFlatRStarTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/NonFlatRStarTree.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.persistent.PageFile; * Abstract superclass for all non-flat R*-Tree variants. * * @author Elke Achtert + * @since 0.2 * * @param <N> Node type * @param <E> Entry type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluDirectoryEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluDirectoryEntry.java index b8792abd..c4e941bf 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluDirectoryEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluDirectoryEntry.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.index.tree.spatial.SpatialDirectoryEntry; * objects. * * @author Elke Achtert + * @since 0.2 */ public class DeLiCluDirectoryEntry extends SpatialDirectoryEntry implements DeLiCluEntry { private static final long serialVersionUID = 1; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluEntry.java index f6fc3fb6..feb4501d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluEntry.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.index.tree.spatial.SpatialEntry; * contains handled or unhandled data objects. * * @author Elke Achtert + * @since 0.2 */ public interface DeLiCluEntry extends SpatialEntry { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluLeafEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluLeafEntry.java index 4a02c4fd..d973a226 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluLeafEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluLeafEntry.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.index.tree.spatial.SpatialPointLeafEntry; * whether this entry's node contains handled or unhandled data objects. * * @author Elke Achtert + * @since 0.2 */ public class DeLiCluLeafEntry extends SpatialPointLeafEntry implements DeLiCluEntry { private static final long serialVersionUID = 1; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluNode.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluNode.java index 72fdd154..994b5777 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluNode.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluNode.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.AbstractRStarTreeNod * Represents a node in a DeLiClu-Tree. * * @author Elke Achtert + * @since 0.2 * * @apiviz.has DeLiCluEntry oneway - - contains */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluTree.java index dafa4992..a977be40 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluTree.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.persistent.PageFile; * algorithm. * * @author Elke Achtert + * @since 0.2 * * @apiviz.has DeLiCluNode oneway - - contains */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluTreeFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluTreeFactory.java index 66a59352..3e706658 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluTreeFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluTreeFactory.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.persistent.PageFileFactory; * Factory for DeLiClu R*-Trees. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.stereotype factory * @apiviz.uses DeLiCluTreeIndex oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluTreeIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluTreeIndex.java index 436e38fd..7f078906 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluTreeIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/deliclu/DeLiCluTreeIndex.java @@ -51,6 +51,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * The common use of the DeLiClu tree: indexing number vectors. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/flat/FlatRStarTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/flat/FlatRStarTree.java index 7f0e77ab..01b4a594 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/flat/FlatRStarTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/flat/FlatRStarTree.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.persistent.PageFile; * to search for certain object in the structure and ensures persistence. * * @author Elke Achtert + * @since 0.2 * * @apiviz.has FlatRStarTreeNode oneway - - contains */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/flat/FlatRStarTreeFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/flat/FlatRStarTreeFactory.java index 88505f0c..ad4406ad 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/flat/FlatRStarTreeFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/flat/FlatRStarTreeFactory.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.persistent.PageFileFactory; * Factory for flat R*-Trees. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.stereotype factory * @apiviz.uses FlatRStarTreeIndex oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/flat/FlatRStarTreeIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/flat/FlatRStarTreeIndex.java index 21f4baea..7bfa77f4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/flat/FlatRStarTreeIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/flat/FlatRStarTreeIndex.java @@ -52,6 +52,7 @@ import de.lmu.ifi.dbs.elki.persistent.PageFile; * The common use of the flat rstar tree: indexing number vectors. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/flat/FlatRStarTreeNode.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/flat/FlatRStarTreeNode.java index 0ad3af21..2ae002d8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/flat/FlatRStarTreeNode.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/flat/FlatRStarTreeNode.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; * Represents a node in a flat R*-Tree. * * @author Elke Achtert + * @since 0.2 */ public class FlatRStarTreeNode extends AbstractRStarTreeNode<FlatRStarTreeNode, SpatialEntry> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/EuclideanRStarTreeKNNQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/EuclideanRStarTreeKNNQuery.java index 25884cdf..30e41ff3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/EuclideanRStarTreeKNNQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/EuclideanRStarTreeKNNQuery.java @@ -58,6 +58,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.uses EuclideanDistanceFunction * @apiviz.uses SquaredEuclideanDistanceFunction diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/EuclideanRStarTreeRangeQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/EuclideanRStarTreeRangeQuery.java index 70112d7e..9c04d2a5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/EuclideanRStarTreeRangeQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/EuclideanRStarTreeRangeQuery.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses EuclideanDistanceFunction * @apiviz.uses SquaredEuclideanDistanceFunction diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/RStarTreeKNNQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/RStarTreeKNNQuery.java index bb1a57a4..763841ef 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/RStarTreeKNNQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/RStarTreeKNNQuery.java @@ -65,6 +65,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses AbstractRStarTree * @apiviz.uses SpatialPrimitiveDistanceFunction diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/RStarTreeRangeQuery.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/RStarTreeRangeQuery.java index b8929011..0319e809 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/RStarTreeRangeQuery.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/RStarTreeRangeQuery.java @@ -51,6 +51,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses AbstractRStarTree * @apiviz.uses SpatialPrimitiveDistanceFunction diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/RStarTreeUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/RStarTreeUtil.java index ee8cd6f0..9808bf30 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/RStarTreeUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/query/RStarTreeUtil.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.AbstractRStarTree; * Utility class for RStar trees * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNDirectoryEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNDirectoryEntry.java index 9b422334..93b32af8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNDirectoryEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNDirectoryEntry.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.index.tree.spatial.SpatialDirectoryEntry; * underlying RdKNN-Tree node. * * @author Elke Achtert + * @since 0.2 * @param Distance type */ public class RdKNNDirectoryEntry extends SpatialDirectoryEntry implements RdKNNEntry { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNEntry.java index 9d98dcd0..b85a1c92 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNEntry.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.index.tree.spatial.SpatialEntry; * data object or RdKNN-Tree node. * * @author Elke Achtert + * @since 0.2 */ interface RdKNNEntry extends SpatialEntry { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNLeafEntry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNLeafEntry.java index 44c65c5f..491d6cfe 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNLeafEntry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNLeafEntry.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.index.tree.spatial.SpatialPointLeafEntry; * data object. * * @author Elke Achtert + * @since 0.2 */ public class RdKNNLeafEntry extends SpatialPointLeafEntry implements RdKNNEntry { private static final long serialVersionUID = 2; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNNode.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNNode.java index ce4ac0dd..6a887047 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNNode.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNNode.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.AbstractRStarTreeNod * Represents a node in a RDkNN-Tree. * * @author Elke Achtert + * @since 0.2 * * @apiviz.has RdKNNEntry oneway - - contains */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNTree.java index b9485503..04e45424 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNTree.java @@ -74,6 +74,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.DoubleObjPair; * TODO: noch nicht fertig!!! * * @author Elke Achtert + * @since 0.2 * * @apiviz.has RdKNNNode * @apiviz.has RdKNNTreeHeader diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNTreeFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNTreeFactory.java index fbe03399..9ccdea59 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNTreeFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNTreeFactory.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Factory for RdKNN R*-Trees. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.stereotype factory * @apiviz.uses RdKNNTree oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNTreeHeader.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNTreeHeader.java index 4b2b8c5f..94af7721 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNTreeHeader.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdKNNTreeHeader.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.index.tree.TreeIndexHeader; * needed for persistent storage. * * @author Elke Achtert + * @since 0.2 */ class RdKNNTreeHeader extends TreeIndexHeader { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdkNNSettings.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdkNNSettings.java index 0cee0c4a..931428b7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdkNNSettings.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rdknn/RdkNNSettings.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.AbstractRTreeSetting * Settings for the RdKNN Tree. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/RStarTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/RStarTree.java index b4e19638..986ade9d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/RStarTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/RStarTree.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * for certain object in the structure and ensures persistence. * * @author Elke Achtert + * @since 0.2 * * @apiviz.has RStarTreeNode oneway - - contains */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/RStarTreeFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/RStarTreeFactory.java index aacb94c5..efdbdcc9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/RStarTreeFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/RStarTreeFactory.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.Alias; * Factory for regular R*-Trees. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark factory * @apiviz.uses RStarTreeIndex oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/RStarTreeIndex.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/RStarTreeIndex.java index 17c7b942..dfa39915 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/RStarTreeIndex.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/RStarTreeIndex.java @@ -51,6 +51,7 @@ import de.lmu.ifi.dbs.elki.persistent.PageFile; * The common use of the rstar tree: indexing number vectors. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/RStarTreeNode.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/RStarTreeNode.java index d5d01542..14361c87 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/RStarTreeNode.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/rstar/RStarTreeNode.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.AbstractRStarTreeNod * Represents a node in an R*-Tree. * * @author Elke Achtert + * @since 0.2 */ public class RStarTreeNode extends AbstractRStarTreeNode<RStarTreeNode, SpatialEntry> { private static final long serialVersionUID = 1; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/AbstractBulkSplit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/AbstractBulkSplit.java index 0c218c7e..75b55eba 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/AbstractBulkSplit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/AbstractBulkSplit.java @@ -30,6 +30,7 @@ import java.util.List; * Encapsulates the required parameters for a bulk split of a spatial index. * * @author Elke Achtert + * @since 0.4.0 */ public abstract class AbstractBulkSplit implements BulkSplit { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/AdaptiveSortTileRecursiveBulkSplit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/AdaptiveSortTileRecursiveBulkSplit.java index 55b8d5ec..0eda00fd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/AdaptiveSortTileRecursiveBulkSplit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/AdaptiveSortTileRecursiveBulkSplit.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * See {@link SortTileRecursiveBulkSplit} for the original STR bulk load. * * @author Erich Schubert + * @since 0.5.0 */ public class AdaptiveSortTileRecursiveBulkSplit extends AbstractBulkSplit { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/BulkSplit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/BulkSplit.java index 84432746..0688fb1c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/BulkSplit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/BulkSplit.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.data.spatial.SpatialComparable; * Interface for a bulk split strategy. * * @author Erich Schubert + * @since 0.4.0 */ public interface BulkSplit { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/FileOrderBulkSplit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/FileOrderBulkSplit.java index ad77ceab..0c937b06 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/FileOrderBulkSplit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/FileOrderBulkSplit.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * before. * * @author Erich Schubert + * @since 0.5.0 */ public class FileOrderBulkSplit extends AbstractBulkSplit { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/MaxExtensionBulkSplit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/MaxExtensionBulkSplit.java index 3ad7a333..2bd67601 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/MaxExtensionBulkSplit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/MaxExtensionBulkSplit.java @@ -31,6 +31,7 @@ import java.util.List; import de.lmu.ifi.dbs.elki.data.spatial.SpatialComparable; import de.lmu.ifi.dbs.elki.data.spatial.SpatialSingleMinComparator; import de.lmu.ifi.dbs.elki.logging.Logging; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; /** @@ -38,9 +39,11 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * dimensions with maximum extension. * * @author Elke Achtert + * @since 0.4.0 * * @apiviz.composedOf SpatialSingleMinComparator */ +@Alias("de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.bulk.MaxExtensionBulkSplit") public class MaxExtensionBulkSplit extends AbstractBulkSplit { /** * Logger. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/MaxExtensionSortTileRecursiveBulkSplit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/MaxExtensionSortTileRecursiveBulkSplit.java index eeb3c050..e98ff4c2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/MaxExtensionSortTileRecursiveBulkSplit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/MaxExtensionSortTileRecursiveBulkSplit.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * further, by also varying the fan-out degree. * * @author Erich Schubert + * @since 0.5.0 */ public class MaxExtensionSortTileRecursiveBulkSplit extends AbstractBulkSplit { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/OneDimSortBulkSplit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/OneDimSortBulkSplit.java index 439bd9c7..111cb71c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/OneDimSortBulkSplit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/OneDimSortBulkSplit.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.5.0 */ @Reference(authors = "Roussopoulos, N. and Leifker, D.", title = "Direct spatial search on pictorial databases using packed R-trees", booktitle = "ACM SIGMOD Record 14-4", url = "http://dx.doi.org/10.1145/971699.318900") public class OneDimSortBulkSplit extends AbstractBulkSplit { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/SortTileRecursiveBulkSplit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/SortTileRecursiveBulkSplit.java index ed9e919e..7f074023 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/SortTileRecursiveBulkSplit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/SortTileRecursiveBulkSplit.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.5.0 */ @Reference(authors = "Leutenegger, S.T. and Lopez, M.A. and Edgington, J.", title = "STR: A simple and efficient algorithm for R-tree packing", booktitle = "Proc. 13th International Conference on Data Engineering, 1997", url = "http://dx.doi.org/10.1109/ICDE.1997.582015") @Alias({"str", "STR"}) diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/SpatialSortBulkSplit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/SpatialSortBulkSplit.java index f2b39179..f0a85de7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/SpatialSortBulkSplit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/bulk/SpatialSortBulkSplit.java @@ -47,6 +47,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * @apiviz.composedOf SpatialSorter * * @author Erich Schubert + * @since 0.5.0 */ @Reference(title = "On packing R-trees", authors = "Kamel, I. and Faloutsos, C.", booktitle = "Proc. of the second international conference on Information and knowledge management", url = "http://dx.doi.org/10.1145/170088.170403") public class SpatialSortBulkSplit extends AbstractBulkSplit { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/ApproximativeLeastOverlapInsertionStrategy.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/ApproximativeLeastOverlapInsertionStrategy.java index 2897c5a4..9eab98d4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/ApproximativeLeastOverlapInsertionStrategy.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/ApproximativeLeastOverlapInsertionStrategy.java @@ -52,6 +52,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.DoubleIntPair; * @author Erich Schubert * @author Franz Graf * @author Marisa Thoma + * @since 0.5.0 */ @Reference(authors = "N. Beckmann, H.-P. Kriegel, R. Schneider, B. Seeger", title = "The R*-tree: an efficient and robust access method for points and rectangles", booktitle = "Proceedings of the 1990 ACM SIGMOD International Conference on Management of Data, Atlantic City, NJ, May 23-25, 1990", url = "http://dx.doi.org/10.1145/93597.98741") public class ApproximativeLeastOverlapInsertionStrategy extends LeastOverlapInsertionStrategy { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/CombinedInsertionStrategy.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/CombinedInsertionStrategy.java index 04221d8b..f53092b8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/CombinedInsertionStrategy.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/CombinedInsertionStrategy.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ClassParameter; * </p> * * @author Erich Schubert + * @since 0.5.0 */ @Reference(authors = "N. Beckmann, H.-P. Kriegel, R. Schneider, B. Seeger", title = "The R*-tree: an efficient and robust access method for points and rectangles", booktitle = "Proceedings of the 1990 ACM SIGMOD International Conference on Management of Data, Atlantic City, NJ, May 23-25, 1990", url = "http://dx.doi.org/10.1145/93597.98741") public class CombinedInsertionStrategy implements InsertionStrategy { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/InsertionStrategy.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/InsertionStrategy.java index 552206bf..b564ad1d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/InsertionStrategy.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/InsertionStrategy.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.ArrayAdapter; * RTree insertion strategy interface. * * @author Erich Schubert + * @since 0.5.0 */ public interface InsertionStrategy { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/LeastEnlargementInsertionStrategy.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/LeastEnlargementInsertionStrategy.java index ef17e816..fdad1bda 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/LeastEnlargementInsertionStrategy.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/LeastEnlargementInsertionStrategy.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.5.0 */ @Reference(authors = "Antonin Guttman", title = "R-Trees: A Dynamic Index Structure For Spatial Searching", booktitle = "Proceedings of the 1984 ACM SIGMOD international conference on Management of data", url = "http://dx.doi.org/10.1145/971697.602266") public class LeastEnlargementInsertionStrategy implements InsertionStrategy { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/LeastEnlargementWithAreaInsertionStrategy.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/LeastEnlargementWithAreaInsertionStrategy.java index 9c90169d..70543731 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/LeastEnlargementWithAreaInsertionStrategy.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/LeastEnlargementWithAreaInsertionStrategy.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.5.0 */ @Reference(authors = "N. Beckmann, H.-P. Kriegel, R. Schneider, B. Seeger", title = "The R*-tree: an efficient and robust access method for points and rectangles", booktitle = "Proceedings of the 1990 ACM SIGMOD International Conference on Management of Data, Atlantic City, NJ, May 23-25, 1990", url = "http://dx.doi.org/10.1145/93597.98741") public class LeastEnlargementWithAreaInsertionStrategy implements InsertionStrategy { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/LeastOverlapInsertionStrategy.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/LeastOverlapInsertionStrategy.java index 794f32a1..69e68446 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/LeastOverlapInsertionStrategy.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/insert/LeastOverlapInsertionStrategy.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.5.0 */ @Reference(authors = "N. Beckmann, H.-P. Kriegel, R. Schneider, B. Seeger", title = "The R*-tree: an efficient and robust access method for points and rectangles", booktitle = "Proceedings of the 1990 ACM SIGMOD International Conference on Management of Data, Atlantic City, NJ, May 23-25, 1990", url = "http://dx.doi.org/10.1145/93597.98741") public class LeastOverlapInsertionStrategy implements InsertionStrategy { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/overflow/LimitedReinsertOverflowTreatment.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/overflow/LimitedReinsertOverflowTreatment.java index 23db999c..2023fb44 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/overflow/LimitedReinsertOverflowTreatment.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/overflow/LimitedReinsertOverflowTreatment.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * reinsertions to happen only once per level. * * @author Erich Schubert + * @since 0.5.0 */ @Reference(authors = "N. Beckmann, H.-P. Kriegel, R. Schneider, B. Seeger", title = "The R*-tree: an efficient and robust access method for points and rectangles", booktitle = "Proceedings of the 1990 ACM SIGMOD International Conference on Management of Data, Atlantic City, NJ, May 23-25, 1990", url = "http://dx.doi.org/10.1145/93597.98741") public class LimitedReinsertOverflowTreatment implements OverflowTreatment { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/overflow/OverflowTreatment.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/overflow/OverflowTreatment.java index 8c9fc962..4c275503 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/overflow/OverflowTreatment.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/overflow/OverflowTreatment.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.AbstractRStarTreeNod * Reinsertion strategy to resolve overflows in the RStarTree. * * @author Erich Schubert + * @since 0.5.0 */ public interface OverflowTreatment { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/overflow/SplitOnlyOverflowTreatment.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/overflow/SplitOnlyOverflowTreatment.java index 9670daa1..d6470884 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/overflow/SplitOnlyOverflowTreatment.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/overflow/SplitOnlyOverflowTreatment.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Always split, as in the original R-Tree * * @author Erich Schubert + * @since 0.5.0 */ public class SplitOnlyOverflowTreatment implements OverflowTreatment { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/reinsert/AbstractPartialReinsert.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/reinsert/AbstractPartialReinsert.java index 9f65bdd8..13cf20e4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/reinsert/AbstractPartialReinsert.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/reinsert/AbstractPartialReinsert.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * parameter to partially reinsert entries. * * @author Erich Schubert + * @since 0.5.0 */ public abstract class AbstractPartialReinsert implements ReinsertStrategy { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/reinsert/CloseReinsert.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/reinsert/CloseReinsert.java index 2021b117..ae043992 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/reinsert/CloseReinsert.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/reinsert/CloseReinsert.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.DoubleIntPair; * The strategy preferred by the R*-Tree * * @author Erich Schubert + * @since 0.5.0 */ @Reference(authors = "N. Beckmann, H.-P. Kriegel, R. Schneider, B. Seeger", // title = "The R*-tree: an efficient and robust access method for points and rectangles", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/reinsert/FarReinsert.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/reinsert/FarReinsert.java index 52241deb..40b7b894 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/reinsert/FarReinsert.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/reinsert/FarReinsert.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.DoubleIntPair; * Alternative strategy mentioned in the R*-tree * * @author Erich Schubert + * @since 0.5.0 */ @Reference(authors = "N. Beckmann, H.-P. Kriegel, R. Schneider, B. Seeger", // title = "The R*-tree: an efficient and robust access method for points and rectangles", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/reinsert/ReinsertStrategy.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/reinsert/ReinsertStrategy.java index c4650b89..cb63a3d9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/reinsert/ReinsertStrategy.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/reinsert/ReinsertStrategy.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.ArrayAdapter; * Reinsertion strategy to resolve overflows in the RStarTree. * * @author Erich Schubert + * @since 0.5.0 */ public interface ReinsertStrategy { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/AngTanLinearSplit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/AngTanLinearSplit.java index 73e3a8e5..08b40acc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/AngTanLinearSplit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/AngTanLinearSplit.java @@ -50,6 +50,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.5.0 */ @Reference(authors = "C. H. Ang and T. C. Tan", title = "New linear node splitting algorithm for R-trees", booktitle = "Proceedings of the 5th International Symposium on Advances in Spatial Databases", url = "http://dx.doi.org/10.1007/3-540-63238-7_38") public class AngTanLinearSplit implements SplitStrategy { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/GreeneSplit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/GreeneSplit.java index f6d15f18..e415bb35 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/GreeneSplit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/GreeneSplit.java @@ -50,6 +50,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.DoubleIntPair; * </p> * * @author Erich Schubert + * @since 0.5.0 */ @Reference(authors = "Diane Greene", title = "An implementation and performance analysis of spatial data access methods", booktitle = "Proceedings of the Fifth International Conference on Data Engineering", url = "http://dx.doi.org/10.1109/ICDE.1989.47268") public class GreeneSplit implements SplitStrategy { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/RTreeLinearSplit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/RTreeLinearSplit.java index c7ec5412..6849207f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/RTreeLinearSplit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/RTreeLinearSplit.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.5.0 */ @Reference(authors = "Antonin Guttman", title = "R-Trees: A Dynamic Index Structure For Spatial Searching", booktitle = "Proceedings of the 1984 ACM SIGMOD international conference on Management of data", url = "http://dx.doi.org/10.1145/971697.602266") public class RTreeLinearSplit implements SplitStrategy { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/RTreeQuadraticSplit.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/RTreeQuadraticSplit.java index 351c97f5..16037a4a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/RTreeQuadraticSplit.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/RTreeQuadraticSplit.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.5.0 */ @Reference(authors = "Antonin Guttman", title = "R-Trees: A Dynamic Index Structure For Spatial Searching", booktitle = "Proceedings of the 1984 ACM SIGMOD international conference on Management of data", url = "http://dx.doi.org/10.1145/971697.602266") public class RTreeQuadraticSplit implements SplitStrategy { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/SplitStrategy.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/SplitStrategy.java index 080da97a..f63f89dd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/SplitStrategy.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/SplitStrategy.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.ArrayAdapter; * Generic interface for split strategies. * * @author Erich Schubert + * @since 0.4.0 */ public interface SplitStrategy { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/TopologicalSplitter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/TopologicalSplitter.java index d1808962..5ab9b73b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/TopologicalSplitter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/strategies/split/TopologicalSplitter.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.data.HyperBoundingBox; import de.lmu.ifi.dbs.elki.data.ModifiableHyperBoundingBox; import de.lmu.ifi.dbs.elki.data.spatial.SpatialComparable; import de.lmu.ifi.dbs.elki.data.spatial.SpatialUtil; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.BitsUtil; import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.ArrayAdapter; import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; @@ -39,10 +40,12 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.DoubleIntPair; * Encapsulates the required parameters for a topological split of a R*-Tree. * * @author Elke Achtert + * @since 0.4.0 * * @apiviz.has Split */ @Reference(authors = "N. Beckmann, H.-P. Kriegel, R. Schneider, B. Seeger", title = "The R*-tree: an efficient and robust access method for points and rectangles", booktitle = "Proceedings of the 1990 ACM SIGMOD International Conference on Management of Data, Atlantic City, NJ, May 23-25, 1990", url = "http://dx.doi.org/10.1145/93597.98741") +@Alias("de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.util.TopologicalSplitter") public class TopologicalSplitter implements SplitStrategy { /** * Static instance. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/util/NodeArrayAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/util/NodeArrayAdapter.java index f0f887a4..973edf86 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/util/NodeArrayAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/tree/spatial/rstarvariants/util/NodeArrayAdapter.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.ArrayAdapter; * Access the entries of a node as array-like. * * @author Erich Schubert + * @since 0.4.0 */ public class NodeArrayAdapter implements ArrayAdapter<SpatialEntry, AbstractNode<? extends SpatialEntry>> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/DAFile.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/DAFile.java index 17101dec..9c3e4b1b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/DAFile.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/DAFile.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteArrayUtil; * * @author Thomas Bernecker * @author Erich Schubert + * @since 0.5.0 */ @Reference(authors = "Hans-Peter Kriegel, Peer Kröger, Matthias Schubert, Ziyue Zhu", title = "Efficient Query Processing in Arbitrary Subspaces Using Vector Approximations", booktitle = "Proc. 18th Int. Conf. on Scientific and Statistical Database Management (SSDBM 06), Wien, Austria, 2006", url = "http://dx.doi.org/10.1109/SSDBM.2006.23") public class DAFile { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/PartialVAFile.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/PartialVAFile.java index fdc262d0..c0d1945d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/PartialVAFile.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/PartialVAFile.java @@ -82,6 +82,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.DoubleObjPair; * * @author Thomas Bernecker * @author Erich Schubert + * @since 0.5.0 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/VAFile.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/VAFile.java index 91516e97..2933a077 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/VAFile.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/VAFile.java @@ -71,6 +71,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * * @author Thomas Bernecker * @author Erich Schubert + * @since 0.5.0 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/VALPNormDistance.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/VALPNormDistance.java index ae341e4b..76f2448c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/VALPNormDistance.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/VALPNormDistance.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.data.NumberVector; * Lp-Norm distance function for partially computed objects. * * @author Erich Schubert + * @since 0.5.0 */ public class VALPNormDistance { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/VectorApproximation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/VectorApproximation.java index 9913cade..5025d415 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/VectorApproximation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/index/vafile/VectorApproximation.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteArrayUtil; * * @author Thomas Bernecker * @author Erich Schubert + * @since 0.5.0 */ public class VectorApproximation { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/CLISmartHandler.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/CLISmartHandler.java index f434cee4..de496674 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/CLISmartHandler.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/CLISmartHandler.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.logging.progress.ProgressTracker; * Handler that handles output to the console with clever formatting. * * @author Erich Schubert + * @since 0.2 * * @apiviz.composedOf ProgressTracker * @apiviz.uses LogRecord oneway - - processes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/ELKILogRecord.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/ELKILogRecord.java index c181e449..87de3faa 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/ELKILogRecord.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/ELKILogRecord.java @@ -27,9 +27,6 @@ import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; -import de.lmu.ifi.dbs.elki.application.AbstractApplication; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.AbstractParameterization; - /** * Base {@link LogRecord} class used in ELKI. * @@ -37,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.AbstractPar * additional classes when determining the 'origin' of a log message. * * @author Erich Schubert + * @since 0.2 */ public class ELKILogRecord extends LogRecord { /** @@ -52,7 +50,15 @@ public class ELKILogRecord extends LogRecord { /** * Classes to ignore when finding the relevant caller. */ - public static final String[] IGNORE_CLASSES = { Logger.class.getCanonicalName(), Logging.class.getCanonicalName(), LoggingUtil.class.getCanonicalName(), ELKILogRecord.class.getCanonicalName(), AbstractParameterization.class.getCanonicalName(), AbstractApplication.class.getCanonicalName() }; + public static final String[] IGNORE_CLASSES = { // + Logger.class.getCanonicalName(), // + Logging.class.getCanonicalName(), // + LoggingUtil.class.getCanonicalName(), // + ELKILogRecord.class.getCanonicalName(), // + // Avoid dependencies on these packages: + "de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.AbstractParameterization", // + "de.lmu.ifi.dbs.elki.application.AbstractApplication", // + }; /** * Name of this class. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/ErrorFormatter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/ErrorFormatter.java index 2344669e..376b3b95 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/ErrorFormatter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/ErrorFormatter.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.logging.progress.ProgressLogRecord; * Format a log record for error output, including a stack trace if available. * * @author Erich Schubert + * @since 0.5.0 */ // TODO: make more configurable and handle suppressed exceptions public class ErrorFormatter extends Formatter { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/Logging.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/Logging.java index ca59ad18..a57dd4cc 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/Logging.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/Logging.java @@ -53,6 +53,7 @@ import de.lmu.ifi.dbs.elki.logging.statistics.UnsynchronizedLongCounter; * {@link ELKILogRecord}! * * @author Erich Schubert + * @since 0.2 * * @apiviz.uses LoggingConfiguration * @apiviz.uses ELKILogRecord oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/LoggingConfiguration.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/LoggingConfiguration.java index 86f7c528..c2d200ea 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/LoggingConfiguration.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/LoggingConfiguration.java @@ -24,6 +24,7 @@ package de.lmu.ifi.dbs.elki.logging; */ import java.io.File; +import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.InputStream; import java.util.Properties; @@ -32,12 +33,12 @@ import java.util.logging.LogManager; import java.util.logging.Logger; import de.lmu.ifi.dbs.elki.logging.Logging.Level; -import de.lmu.ifi.dbs.elki.utilities.FileUtil; /** * Facility for configuration of logging. * * @author Erich Schubert + * @since 0.2 */ public final class LoggingConfiguration { /** @@ -107,36 +108,62 @@ public final class LoggingConfiguration { LogManager logManager = LogManager.getLogManager(); Logger logger = Logger.getLogger(LoggingConfiguration.class.getName()); // allow null as package name. - if (pkg == null) { + if(pkg == null) { pkg = ""; } // Load logging configuration from current directory String cfgfile = name; - if (new File(name).exists()) { + if(new File(name).exists()) { cfgfile = name; - } else { + } + else { // Fall back to full path / resources. cfgfile = pkg.replace('.', File.separatorChar) + File.separatorChar + name; } try { - InputStream cfgdata = FileUtil.openSystemFile(cfgfile); + InputStream cfgdata = openSystemFile(cfgfile); logManager.readConfiguration(cfgdata); // also load as properties for us, to get debug flag. - InputStream cfgdata2 = FileUtil.openSystemFile(cfgfile); + InputStream cfgdata2 = openSystemFile(cfgfile); Properties cfgprop = new Properties(); cfgprop.load(cfgdata2); DEBUG = Boolean.parseBoolean(cfgprop.getProperty("debug")); logger.info("Logging configuration read."); - } catch (FileNotFoundException e) { + } + catch(FileNotFoundException e) { logger.log(Level.SEVERE, "Could not find logging configuration file: " + cfgfile, e); - } catch (Exception e) { + } + catch(Exception e) { logger.log(Level.SEVERE, "Failed to configure logging from file: " + cfgfile, e); } } /** + * Private copy from FileUtil, to avoid cross-dependencies. Try to open a + * file, first trying the file system, then falling back to the classpath. + * + * @param filename File name in system notation + * @return Input stream + * @throws FileNotFoundException When no file was found. + */ + private static InputStream openSystemFile(String filename) throws FileNotFoundException { + try { + return new FileInputStream(filename); + } + catch(FileNotFoundException e) { + // try with classloader + String resname = filename.replace(File.separatorChar, '/'); + InputStream result = ClassLoader.getSystemResourceAsStream(resname); + if(result == null) { + throw e; + } + return result; + } + } + + /** * Assert that logging was configured. */ public static void assertConfigured() { @@ -149,23 +176,24 @@ public final class LoggingConfiguration { * @param verbose verbosity level. */ public static void setVerbose(java.util.logging.Level verbose) { - if (verbose.intValue() <= Level.VERBOSE.intValue()) { + if(verbose.intValue() <= Level.VERBOSE.intValue()) { // decrease to VERBOSE if it was higher, otherwise further to VERYVERBOSE - if (LOGGER_GLOBAL_TOP.getLevel() == null || LOGGER_GLOBAL_TOP.getLevel().intValue() > verbose.intValue()) { + if(LOGGER_GLOBAL_TOP.getLevel() == null || LOGGER_GLOBAL_TOP.getLevel().intValue() > verbose.intValue()) { LOGGER_GLOBAL_TOP.setLevel(verbose); } - if (LOGGER_ELKI_TOP.getLevel() == null || LOGGER_ELKI_TOP.getLevel().intValue() > verbose.intValue()) { + if(LOGGER_ELKI_TOP.getLevel() == null || LOGGER_ELKI_TOP.getLevel().intValue() > verbose.intValue()) { LOGGER_ELKI_TOP.setLevel(verbose); } - } else { + } + else { // re-increase to given level if it was verbose or "very verbose". - if (LOGGER_GLOBAL_TOP.getLevel() != null && (// + if(LOGGER_GLOBAL_TOP.getLevel() != null && (// Level.VERBOSE.equals(LOGGER_GLOBAL_TOP.getLevel()) || // Level.VERYVERBOSE.equals(LOGGER_GLOBAL_TOP.getLevel()) // )) { LOGGER_GLOBAL_TOP.setLevel(verbose); } - if (LOGGER_ELKI_TOP.getLevel() != null && (// + if(LOGGER_ELKI_TOP.getLevel() != null && (// Level.VERBOSE.equals(LOGGER_ELKI_TOP.getLevel()) || // Level.VERYVERBOSE.equals(LOGGER_ELKI_TOP.getLevel()) // )) { @@ -179,13 +207,13 @@ public final class LoggingConfiguration { */ public static void setStatistics() { // decrease to INFO if it was higher - if (LOGGER_GLOBAL_TOP.getLevel() == null || LOGGER_GLOBAL_TOP.getLevel().intValue() > Level.STATISTICS.intValue()) { + if(LOGGER_GLOBAL_TOP.getLevel() == null || LOGGER_GLOBAL_TOP.getLevel().intValue() > Level.STATISTICS.intValue()) { LOGGER_GLOBAL_TOP.setLevel(Level.STATISTICS); } - if (LOGGER_ELKI_TOP.getLevel() == null || LOGGER_ELKI_TOP.getLevel().intValue() > Level.STATISTICS.intValue()) { + if(LOGGER_ELKI_TOP.getLevel() == null || LOGGER_ELKI_TOP.getLevel().intValue() > Level.STATISTICS.intValue()) { LOGGER_ELKI_TOP.setLevel(Level.STATISTICS); } - if (LOGGER_TIME_TOP.getLevel() == null || LOGGER_TIME_TOP.getLevel().intValue() > Level.STATISTICS.intValue()) { + if(LOGGER_TIME_TOP.getLevel() == null || LOGGER_TIME_TOP.getLevel().intValue() > Level.STATISTICS.intValue()) { LOGGER_TIME_TOP.setLevel(Level.STATISTICS); } } @@ -209,8 +237,8 @@ public final class LoggingConfiguration { */ public static void replaceDefaultHandler(Handler handler) { Logger rootlogger = LogManager.getLogManager().getLogger(""); - for (Handler h : rootlogger.getHandlers()) { - if (h instanceof CLISmartHandler) { + for(Handler h : rootlogger.getHandlers()) { + if(h instanceof CLISmartHandler) { rootlogger.removeHandler(h); } } @@ -226,7 +254,7 @@ public final class LoggingConfiguration { */ public static void setLevelFor(String pkg, String level) throws IllegalArgumentException { Logger logr = Logger.getLogger(pkg); - if (logr == null) { + if(logr == null) { throw new IllegalArgumentException("Logger not found."); } // Can also throw an IllegalArgumentException diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/LoggingUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/LoggingUtil.java index 5f9cb39b..576fa817 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/LoggingUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/LoggingUtil.java @@ -27,9 +27,6 @@ import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.StringParameter; - /** * This final class contains some static convenience methods for logging. * @@ -38,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.StringParameter; * loop constructs. * * @author Erich Schubert + * @since 0.2 * * @apiviz.uses ELKILogRecord oneway - - «create» */ @@ -177,38 +175,4 @@ public final class LoggingUtil { return null; } - - /** - * Parse the option string to configure logging. - * - * @param param Parameter to process. - * - * @throws WrongParameterValueException On parsing errors - */ - public static final void parseDebugParameter(StringParameter param) throws WrongParameterValueException { - String[] opts = param.getValue().split(","); - for(String opt : opts) { - try { - String[] chunks = opt.split("="); - if(chunks.length == 1) { - try { - Level level = Level.parse(chunks[0]); - LoggingConfiguration.setDefaultLevel(level); - } - catch(IllegalArgumentException e) { - LoggingConfiguration.setLevelFor(chunks[0], Level.FINEST.getName()); - } - } - else if(chunks.length == 2) { - LoggingConfiguration.setLevelFor(chunks[0], chunks[1]); - } - else { - throw new WrongParameterValueException(param, param.getValue(), "More than one '=' in debug parameter."); - } - } - catch(IllegalArgumentException e) { - throw (new WrongParameterValueException(param, param.getValue(), "Could not process value.", e)); - } - } - } }
\ No newline at end of file diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/MessageFormatter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/MessageFormatter.java index e0074f4f..5dc87173 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/MessageFormatter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/MessageFormatter.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.logging.progress.ProgressLogRecord; * origin information. Usually, the formatter will try to ensure a newline at the end. * * @author Arthur Zimek + * @since 0.2 */ public class MessageFormatter extends Formatter { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/OutputStreamLogger.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/OutputStreamLogger.java index adee9b1e..0b48093c 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/OutputStreamLogger.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/OutputStreamLogger.java @@ -37,6 +37,7 @@ import java.nio.charset.CharsetEncoder; * This is meant to wrap logging output to the console. * * @author Erich Schubert + * @since 0.2 */ public class OutputStreamLogger extends OutputStreamWriter { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/AbstractProgress.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/AbstractProgress.java index 526dac3f..7171c668 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/AbstractProgress.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/AbstractProgress.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * Abstract base class for FiniteProgress objects. * * @author Erich Schubert + * @since 0.2 */ public abstract class AbstractProgress implements Progress { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/FiniteProgress.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/FiniteProgress.java index 2b1f1018..014535ee 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/FiniteProgress.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/FiniteProgress.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * progress suitable as a message for printing to the command line interface. * * @author Arthur Zimek + * @since 0.2 */ public class FiniteProgress extends AbstractProgress { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/IndefiniteProgress.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/IndefiniteProgress.java index eeebf4bb..34969e31 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/IndefiniteProgress.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/IndefiniteProgress.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * Progress class without a fixed destination value. * * @author Erich Schubert + * @since 0.2 */ public class IndefiniteProgress extends AbstractProgress { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/MutableProgress.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/MutableProgress.java index 74f5d4f0..47c426f7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/MutableProgress.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/MutableProgress.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * Progress class with a moving target. * * @author Erich Schubert + * @since 0.2 */ public class MutableProgress extends AbstractProgress { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/Progress.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/Progress.java index 25e5129a..8d41a59d 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/Progress.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/Progress.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.logging.progress; * Generic Progress logging interface. * * @author Erich Schubert + * @since 0.2 */ public interface Progress { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/ProgressLogRecord.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/ProgressLogRecord.java index cea0ecf1..773b4175 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/ProgressLogRecord.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/ProgressLogRecord.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.logging.ELKILogRecord; * Log record for progress messages. * * @author Erich Schubert + * @since 0.3 * * @apiviz.has Progress */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/ProgressTracker.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/ProgressTracker.java index 04f0c430..64e47019 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/ProgressTracker.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/ProgressTracker.java @@ -33,6 +33,7 @@ import java.util.List; * Class to keep track of "alive" progresses. * * @author Erich Schubert + * @since 0.3 * * @apiviz.uses Progress oneway - - tracks */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/StepProgress.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/StepProgress.java index ff01d027..1532bba6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/StepProgress.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/progress/StepProgress.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * This progress class is used for multi-step processing. * * @author Erich Schubert + * @since 0.4.0 */ public class StepProgress extends FiniteProgress { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/AbstractStatistic.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/AbstractStatistic.java index 72b477ed..bcd7d101 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/AbstractStatistic.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/AbstractStatistic.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.logging.statistics; * Abstract base class for statistics tracking. * * @author Erich Schubert + * @since 0.3 */ public abstract class AbstractStatistic implements Statistic { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/AtomicLongCounter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/AtomicLongCounter.java index dfdc9e7f..3e9e88da 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/AtomicLongCounter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/AtomicLongCounter.java @@ -29,6 +29,7 @@ import java.util.concurrent.atomic.AtomicLong; * Class to count events in a thread-safe counter. * * @author Erich Schubert + * @since 0.5.0 */ public class AtomicLongCounter extends AbstractStatistic implements Counter { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/Counter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/Counter.java index 21692d54..91b4fc1d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/Counter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/Counter.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.logging.statistics; * Simple statistic by counting. For example: invocations of a method. * * @author Erich Schubert + * @since 0.2 */ public interface Counter extends Statistic { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/DoubleStatistic.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/DoubleStatistic.java index d3257edd..89b8229e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/DoubleStatistic.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/DoubleStatistic.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.logging.statistics; * Trivial double-valued statistic. * * @author Erich Schubert + * @since 0.5.0 */ public class DoubleStatistic extends AbstractStatistic { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/Duration.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/Duration.java index 1b8769e6..30162d70 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/Duration.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/Duration.java @@ -29,6 +29,7 @@ package de.lmu.ifi.dbs.elki.logging.statistics; * TODO: add support for different time units? * * @author Erich Schubert + * @since 0.2 */ public interface Duration extends Statistic { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/LongStatistic.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/LongStatistic.java index 409b17f6..ffb70f3c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/LongStatistic.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/LongStatistic.java @@ -4,7 +4,7 @@ package de.lmu.ifi.dbs.elki.logging.statistics; This file is part of ELKI: Environment for Developing KDD-Applications Supported by Index-Structures - Copyright (C) 2015 + Copyright (C) 2016 Ludwig-Maximilians-Universität München Lehr- und Forschungseinheit für Datenbanksysteme ELKI Development Team @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.logging.statistics; * Trivial long-valued statistic. * * @author Erich Schubert + * @since 0.5.0 */ public class LongStatistic extends AbstractStatistic { /** @@ -63,6 +64,15 @@ public class LongStatistic extends AbstractStatistic { this.value = value; } + /** + * Increment counter. + * + * @param inc Increment + */ + public void increment(long inc) { + this.value += inc; + } + @Override public String formatValue() { return Long.toString(value); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/MillisTimeDuration.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/MillisTimeDuration.java index d6637d52..2a268fd8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/MillisTimeDuration.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/MillisTimeDuration.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.logging.statistics; * Class that tracks the runtime of a task with {@code System.nanoTime()} * * @author Erich Schubert + * @since 0.5.0 */ public class MillisTimeDuration extends AbstractStatistic implements Duration { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/NanoDuration.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/NanoDuration.java index ca09324b..03a9f9eb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/NanoDuration.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/NanoDuration.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.logging.statistics; * Class that tracks the runtime of a task with {@code System.nanoTime()} * * @author Erich Schubert + * @since 0.5.0 */ public class NanoDuration extends AbstractStatistic implements Duration { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/Statistic.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/Statistic.java index 3a826ccf..5a256e24 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/Statistic.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/Statistic.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.logging.statistics; * Abstract base interface for statistics tracking. * * @author Erich Schubert + * @since 0.4.0 */ public interface Statistic { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/StringStatistic.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/StringStatistic.java index af7b12d8..81ec6ff1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/StringStatistic.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/StringStatistic.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.logging.statistics; * Trivial string based statistic. * * @author Erich Schubert + * @since 0.4.0 */ public class StringStatistic extends AbstractStatistic { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/UnsynchronizedLongCounter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/UnsynchronizedLongCounter.java index 69164053..3cd7ee54 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/UnsynchronizedLongCounter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/logging/statistics/UnsynchronizedLongCounter.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.logging.statistics; * Class to count events in a thread-safe counter. * * @author Erich Schubert + * @since 0.5.0 */ public class UnsynchronizedLongCounter extends AbstractStatistic implements Counter { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/DoubleMinMax.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/DoubleMinMax.java index 7fc67833..e65957d8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/DoubleMinMax.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/DoubleMinMax.java @@ -29,6 +29,7 @@ import java.util.Collection; * Class to find the minimum and maximum double values in data. * * @author Erich Schubert + * @since 0.2 */ public class DoubleMinMax { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/IntegerMinMax.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/IntegerMinMax.java index c80b0516..12b83945 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/IntegerMinMax.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/IntegerMinMax.java @@ -30,6 +30,7 @@ import java.util.Collection; * * @author Erich Schubert * @author Arthur Zimek + * @since 0.2 */ public class IntegerMinMax { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/MathUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/MathUtil.java index deb3ed2c..2c9f0301 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/MathUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/MathUtil.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; * * @author Arthur Zimek * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark */ @@ -1046,16 +1047,15 @@ public final class MathUtil { return Math.pow(x, p); } double tmp = x, ret = (p & 1) == 1 ? x : 1.; - p >>= 1; while(true) { + tmp *= tmp; + p >>= 1; if(p == 1) { return ret * tmp; } if((p & 1) != 0) { ret *= tmp; } - tmp *= tmp; - p >>= 1; } } @@ -1072,16 +1072,15 @@ public final class MathUtil { return (int) Math.pow(x, p); } int tmp = x, ret = (p & 1) == 1 ? x : 1; - p >>= 1; while(true) { + tmp *= tmp; + p >>= 1; if(p == 1) { return ret * tmp; } if((p & 1) != 0) { ret *= tmp; } - tmp *= tmp; - p >>= 1; } } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/Mean.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/Mean.java index da8bde38..0eb7f3f0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/Mean.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/Mean.java @@ -49,6 +49,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.4.0 */ @Reference(authors = "B. P. Welford", // title = "Note on a method for calculating corrected sums of squares and products", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/MeanVariance.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/MeanVariance.java index 5a1cd7e6..6b5f893d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/MeanVariance.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/MeanVariance.java @@ -56,6 +56,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * </p> * * @author Erich Schubert + * @since 0.2 */ @Reference(authors = "B. P. Welford", // title = "Note on a method for calculating corrected sums of squares and products", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/MeanVarianceMinMax.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/MeanVarianceMinMax.java index fcd96f02..46ad82e0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/MeanVarianceMinMax.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/MeanVarianceMinMax.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * Class collecting mean, variance, minimum and maximum statistics. * * @author Erich Schubert + * @since 0.5.0 */ public class MeanVarianceMinMax extends MeanVariance { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/PearsonCorrelation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/PearsonCorrelation.java index b2821bdd..9bfe38ae 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/PearsonCorrelation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/PearsonCorrelation.java @@ -31,6 +31,7 @@ package de.lmu.ifi.dbs.elki.math; * slightly more memory (by using arrays) but essentially does the same. * * @author Erich Schubert + * @since 0.5.0 */ public class PearsonCorrelation { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/Primes.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/Primes.java index 2a717634..adebf820 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/Primes.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/Primes.java @@ -31,6 +31,7 @@ package de.lmu.ifi.dbs.elki.math; * classes. * * @author Erich Schubert + * @since 0.5.5 */ public final class Primes { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/SinCosTable.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/SinCosTable.java index 842f7152..f224a8b3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/SinCosTable.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/SinCosTable.java @@ -33,6 +33,7 @@ package de.lmu.ifi.dbs.elki.math; * TODO: add caching * * @author Erich Schubert + * @since 0.5.5 */ public abstract class SinCosTable { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/StatisticalMoments.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/StatisticalMoments.java index df188a7f..f9146314 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/StatisticalMoments.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/StatisticalMoments.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * </p> * * @author Erich Schubert + * @since 0.6.0 */ @Reference(authors = "T. B. Terriberry", title = "Computing Higher-Order Moments Online", booktitle = "Online - Technical Note", url = "http://people.xiph.org/~tterribe/notes/homs.html") public class StatisticalMoments extends MeanVarianceMinMax { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/CovarianceDimensionSimilarity.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/CovarianceDimensionSimilarity.java index 08f4ad86..10c0713e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/CovarianceDimensionSimilarity.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/CovarianceDimensionSimilarity.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Class to compute the dimension similarity based on covariances. * * @author Erich Schubert + * @since 0.5.5 */ public class CovarianceDimensionSimilarity implements DimensionSimilarity<NumberVector> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/DimensionSimilarity.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/DimensionSimilarity.java index 7e772838..1bc08dbe 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/DimensionSimilarity.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/DimensionSimilarity.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * dimensions in parallel coordinate plots. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.uses DimensionSimilarityMatrix - - «writes» * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/DimensionSimilarityMatrix.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/DimensionSimilarityMatrix.java index 89d0d4eb..6e57ad00 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/DimensionSimilarityMatrix.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/DimensionSimilarityMatrix.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Matrix; * Class representing a similarity matrix between dimensions. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.uses PrimsMinimumSpanningTree */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/HSMDimensionSimilarity.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/HSMDimensionSimilarity.java index 4627c785..e4e55b9b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/HSMDimensionSimilarity.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/HSMDimensionSimilarity.java @@ -49,6 +49,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * @author Erich Schubert * @author Robert Rödler + * @since 0.5.5 */ @Reference(authors = "A. Tatu, G. Albuquerque, M. Eisemann, P. Bak, H. Theisel, M. A. Magnor, and D. A. Keim", // title = "Automated Analytical Methods to Support Visual Exploration of High-Dimensional Data", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/HiCSDimensionSimilarity.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/HiCSDimensionSimilarity.java index 1c024fc8..0e0ddcaa 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/HiCSDimensionSimilarity.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/HiCSDimensionSimilarity.java @@ -70,6 +70,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * * @author Erich Schubert * @author Robert Rödler + * @since 0.5.5 */ @Reference(authors = "Elke Achtert, Hans-Peter Kriegel, Erich Schubert, Arthur Zimek", // title = "Interactive Data Mining with 3D-Parallel-Coordinate-Trees", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/MCEDimensionSimilarity.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/MCEDimensionSimilarity.java index 048f960d..88adbf9d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/MCEDimensionSimilarity.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/MCEDimensionSimilarity.java @@ -52,6 +52,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.5.5 */ @Reference(authors = "D. Guo", // title = "Coordinating computational and visual approaches for interactive feature selection and multivariate clustering", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/SURFINGDimensionSimilarity.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/SURFINGDimensionSimilarity.java index d7aa8ca6..4474239c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/SURFINGDimensionSimilarity.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/SURFINGDimensionSimilarity.java @@ -62,6 +62,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * @author Robert Rödler * @author Erich Schubert + * @since 0.5.5 * * @apiviz.uses SubspaceEuclideanDistanceFunction */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/SlopeDimensionSimilarity.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/SlopeDimensionSimilarity.java index eeb7906d..55205fcc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/SlopeDimensionSimilarity.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/SlopeDimensionSimilarity.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * @author Erich Schubert * @author Robert Rödler + * @since 0.5.5 */ @Reference(authors = "Elke Achtert, Hans-Peter Kriegel, Erich Schubert, Arthur Zimek", // title = "Interactive Data Mining with 3D-Parallel-Coordinate-Trees", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/SlopeInversionDimensionSimilarity.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/SlopeInversionDimensionSimilarity.java index 52b73350..aee0a9db 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/SlopeInversionDimensionSimilarity.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/dimensionsimilarity/SlopeInversionDimensionSimilarity.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * @author Erich Schubert * @author Robert Rödler + * @since 0.5.5 */ @Reference(authors = "Elke Achtert, Hans-Peter Kriegel, Erich Schubert, Arthur Zimek", // title = "Interactive Data Mining with 3D-Parallel-Coordinate-Trees", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/AbstractEarthModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/AbstractEarthModel.java index 34652bd4..9122755b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/AbstractEarthModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/AbstractEarthModel.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * Abstract base class for earth models with shared glue code. * * @author Erich Schubert + * @since 0.6.0 */ public abstract class AbstractEarthModel implements EarthModel { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/Clarke1858SpheroidEarthModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/Clarke1858SpheroidEarthModel.java index 4bc5560e..186c3c3a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/Clarke1858SpheroidEarthModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/Clarke1858SpheroidEarthModel.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Flattening: 1 / 294.26068 * * @author Erich Schubert + * @since 0.3 */ @Alias({ "Clarke1858" }) public class Clarke1858SpheroidEarthModel extends AbstractEarthModel { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/Clarke1880SpheroidEarthModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/Clarke1880SpheroidEarthModel.java index b204c8c4..ef1a0d2d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/Clarke1880SpheroidEarthModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/Clarke1880SpheroidEarthModel.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Flattening: 1 / 293.465 * * @author Erich Schubert + * @since 0.3 */ @Alias({ "Clarke1880" }) public class Clarke1880SpheroidEarthModel extends AbstractEarthModel { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/EarthModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/EarthModel.java index 332ddf64..8eb697b0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/EarthModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/EarthModel.java @@ -28,6 +28,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; * API for handling different earth models. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.uses SphereUtil */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/GRS67SpheroidEarthModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/GRS67SpheroidEarthModel.java index d8468a6b..7770933f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/GRS67SpheroidEarthModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/GRS67SpheroidEarthModel.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Flattening: 1 / 298.25 * * @author Erich Schubert + * @since 0.3 */ @Alias({ "GRS67", "GRS-67" }) public class GRS67SpheroidEarthModel extends AbstractEarthModel { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/GRS80SpheroidEarthModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/GRS80SpheroidEarthModel.java index 591dd923..8d9b59a5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/GRS80SpheroidEarthModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/GRS80SpheroidEarthModel.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Flattening: 1 / 298.257222101 * * @author Erich Schubert + * @since 0.3 */ @Alias({ "GRS-80", "GRS80" }) public class GRS80SpheroidEarthModel extends AbstractEarthModel { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/SphereUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/SphereUtil.java index 8fcd4d97..98a674f0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/SphereUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/SphereUtil.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * * @author Erich Schubert * @author Niels Dörre + * @since 0.5.5 */ @Reference(authors = "Ed Williams", title = "Aviation Formulary", booktitle = "", url = "http://williams.best.vwh.net/avform.htm") public final class SphereUtil { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/SphericalCosineEarthModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/SphericalCosineEarthModel.java index c8cc694a..f4b51dca 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/SphericalCosineEarthModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/SphericalCosineEarthModel.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * faster but less accurate than the Haversince or Vincenty's formula. * * @author Erich Schubert + * @since 0.6.0 */ public class SphericalCosineEarthModel extends AbstractEarthModel { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/SphericalHaversineEarthModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/SphericalHaversineEarthModel.java index db0c39c9..56e581a9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/SphericalHaversineEarthModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/SphericalHaversineEarthModel.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * faster but less accurate than Vincenty's formula. * * @author Erich Schubert + * @since 0.6.0 */ public class SphericalHaversineEarthModel extends AbstractEarthModel { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/SphericalVincentyEarthModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/SphericalVincentyEarthModel.java index 7f627425..439b8e77 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/SphericalVincentyEarthModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/SphericalVincentyEarthModel.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * A simple spherical earth model using radius 6371009 m. * * @author Erich Schubert + * @since 0.6.0 */ public class SphericalVincentyEarthModel extends AbstractEarthModel { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/WGS72SpheroidEarthModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/WGS72SpheroidEarthModel.java index 43763328..3a23cf47 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/WGS72SpheroidEarthModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/WGS72SpheroidEarthModel.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Flattening: 1 / 298.26 * * @author Erich Schubert + * @since 0.3 */ @Alias({ "WGS72", "WGS-72" }) public class WGS72SpheroidEarthModel extends AbstractEarthModel { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/WGS84SpheroidEarthModel.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/WGS84SpheroidEarthModel.java index 522e769a..2265353a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/WGS84SpheroidEarthModel.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geodesy/WGS84SpheroidEarthModel.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Flattening: 1 / 298.257223563 * * @author Erich Schubert + * @since 0.3 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/AlphaShape.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/AlphaShape.java index aefb9149..c02efca1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/AlphaShape.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/AlphaShape.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.BitsUtil; * Compute the alpha-Shape of a point set, using Delaunay triangulation. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.uses SweepHullDelaunay2D * @apiviz.has Polygon diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/GrahamScanConvexHull2D.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/GrahamScanConvexHull2D.java index c3f69807..529ae2fe 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/GrahamScanConvexHull2D.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/GrahamScanConvexHull2D.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * classic Grahams scan. Also computes a bounding box. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has Polygon */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/PrimsMinimumSpanningTree.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/PrimsMinimumSpanningTree.java index 578f7d12..06596cde 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/PrimsMinimumSpanningTree.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/PrimsMinimumSpanningTree.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.composedOf Adapter * @apiviz.composedOf Collector diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/SweepHullDelaunay2D.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/SweepHullDelaunay2D.java index b404ebfb..cb2d498a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/SweepHullDelaunay2D.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/SweepHullDelaunay2D.java @@ -47,6 +47,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.IntIntPair; * Note: This implementation does not check or handle duplicate points! * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.has Polygon */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/XYCurve.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/XYCurve.java index f3af2c8e..8c05e62e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/XYCurve.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/XYCurve.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.DoubleArray; * the curve while adding points. * * @author Erich Schubert + * @since 0.5.0 */ public class XYCurve implements Result, TextWriteable { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/XYPlot.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/XYPlot.java index 412f19ee..76c367ff 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/XYPlot.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/geometry/XYPlot.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.result.Result; * generation. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf Curve */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/AffineTransformation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/AffineTransformation.java index 74b19d2c..e00e3802 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/AffineTransformation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/AffineTransformation.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * transformation. * * @author Erich Schubert + * @since 0.2 * * @apiviz.composedOf Matrix * @apiviz.uses Matrix diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/Centroid.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/Centroid.java index 2e7ba977..dfc0f2a2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/Centroid.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/Centroid.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.database.relation.RelationUtil; * easier to use APIs. * * @author Erich Schubert + * @since 0.4.0 */ public class Centroid extends Vector { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/CholeskyDecomposition.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/CholeskyDecomposition.java index ef0d5ef7..ce0f8ab0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/CholeskyDecomposition.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/CholeskyDecomposition.java @@ -23,7 +23,6 @@ package de.lmu.ifi.dbs.elki.math.linearalgebra; along with this program. If not, see <http://www.gnu.org/licenses/>. */ - /** * Cholesky Decomposition. * <P> @@ -34,6 +33,9 @@ package de.lmu.ifi.dbs.elki.math.linearalgebra; * a partial decomposition and sets an internal flag that may be queried by the * isSPD() method. * + * @author Arthur Zimek + * @since 0.2 + * * @apiviz.uses Matrix - - transforms */ @SuppressWarnings("serial") diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/CovarianceMatrix.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/CovarianceMatrix.java index 1e40430f..566e0e11 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/CovarianceMatrix.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/CovarianceMatrix.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.database.relation.RelationUtil; * stabilized covariance matrix builder! * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses Vector oneway * @apiviz.uses NumberVector oneway diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/EigenPair.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/EigenPair.java index f2d6cec3..df4da275 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/EigenPair.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/EigenPair.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.FormatUtil; * eigenvalue. This class is used to sort eigenpairs. * * @author Elke Achtert + * @since 0.2 * * @apiviz.composedOf Matrix */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/EigenvalueDecomposition.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/EigenvalueDecomposition.java index fde453c6..88ab0688 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/EigenvalueDecomposition.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/EigenvalueDecomposition.java @@ -39,7 +39,10 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * the eigenvectors in the sense that A*V = V*D, i.e. A.times(V) equals * V.times(D). The matrix V may be badly conditioned, or even singular, so the * validity of the equation A = V*D*inverse(V) depends upon V.cond(). - * + * + * @author Arthur Zimek + * @since 0.2 + * * @apiviz.uses Matrix - - transforms */ public class EigenvalueDecomposition implements java.io.Serializable { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/LUDecomposition.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/LUDecomposition.java index be33769e..361e315e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/LUDecomposition.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/LUDecomposition.java @@ -36,6 +36,9 @@ package de.lmu.ifi.dbs.elki.math.linearalgebra; * decomposition is in the solution of square systems of simultaneous linear * equations. This will fail if isNonsingular() returns false. * + * @author Arthur Zimek + * @since 0.2 + * * @apiviz.uses Matrix - - transforms */ public class LUDecomposition implements java.io.Serializable { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/LinearEquationSystem.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/LinearEquationSystem.java index da723177..3d273520 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/LinearEquationSystem.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/LinearEquationSystem.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.IntIntPair; * Class for systems of linear equations. * * @author Elke Achtert + * @since 0.2 */ public class LinearEquationSystem { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/Matrix.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/Matrix.java index cb828e50..9f6ecde9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/Matrix.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/Matrix.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.DoubleArray; * * @author Elke Achtert * @author Erich Schubert + * @since 0.2 * * @apiviz.uses Vector * @apiviz.landmark diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/ProjectedCentroid.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/ProjectedCentroid.java index cc850ce4..b519ca9e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/ProjectedCentroid.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/ProjectedCentroid.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.BitsUtil; * easier to use APIs. * * @author Erich Schubert + * @since 0.4.0 */ public class ProjectedCentroid extends Centroid { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/ProjectionResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/ProjectionResult.java index ca1c05c2..67958078 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/ProjectionResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/ProjectionResult.java @@ -30,6 +30,7 @@ package de.lmu.ifi.dbs.elki.math.linearalgebra; * This can either come from a full PCA, or just from an axis-parallel subspace selection * * @author Erich Schubert + * @since 0.4.0 */ // TODO: cleanup public interface ProjectionResult { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/QRDecomposition.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/QRDecomposition.java index 541987e7..be07df37 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/QRDecomposition.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/QRDecomposition.java @@ -36,6 +36,9 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * decomposition is in the least squares solution of nonsquare systems of * simultaneous linear equations. This will fail if isFullRank() returns false. * + * @author Arthur Zimek + * @since 0.2 + * * @apiviz.uses Matrix - - transforms */ public class QRDecomposition implements java.io.Serializable { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/SingularValueDecomposition.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/SingularValueDecomposition.java index 6b311ed1..2514acc6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/SingularValueDecomposition.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/SingularValueDecomposition.java @@ -39,6 +39,9 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * fail. The matrix condition number and the effective numerical rank can be * computed from this decomposition. * + * @author Arthur Zimek + * @since 0.2 + * * @apiviz.uses Matrix - - transforms */ public class SingularValueDecomposition { @@ -326,7 +329,7 @@ public class SingularValueDecomposition { // Perform the task indicated by kase. switch(kase){ - + // Deflate negligible s(p). case 1: { double f = e[p - 2]; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/SortedEigenPairs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/SortedEigenPairs.java index a4cca9de..e028793c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/SortedEigenPairs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/SortedEigenPairs.java @@ -33,6 +33,7 @@ import java.util.List; * eigenvectors (and -values). * * @author Elke Achtert + * @since 0.2 * * @apiviz.composedOf de.lmu.ifi.dbs.elki.math.linearalgebra.EigenPair */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/VMath.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/VMath.java index a6d4ea77..31456eff 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/VMath.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/VMath.java @@ -31,6 +31,7 @@ import java.util.Arrays; * usage and VM overhead. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/Vector.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/Vector.java index 06198e4a..80e7e219 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/Vector.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/Vector.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteBufferSerializer; * A mathematical vector object, along with mathematical operations. * * @author Elke Achtert + * @since 0.2 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/fitting/FittingFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/fitting/FittingFunction.java index a0da0c7b..13aa185a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/fitting/FittingFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/fitting/FittingFunction.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.math.linearalgebra.fitting; * Interface for a function used in Levenberg-Marquard-Fitting * * @author Erich Schubert + * @since 0.2 */ public interface FittingFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/fitting/FittingFunctionResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/fitting/FittingFunctionResult.java index bf17e4c3..52f340a8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/fitting/FittingFunctionResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/fitting/FittingFunctionResult.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.math.linearalgebra.fitting; * Result returned by a fitting function. * * @author Erich Schubert + * @since 0.2 */ public class FittingFunctionResult { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/fitting/GaussianFittingFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/fitting/GaussianFittingFunction.java index 6cdcff18..7d12cdff 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/fitting/GaussianFittingFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/fitting/GaussianFittingFunction.java @@ -58,6 +58,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * number of parameters (which obviously needs to be a multiple of 3) * * @author Erich Schubert + * @since 0.2 */ public class GaussianFittingFunction implements FittingFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/fitting/LevenbergMarquardtMethod.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/fitting/LevenbergMarquardtMethod.java index b77f3b79..0ca9a643 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/fitting/LevenbergMarquardtMethod.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/fitting/LevenbergMarquardtMethod.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.LinearEquationSystem; * Which supposedly offers increased robustness. * * @author Erich Schubert + * @since 0.2 * * @apiviz.has FittingFunction * @apiviz.uses FittingFunctionResult oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/AbstractCovarianceMatrixBuilder.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/AbstractCovarianceMatrixBuilder.java index 8190eea5..3874b91b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/AbstractCovarianceMatrixBuilder.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/AbstractCovarianceMatrixBuilder.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Matrix; * Mostly the specification of an interface. * * @author Erich Schubert + * @since 0.2 */ public abstract class AbstractCovarianceMatrixBuilder implements CovarianceMatrixBuilder { @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/CompositeEigenPairFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/CompositeEigenPairFilter.java index c56217f8..bd88dcb8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/CompositeEigenPairFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/CompositeEigenPairFilter.java @@ -36,15 +36,11 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectListParamet * eigenpair filters. * * @author Elke Achtert + * @since 0.2 */ // todo parameter comments public class CompositeEigenPairFilter implements EigenPairFilter { /** - * The list of filters to use. - */ - public static final OptionID EIGENPAIR_FILTER_COMPOSITE_LIST = new OptionID("pca.filter.composite.list", "A comma separated list of the class names of the filters to be used. " + "The specified filters will be applied sequentially in the given order."); - - /** * The filters to be applied. */ private List<EigenPairFilter> filters; @@ -86,6 +82,10 @@ public class CompositeEigenPairFilter implements EigenPairFilter { */ public static class Parameterizer extends AbstractParameterizer { /** + * The list of filters to use. + */ + public static final OptionID EIGENPAIR_FILTER_COMPOSITE_LIST = new OptionID("pca.filter.composite.list", "A comma separated list of the class names of the filters to be used. " + "The specified filters will be applied sequentially in the given order."); + /** * The filters to be applied. */ private List<EigenPairFilter> filters = null; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/CovarianceMatrixBuilder.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/CovarianceMatrixBuilder.java index e3d10297..c2b40a85 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/CovarianceMatrixBuilder.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/CovarianceMatrixBuilder.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Matrix; * Interface for computing covariance matrixes on a data set. * * @author Erich Schubert + * @since 0.2 */ public interface CovarianceMatrixBuilder { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/DropEigenPairFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/DropEigenPairFilter.java index 7d642b86..40a171df 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/DropEigenPairFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/DropEigenPairFilter.java @@ -37,16 +37,17 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; /** * The "drop" filter looks for the largest drop in normalized relative * eigenvalues. - * + * * Let s_1 .. s_n be the eigenvalues. - * + * * Let a_k := 1/(n-k) sum_{i=k..n} s_i - * + * * Then r_k := s_k / a_k is the relative eigenvalue. - * + * * The drop filter searches for argmax_k r_k / r_{k+1} - * + * * @author Erich Schubert + * @since 0.2 */ @Title("Drop EigenPair Filter") public class DropEigenPairFilter implements EigenPairFilter { @@ -63,7 +64,7 @@ public class DropEigenPairFilter implements EigenPairFilter { /** * Constructor. - * + * * @param walpha */ public DropEigenPairFilter(double walpha) { @@ -121,9 +122,9 @@ public class DropEigenPairFilter implements EigenPairFilter { /** * Parameterization class. - * + * * @author Erich Schubert - * + * * @apiviz.exclude */ public static class Parameterizer extends AbstractParameterizer { @@ -132,7 +133,7 @@ public class DropEigenPairFilter implements EigenPairFilter { @Override protected void makeOptions(Parameterization config) { super.makeOptions(config); - DoubleParameter walphaP = new DoubleParameter(WeakEigenPairFilter.EIGENPAIR_FILTER_WALPHA, DEFAULT_WALPHA); + DoubleParameter walphaP = new DoubleParameter(WeakEigenPairFilter.Parameterizer.EIGENPAIR_FILTER_WALPHA, DEFAULT_WALPHA); walphaP.addConstraint(CommonConstraints.GREATER_EQUAL_ZERO_DOUBLE); if (config.grab(walphaP)) { walpha = walphaP.getValue(); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/EigenPairFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/EigenPairFilter.java index b0a244f6..7b3886e5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/EigenPairFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/EigenPairFilter.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.SortedEigenPairs; * and weak eigenpairs having small variances. * * @author Elke Achtert + * @since 0.2 * * @apiviz.uses SortedEigenPairs oneway - - reads * @apiviz.uses FilteredEigenPairs oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/FilteredEigenPairs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/FilteredEigenPairs.java index b8343a24..fcc09c7c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/FilteredEigenPairs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/FilteredEigenPairs.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.EigenPair; * by an eigenpair filter. * * @author Elke Achtert + * @since 0.2 * * @apiviz.has EigenPair */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/FirstNEigenPairFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/FirstNEigenPairFilter.java index d2251f28..ca7d288e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/FirstNEigenPairFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/FirstNEigenPairFilter.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * eigenpairs, where n is a user specified number. * * @author Elke Achtert + * @since 0.2 */ // todo parameter comments @Title("First n Eigenpair filter") @@ -53,11 +54,6 @@ public class FirstNEigenPairFilter implements EigenPairFilter { private static final Logging LOG = Logging.getLogger(FirstNEigenPairFilter.class); /** - * Paremeter n - */ - public static final OptionID EIGENPAIR_FILTER_N = new OptionID("pca.filter.n", "The number of strong eigenvectors: n eigenvectors with the n highest" + "eigenvalues are marked as strong eigenvectors."); - - /** * The threshold for strong eigenvectors: n eigenvectors with the n highest * eigenvalues are marked as strong eigenvectors. */ @@ -114,6 +110,10 @@ public class FirstNEigenPairFilter implements EigenPairFilter { */ public static class Parameterizer extends AbstractParameterizer { /** + * Paremeter n + */ + public static final OptionID EIGENPAIR_FILTER_N = new OptionID("pca.filter.n", "The number of strong eigenvectors: n eigenvectors with the n highest" + "eigenvalues are marked as strong eigenvectors."); + /** * The number of eigenpairs to keep. */ protected int n = 0; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/LimitEigenPairFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/LimitEigenPairFilter.java index 779ceb2e..a4047473 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/LimitEigenPairFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/LimitEigenPairFilter.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag; * others are marked as strong eigenpairs. * * @author Elke Achtert + * @since 0.2 */ @Title("Limit-based Eigenpair Filter") @Description("Filters all eigenpairs, which are lower than a given value.") @@ -58,16 +59,6 @@ public class LimitEigenPairFilter implements EigenPairFilter { private static final Logging LOG = Logging.getLogger(LimitEigenPairFilter.class); /** - * "absolute" Flag - */ - public static final OptionID EIGENPAIR_FILTER_ABSOLUTE = new OptionID("pca.filter.absolute", "Flag to mark delta as an absolute value."); - - /** - * Parameter delta - */ - public static final OptionID EIGENPAIR_FILTER_DELTA = new OptionID("pca.filter.delta", "The threshold for strong Eigenvalues. If not otherwise specified, delta " + "is a relative value w.r.t. the (absolute) highest Eigenvalues and has to be " + "a double between 0 and 1. To mark delta as an absolute value, use " + "the option -" + EIGENPAIR_FILTER_ABSOLUTE.getName() + "."); - - /** * The default value for delta. */ public static final double DEFAULT_DELTA = 0.01; @@ -154,6 +145,16 @@ public class LimitEigenPairFilter implements EigenPairFilter { */ public static class Parameterizer extends AbstractParameterizer { /** + * "absolute" Flag + */ + public static final OptionID EIGENPAIR_FILTER_ABSOLUTE = new OptionID("pca.filter.absolute", "Flag to mark delta as an absolute value."); + + /** + * Parameter delta + */ + public static final OptionID EIGENPAIR_FILTER_DELTA = new OptionID("pca.filter.delta", "The threshold for strong Eigenvalues. If not otherwise specified, delta " + "is a relative value w.r.t. the (absolute) highest Eigenvalues and has to be " + "a double between 0 and 1. To mark delta as an absolute value, use " + "the option -" + EIGENPAIR_FILTER_ABSOLUTE.getName() + "."); + + /** * Threshold for strong eigenpairs, can be absolute or relative. */ private double delta; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/NormalizingEigenPairFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/NormalizingEigenPairFilter.java index fb95a68c..9f77f747 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/NormalizingEigenPairFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/NormalizingEigenPairFilter.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Title; * eigenvector> * eigenvalue = 1, where <,> is the standard dot product * * @author Simon Paradies + * @since 0.2 */ @Title("Perecentage based Eigenpair filter") @Description("Normalizes all eigenpairs, consisting of eigenvalue e and eigenvector v such that <v,v> * e = 1, where <,> is the standard dot product.") diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCAFilteredAutotuningRunner.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCAFilteredAutotuningRunner.java index 600fcf95..4abd1c6d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCAFilteredAutotuningRunner.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCAFilteredAutotuningRunner.java @@ -55,6 +55,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * exhibit the clearest correlation. * * @author Erich Schubert + * @since 0.5.0 */ @Reference(authors = "Hans-Peter Kriegel, Peer Kröger, Erich Schubert, Arthur Zimek", // title = "A General Framework for Increasing the Robustness of PCA-based Correlation Clustering Algorithms",// diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCAFilteredResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCAFilteredResult.java index f7ec9e79..1b7d6910 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCAFilteredResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCAFilteredResult.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.SortedEigenPairs; * subspace and an "error" subspace. * * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCAFilteredRunner.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCAFilteredRunner.java index e7c31cf6..d61c7830 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCAFilteredRunner.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCAFilteredRunner.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * regular runner, but afterwards, an {@link EigenPairFilter} is applied. * * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark * @apiviz.has PCAFilteredResult oneway - - «create» diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCAResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCAResult.java index 4c0de355..72268972 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCAResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCAResult.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.SortedEigenPairs; * Result class for Principal Component Analysis with some convenience methods * * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark * @apiviz.has SortedEigenPairs diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCARunner.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCARunner.java index bdd4f32f..c4195506 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCARunner.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PCARunner.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * to a weighted covariance matrix builder) * * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark * @apiviz.uses PCAResult oneway - - «create» @@ -53,18 +54,6 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; */ public class PCARunner { /** - * Parameter to specify the class to compute the covariance matrix, must be a - * subclass of {@link CovarianceMatrixBuilder}. - * <p> - * Default value: {@link CovarianceMatrixBuilder} - * </p> - * <p> - * Key: {@code -pca.covariance} - * </p> - */ - public static final OptionID PCA_COVARIANCE_MATRIX = new OptionID("pca.covariance", "Class used to compute the covariance matrix."); - - /** * The covariance computation class. */ protected CovarianceMatrixBuilder covarianceMatrixBuilder; @@ -161,6 +150,17 @@ public class PCARunner { */ public static class Parameterizer extends AbstractParameterizer { /** + * Parameter to specify the class to compute the covariance matrix, must be a + * subclass of {@link CovarianceMatrixBuilder}. + * <p> + * Default value: {@link CovarianceMatrixBuilder} + * </p> + * <p> + * Key: {@code -pca.covariance} + * </p> + */ + public static final OptionID PCA_COVARIANCE_MATRIX = new OptionID("pca.covariance", "Class used to compute the covariance matrix."); + /** * The covariance computation class. */ protected CovarianceMatrixBuilder covarianceMatrixBuilder; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PercentageEigenPairFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PercentageEigenPairFilter.java index c32ad6fc..8b445b97 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PercentageEigenPairFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/PercentageEigenPairFilter.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * eigenpairs. * * @author Elke Achtert + * @since 0.2 */ @Title("Percentage based Eigenpair filter") @Description("Sorts the eigenpairs in decending order of their eigenvalues and returns the first eigenpairs, whose sum of eigenvalues is higher than the given percentage of the sum of all eigenvalues.") @@ -54,18 +55,6 @@ public class PercentageEigenPairFilter implements EigenPairFilter { private static final Logging LOG = Logging.getLogger(PercentageEigenPairFilter.class); /** - * The threshold for 'strong' eigenvectors: the 'strong' eigenvectors explain - * a portion of at least alpha of the total variance. - * <p> - * Default value: {@link #DEFAULT_ALPHA} - * </p> - * <p> - * Key: {@code -pca.filter.alpha} - * </p> - */ - public static final OptionID ALPHA_ID = new OptionID("pca.filter.alpha", "The share (0.0 to 1.0) of variance that needs to be explained by the 'strong' eigenvectors." + "The filter class will choose the number of strong eigenvectors by this share."); - - /** * The default value for alpha. */ public static final double DEFAULT_ALPHA = 0.85; @@ -145,6 +134,17 @@ public class PercentageEigenPairFilter implements EigenPairFilter { */ public static class Parameterizer extends AbstractParameterizer { /** + * The threshold for 'strong' eigenvectors: the 'strong' eigenvectors explain + * a portion of at least alpha of the total variance. + * <p> + * Default value: {@link #DEFAULT_ALPHA} + * </p> + * <p> + * Key: {@code -pca.filter.alpha} + * </p> + */ + public static final OptionID ALPHA_ID = new OptionID("pca.filter.alpha", "The share (0.0 to 1.0) of variance that needs to be explained by the 'strong' eigenvectors." + "The filter class will choose the number of strong eigenvectors by this share."); + /** * The threshold for strong eigenvectors: the strong eigenvectors explain a * portion of at least alpha of the total variance. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/ProgressiveEigenPairFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/ProgressiveEigenPairFilter.java index 16b6d72e..242c00f4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/ProgressiveEigenPairFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/ProgressiveEigenPairFilter.java @@ -46,48 +46,44 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * gives better results when clusters of different dimensionality exist, since * different percentage alpha levels might be appropriate for different * dimensionalities. - * + * * Example calculations of alpha levels: - * + * * In a 3D space, a progressive alpha value of 0.5 equals: - * + * * - 1D subspace: 50 % + 1/3 of remainder = 0.667 - * + * * - 2D subspace: 50 % + 2/3 of remainder = 0.833 - * + * * In a 4D space, a progressive alpha value of 0.5 equals: - * + * * - 1D subspace: 50% + 1/4 of remainder = 0.625 - * + * * - 2D subspace: 50% + 2/4 of remainder = 0.750 - * + * * - 3D subspace: 50% + 3/4 of remainder = 0.875 - * + * * Reasoning why this improves over PercentageEigenPairFilter: - * + * * In a 100 dimensional space, a single Eigenvector representing over 85% of the * total variance is highly significant, whereas the strongest 85 Eigenvectors * together will by definition always represent at least 85% of the variance. * PercentageEigenPairFilter can thus not be used with these parameters and * detect both dimensionalities correctly. - * + * * The second parameter introduced here, walpha, serves a different function: It * prevents the eigenpair filter to use a statistically weak Eigenvalue just to * reach the intended level, e.g. 84% + 1% >= 85% when 1% is statistically very * weak. - * + * * @author Erich Schubert - * + * @since 0.2 + * */ @Title("Progressive Eigenpair Filter") @Description("Sorts the eigenpairs in decending order of their eigenvalues and returns the first eigenpairs, whose sum of eigenvalues explains more than the a certain percentage of the unexpected variance, where the percentage increases with subspace dimensionality.") public class ProgressiveEigenPairFilter implements EigenPairFilter { /** - * Parameter progressive alpha. - */ - public static final OptionID EIGENPAIR_FILTER_PALPHA = new OptionID("pca.filter.progressivealpha", "The share (0.0 to 1.0) of variance that needs to be explained by the 'strong' eigenvectors." + "The filter class will choose the number of strong eigenvectors by this share."); - - /** * The default value for alpha. */ public static final double DEFAULT_PALPHA = 0.5; @@ -110,7 +106,7 @@ public class ProgressiveEigenPairFilter implements EigenPairFilter { /** * Constructor. - * + * * @param palpha palpha * @param walpha walpha */ @@ -177,13 +173,18 @@ public class ProgressiveEigenPairFilter implements EigenPairFilter { /** * Parameterization class. - * + * * @author Erich Schubert - * + * * @apiviz.exclude */ public static class Parameterizer extends AbstractParameterizer { /** + * Parameter progressive alpha. + */ + public static final OptionID EIGENPAIR_FILTER_PALPHA = new OptionID("pca.filter.progressivealpha", "The share (0.0 to 1.0) of variance that needs to be explained by the 'strong' eigenvectors." + "The filter class will choose the number of strong eigenvectors by this share."); + + /** * The threshold for strong eigenvectors: the strong eigenvectors explain a * portion of at least alpha of the total variance. */ @@ -204,7 +205,7 @@ public class ProgressiveEigenPairFilter implements EigenPairFilter { palpha = palphaP.getValue(); } - DoubleParameter walphaP = new DoubleParameter(WeakEigenPairFilter.EIGENPAIR_FILTER_WALPHA, DEFAULT_WALPHA); + DoubleParameter walphaP = new DoubleParameter(WeakEigenPairFilter.Parameterizer.EIGENPAIR_FILTER_WALPHA, DEFAULT_WALPHA); walphaP.addConstraint(CommonConstraints.GREATER_EQUAL_ZERO_DOUBLE); if(config.grab(walphaP)) { walpha = walphaP.getValue(); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/RANSACCovarianceMatrixBuilder.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/RANSACCovarianceMatrixBuilder.java index 291f91b6..5553936b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/RANSACCovarianceMatrixBuilder.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/RANSACCovarianceMatrixBuilder.java @@ -74,6 +74,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * </p> * * @author Erich Schubert + * @since 0.5.5 */ @Reference(authors = "Hans-Peter Kriegel, Peer Kröger, Erich Schubert, Arthur Zimek", // title = "Outlier Detection in Arbitrarily Oriented Subspaces", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/RelativeEigenPairFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/RelativeEigenPairFilter.java index 54361c4f..3011a7d8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/RelativeEigenPairFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/RelativeEigenPairFilter.java @@ -50,16 +50,12 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * dimensionalities. * * @author Erich Schubert + * @since 0.2 */ @Title("Relative EigenPair Filter") @Description("Sorts the eigenpairs in decending order of their eigenvalues and returns those eigenpairs, whose eigenvalue is " + "above the average ('expected') eigenvalue of the remaining eigenvectors.") public class RelativeEigenPairFilter implements EigenPairFilter { /** - * Parameter relative alpha. - */ - public static final OptionID EIGENPAIR_FILTER_RALPHA = new OptionID("pca.filter.relativealpha", "The sensitivity niveau for weak eigenvectors: An eigenvector which is at less than " + "the given share of the statistical average variance is considered weak."); - - /** * The default value for ralpha. */ public static final double DEFAULT_RALPHA = 1.1; @@ -123,6 +119,10 @@ public class RelativeEigenPairFilter implements EigenPairFilter { * @apiviz.exclude */ public static class Parameterizer extends AbstractParameterizer { + /** + * Parameter relative alpha. + */ + public static final OptionID EIGENPAIR_FILTER_RALPHA = new OptionID("pca.filter.relativealpha", "The sensitivity niveau for weak eigenvectors: An eigenvector which is at less than " + "the given share of the statistical average variance is considered weak."); protected double ralpha; @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/SignificantEigenPairFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/SignificantEigenPairFilter.java index dfc5347d..64dac360 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/SignificantEigenPairFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/SignificantEigenPairFilter.java @@ -39,18 +39,19 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * The SignificantEigenPairFilter sorts the eigenpairs in descending order of * their eigenvalues and chooses the contrast of an Eigenvalue to the remaining * Eigenvalues is maximal. - * + * * It is closely related to the WeakEigenPairFilter and RelativeEigenPairFilter. * But while the RelativeEigenPairFilter chooses the highest dimensionality that * satisfies the relative alpha levels, the SignificantEigenPairFilter will * chose the local dimensionality such that the 'contrast' is maximal. - * + * * There are some situations where one or the other is superior, especially when * it comes to handling nested clusters and strong global correlations that are * not too interesting. These benefits usually only make a difference at higher * dimensionalities. - * + * * @author Erich Schubert + * @since 0.2 */ @Title("Significant EigenPair Filter") @Description("Sorts the eigenpairs in decending order of their eigenvalues and looks for the maxmimum contrast of current Eigenvalue / average of remaining Eigenvalues.") @@ -68,7 +69,7 @@ public class SignificantEigenPairFilter implements EigenPairFilter { /** * Constructor. - * + * * @param walpha */ public SignificantEigenPairFilter(double walpha) { @@ -122,9 +123,9 @@ public class SignificantEigenPairFilter implements EigenPairFilter { /** * Parameterization class. - * + * * @author Erich Schubert - * + * * @apiviz.exclude */ public static class Parameterizer extends AbstractParameterizer { @@ -133,7 +134,7 @@ public class SignificantEigenPairFilter implements EigenPairFilter { @Override protected void makeOptions(Parameterization config) { super.makeOptions(config); - DoubleParameter walphaP = new DoubleParameter(WeakEigenPairFilter.EIGENPAIR_FILTER_WALPHA, DEFAULT_WALPHA); + DoubleParameter walphaP = new DoubleParameter(WeakEigenPairFilter.Parameterizer.EIGENPAIR_FILTER_WALPHA, DEFAULT_WALPHA); walphaP.addConstraint(CommonConstraints.GREATER_EQUAL_ZERO_DOUBLE); if(config.grab(walphaP)) { walpha = walphaP.getValue(); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/StandardCovarianceMatrixBuilder.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/StandardCovarianceMatrixBuilder.java index 677a88eb..ea1a6787 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/StandardCovarianceMatrixBuilder.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/StandardCovarianceMatrixBuilder.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Matrix; * Reasonable default choice for a {@link CovarianceMatrixBuilder} * * @author Erich Schubert + * @since 0.2 * * @apiviz.uses CovarianceMatrix */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/WeakEigenPairFilter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/WeakEigenPairFilter.java index 51d89450..8f76531e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/WeakEigenPairFilter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/WeakEigenPairFilter.java @@ -42,19 +42,12 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * as "strong", the others as "weak". * * @author Erich Schubert + * @since 0.2 */ @Title("Weak Eigenpair Filter") @Description("Sorts the eigenpairs in decending order of their eigenvalues and returns those eigenpairs, whose eigenvalue is above the average ('expected') eigenvalue.") public class WeakEigenPairFilter implements EigenPairFilter { /** - * OptionID for the weak alpha value of {@link WeakEigenPairFilter}, - * {@link de.lmu.ifi.dbs.elki.math.linearalgebra.pca.ProgressiveEigenPairFilter} - * and - * {@link de.lmu.ifi.dbs.elki.math.linearalgebra.pca.SignificantEigenPairFilter} - */ - public static final OptionID EIGENPAIR_FILTER_WALPHA = new OptionID("pca.filter.weakalpha", "The minimum strength of the statistically expected variance (1/n) share an eigenvector " + "needs to have to be considered 'strong'."); - - /** * The default value for walpha. */ public static final double DEFAULT_WALPHA = 0.95; @@ -119,6 +112,13 @@ public class WeakEigenPairFilter implements EigenPairFilter { */ public static class Parameterizer extends AbstractParameterizer { /** + * OptionID for the weak alpha value of {@link WeakEigenPairFilter}, + * {@link de.lmu.ifi.dbs.elki.math.linearalgebra.pca.ProgressiveEigenPairFilter} + * and + * {@link de.lmu.ifi.dbs.elki.math.linearalgebra.pca.SignificantEigenPairFilter} + */ + public static final OptionID EIGENPAIR_FILTER_WALPHA = new OptionID("pca.filter.weakalpha", "The minimum strength of the statistically expected variance (1/n) share an eigenvector " + "needs to have to be considered 'strong'."); + /** * The threshold for strong eigenvectors: the strong eigenvectors explain a * portion of at least alpha of the total variance. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/WeightedCovarianceMatrixBuilder.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/WeightedCovarianceMatrixBuilder.java index a5b7d545..eba61671 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/WeightedCovarianceMatrixBuilder.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/WeightedCovarianceMatrixBuilder.java @@ -60,6 +60,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Computer Science 5069, Springer * * @author Erich Schubert + * @since 0.2 * * @apiviz.has WeightFunction * @apiviz.has PrimitiveDistanceFunction @@ -73,17 +74,6 @@ booktitle = "Proceedings of the 20th International Conference on Scientific and url = "http://dx.doi.org/10.1007/978-3-540-69497-7_27") public class WeightedCovarianceMatrixBuilder extends AbstractCovarianceMatrixBuilder { /** - * Parameter to specify the weight function to use in weighted PCA, must - * implement - * {@link de.lmu.ifi.dbs.elki.math.linearalgebra.pca.weightfunctions.WeightFunction} - * . - * <p> - * Key: {@code -pca.weight} - * </p> - */ - public static final OptionID WEIGHT_ID = new OptionID("pca.weight", "Weight function to use in weighted PCA."); - - /** * Holds the weight function. */ protected WeightFunction weightfunction; @@ -205,6 +195,16 @@ public class WeightedCovarianceMatrixBuilder extends AbstractCovarianceMatrixBui */ public static class Parameterizer extends AbstractParameterizer { /** + * Parameter to specify the weight function to use in weighted PCA, must + * implement + * {@link de.lmu.ifi.dbs.elki.math.linearalgebra.pca.weightfunctions.WeightFunction} + * . + * <p> + * Key: {@code -pca.weight} + * </p> + */ + public static final OptionID WEIGHT_ID = new OptionID("pca.weight", "Weight function to use in weighted PCA."); + /** * Weight function. */ protected WeightFunction weightfunction = null; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ConstantWeight.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ConstantWeight.java index 693cdb2e..71ae52ed 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ConstantWeight.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ConstantWeight.java @@ -30,6 +30,7 @@ package de.lmu.ifi.dbs.elki.math.linearalgebra.pca.weightfunctions; * The result is always 1.0 * * @author Erich Schubert + * @since 0.2 */ public final class ConstantWeight implements WeightFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ErfcStddevWeight.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ErfcStddevWeight.java index 03423603..76e24d18 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ErfcStddevWeight.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ErfcStddevWeight.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.math.statistics.distribution.NormalDistribution; * erfc(1 / sqrt(2) * distance / stddev) * * @author Erich Schubert + * @since 0.2 */ public final class ErfcStddevWeight implements WeightFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ErfcWeight.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ErfcWeight.java index b7bc1c67..11acb0af 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ErfcWeight.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ErfcWeight.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.math.statistics.distribution.NormalDistribution; * scaling. * * @author Erich Schubert + * @since 0.2 */ public final class ErfcWeight implements WeightFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ExponentialStddevWeight.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ExponentialStddevWeight.java index 3b265d47..fce17896 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ExponentialStddevWeight.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ExponentialStddevWeight.java @@ -34,6 +34,7 @@ package de.lmu.ifi.dbs.elki.math.linearalgebra.pca.weightfunctions; * not squared. * * @author Erich Schubert + * @since 0.2 */ public final class ExponentialStddevWeight implements WeightFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ExponentialWeight.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ExponentialWeight.java index c67e35d7..c45d5cac 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ExponentialWeight.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/ExponentialWeight.java @@ -36,6 +36,7 @@ package de.lmu.ifi.dbs.elki.math.linearalgebra.pca.weightfunctions; * -2.3025850929940455 is log(-.1) to achieve the intended range of 1.0 - 0.1 * * @author Erich Schubert + * @since 0.2 */ public final class ExponentialWeight implements WeightFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/GaussStddevWeight.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/GaussStddevWeight.java index bf78b576..d8f67639 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/GaussStddevWeight.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/GaussStddevWeight.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * with factor being 1 / sqrt(2 * PI) * * @author Erich Schubert + * @since 0.2 */ public final class GaussStddevWeight implements WeightFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/GaussWeight.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/GaussWeight.java index fcad89a3..70826d0e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/GaussWeight.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/GaussWeight.java @@ -31,6 +31,7 @@ package de.lmu.ifi.dbs.elki.math.linearalgebra.pca.weightfunctions; * exp(-2.3025850929940455 * (distance/max)^2) * * @author Erich Schubert + * @since 0.2 */ public final class GaussWeight implements WeightFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/InverseLinearWeight.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/InverseLinearWeight.java index 3fb8e9e0..f2c27d5a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/InverseLinearWeight.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/InverseLinearWeight.java @@ -33,6 +33,7 @@ package de.lmu.ifi.dbs.elki.math.linearalgebra.pca.weightfunctions; * This function has increasing weight, from 0.1 to 1.0 at distance == max. * * @author Erich Schubert + * @since 0.2 */ public final class InverseLinearWeight implements WeightFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/InverseProportionalStddevWeight.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/InverseProportionalStddevWeight.java index a4d4a28e..952e7a56 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/InverseProportionalStddevWeight.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/InverseProportionalStddevWeight.java @@ -30,6 +30,7 @@ package de.lmu.ifi.dbs.elki.math.linearalgebra.pca.weightfunctions; * 1 / (1 + distance/stddev) * * @author Erich Schubert + * @since 0.2 */ public final class InverseProportionalStddevWeight implements WeightFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/InverseProportionalWeight.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/InverseProportionalWeight.java index fb1d71ba..810d17a9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/InverseProportionalWeight.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/InverseProportionalWeight.java @@ -30,6 +30,7 @@ package de.lmu.ifi.dbs.elki.math.linearalgebra.pca.weightfunctions; * 1 / (1 + distance/max) * * @author Erich Schubert + * @since 0.2 */ public final class InverseProportionalWeight implements WeightFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/LinearWeight.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/LinearWeight.java index a37617b5..bc92660e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/LinearWeight.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/LinearWeight.java @@ -31,6 +31,7 @@ package de.lmu.ifi.dbs.elki.math.linearalgebra.pca.weightfunctions; * 1 - 0.9 * (distance/max) * * @author Erich Schubert + * @since 0.2 */ public final class LinearWeight implements WeightFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/QuadraticStddevWeight.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/QuadraticStddevWeight.java index e35e9a67..c02d78f1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/QuadraticStddevWeight.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/QuadraticStddevWeight.java @@ -33,6 +33,7 @@ package de.lmu.ifi.dbs.elki.math.linearalgebra.pca.weightfunctions; * max(0.0, 1.0 - (distance/(3*stddev))^2 * * @author Erich Schubert + * @since 0.2 */ public final class QuadraticStddevWeight implements WeightFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/QuadraticWeight.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/QuadraticWeight.java index 87bd552b..d764ef08 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/QuadraticWeight.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/QuadraticWeight.java @@ -31,6 +31,7 @@ package de.lmu.ifi.dbs.elki.math.linearalgebra.pca.weightfunctions; * 1.0 - 0.9 * (distance/max)^2 * * @author Erich Schubert + * @since 0.2 */ public final class QuadraticWeight implements WeightFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/WeightFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/WeightFunction.java index 49bced02..afc04fb9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/WeightFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/pca/weightfunctions/WeightFunction.java @@ -30,6 +30,7 @@ package de.lmu.ifi.dbs.elki.math.linearalgebra.pca.weightfunctions; * normalized according to the maximum or standard deviation. * * @author Erich Schubert + * @since 0.2 */ public interface WeightFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/AbstractRandomProjectionFamily.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/AbstractRandomProjectionFamily.java index 00597ac2..7ce235de 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/AbstractRandomProjectionFamily.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/AbstractRandomProjectionFamily.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * Abstract base class for random projection families. * * @author Erich Schubert + * @since 0.3 */ public abstract class AbstractRandomProjectionFamily implements RandomProjectionFamily { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/AchlioptasRandomProjectionFamily.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/AchlioptasRandomProjectionFamily.java index e3504419..4c74bbfb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/AchlioptasRandomProjectionFamily.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/AchlioptasRandomProjectionFamily.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * TODO: faster implementation exploiting sparsity. * * @author Erich Schubert + * @since 0.6.0 */ @Reference(title = "Database-friendly random projections: Johnson-Lindenstrauss with binary coins", // authors = "D. Achlioptas", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/CauchyRandomProjectionFamily.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/CauchyRandomProjectionFamily.java index 699478ac..47fddeab 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/CauchyRandomProjectionFamily.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/CauchyRandomProjectionFamily.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.6.0 */ @Reference(authors = "M. Datar and N. Immorlica and P. Indyk and V. S. Mirrokni", // title = "Locality-sensitive hashing scheme based on p-stable distributions", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/GaussianRandomProjectionFamily.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/GaussianRandomProjectionFamily.java index facfe427..e5277d5e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/GaussianRandomProjectionFamily.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/GaussianRandomProjectionFamily.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.6.0 */ @Reference(authors = "M. Datar and N. Immorlica and P. Indyk and V. S. Mirrokni", // title = "Locality-sensitive hashing scheme based on p-stable distributions", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/RandomProjectionFamily.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/RandomProjectionFamily.java index 95a59276..e97e32f6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/RandomProjectionFamily.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/RandomProjectionFamily.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.data.NumberVector; * Interface for random projection families. * * @author Erich Schubert + * @since 0.2 * * @apiviz.has Projection */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/RandomSubsetProjectionFamily.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/RandomSubsetProjectionFamily.java index dae7e0cb..15ecfec4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/RandomSubsetProjectionFamily.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/RandomSubsetProjectionFamily.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.6.0 */ @Reference(authors = "L. Breiman", // title = "Bagging predictors", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/SimplifiedRandomHyperplaneProjectionFamily.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/SimplifiedRandomHyperplaneProjectionFamily.java index 5a505f66..3916659a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/SimplifiedRandomHyperplaneProjectionFamily.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/linearalgebra/randomprojections/SimplifiedRandomHyperplaneProjectionFamily.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * * @author Evgeniy Faerman * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "M. Henzinger", // title = "Finding near-duplicate web pages: a large-scale evaluation of algorithms", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/random/FastNonThreadsafeRandom.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/random/FastNonThreadsafeRandom.java index 72f6be0b..a3632102 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/random/FastNonThreadsafeRandom.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/random/FastNonThreadsafeRandom.java @@ -29,6 +29,7 @@ import java.util.Random; * seeds. This implementation is <em>no longer thread-safe</em> (but faster)! * * @author Erich Schubert + * @since 0.6.0 */ public class FastNonThreadsafeRandom extends Random { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/random/RandomFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/random/RandomFactory.java index ca8f5a36..c75ac19b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/random/RandomFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/random/RandomFactory.java @@ -36,6 +36,7 @@ import java.util.Random; * scientific experiments are not likely to be adversarial. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has Random * @apiviz.has FastNonThreadsafeRandom @@ -44,7 +45,12 @@ public class RandomFactory { /** * Global default factory */ - public static RandomFactory DEFAULT = new RandomFactory(getGlobalSeed()); + public static RandomFactory DEFAULT = new RandomFactory(getGlobalSeed()) { + @Override + public String toString() { + return "GlobalRandom[" + Long.toString(this.seed) + "]"; + } + }; /** * Initialize the default random. @@ -59,7 +65,7 @@ public class RandomFactory { /** * Seed. */ - private long seed; + protected long seed; /** * Factory method: Get a random factory for the given seed. @@ -101,4 +107,9 @@ public class RandomFactory { public Random getSingleThreadedRandom() { return new FastNonThreadsafeRandom(seed++); } + + @Override + public String toString() { + return "Random[" + Long.toString(seed) + "]"; + } }
\ No newline at end of file diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/random/XorShift1024NonThreadsafeRandom.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/random/XorShift1024NonThreadsafeRandom.java index 4cafbfba..e6d28167 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/random/XorShift1024NonThreadsafeRandom.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/random/XorShift1024NonThreadsafeRandom.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "S. Vigna", // title = "An experimental exploration of Marsaglia's xorshift generators, scrambled", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/random/XorShift64NonThreadsafeRandom.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/random/XorShift64NonThreadsafeRandom.java index 4063fe03..7716d178 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/random/XorShift64NonThreadsafeRandom.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/random/XorShift64NonThreadsafeRandom.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "S. Vigna", // title = "An experimental exploration of Marsaglia's xorshift generators, scrambled", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/scales/LinearScale.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/scales/LinearScale.java index 94aead3b..629ac96a 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/scales/LinearScale.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/scales/LinearScale.java @@ -35,6 +35,7 @@ import java.util.Locale; * values. * * @author Erich Schubert + * @since 0.2 * */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/scales/Scales.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/scales/Scales.java index deb2a85c..7ed49882 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/scales/Scales.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/scales/Scales.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * able to automatically choose log scales when appropriate. * * @author Erich Schubert + * @since 0.2 * * @apiviz.has LinearScale oneway - - computes */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/AbstractSpatialSorter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/AbstractSpatialSorter.java index 8c5a580f..7a9e4d31 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/AbstractSpatialSorter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/AbstractSpatialSorter.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.data.spatial.SpatialComparable; * Abstract base class for spatial sorters, offering shared functionality. * * @author Erich Schubert + * @since 0.5.0 */ public abstract class AbstractSpatialSorter implements SpatialSorter { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/BinarySplitSpatialSorter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/BinarySplitSpatialSorter.java index a1b8ea9b..e549c072 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/BinarySplitSpatialSorter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/BinarySplitSpatialSorter.java @@ -47,6 +47,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.5.0 */ @Reference(authors = "J. L. Bentley", title = "Multidimensional binary search trees used for associative searching", booktitle = "Communications of the ACM, Vol. 18 Issue 9, Sept. 1975", url = "http://dx.doi.org/10.1145/361002.361007") public class BinarySplitSpatialSorter extends AbstractSpatialSorter { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/HilbertSpatialSorter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/HilbertSpatialSorter.java index f3207233..b8eebf17 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/HilbertSpatialSorter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/HilbertSpatialSorter.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.composedOf HilbertRef */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/PeanoSpatialSorter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/PeanoSpatialSorter.java index 490c9470..2b9f6982 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/PeanoSpatialSorter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/PeanoSpatialSorter.java @@ -31,9 +31,9 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; /** * Bulk-load an R-tree index by presorting the objects with their position on * the Peano curve. - * + * * The basic shape of this space-filling curve looks like this: - * + * * <pre> * 3---4 9 * | | | @@ -41,14 +41,14 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * | | | * 1 6---7 * </pre> - * + * * Which then expands to the next level as: - * + * * <pre> * +-+ +-+ +-+ +-+ E * | | | | | | | | | * | +-+ +-+ | | +-+ - * | | | + * | | | * | +-+ +-+ | | +-+ * | | | | | | | | | * +-+ | | +-+ +-+ | @@ -57,19 +57,22 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * | | | | | | | | | * S +-+ +-+ +-+ +-+ * </pre> - * + * * and so on. - * + * * Reference: * <p> * G. Peano<br /> * Sur une courbe, qui remplit toute une aire plane<br /> * Mathematische Annalen, 36(1) * </p> - * + * * @author Erich Schubert + * @since 0.5.0 */ -@Reference(authors = "G. Peano", title = "Sur une courbe, qui remplit toute une aire plane", booktitle = "Mathematische Annalen, 36(1)") +@Reference(authors = "G. Peano", // +title = "Sur une courbe, qui remplit toute une aire plane", // +booktitle = "Mathematische Annalen, 36(1)") public class PeanoSpatialSorter extends AbstractSpatialSorter { /** * Constructor. @@ -80,12 +83,12 @@ public class PeanoSpatialSorter extends AbstractSpatialSorter { @Override public <T extends SpatialComparable> void sort(List<T> objs, int start, int end, double[] minmax, int[] dims) { - peanoSort(objs, start, end, minmax, dims, 0, BitsUtil.zero(dims.length), false); + peanoSort(objs, start, end, minmax, dims, 0, BitsUtil.zero(minmax.length >> 1), false); } /** * Sort by Peano curve. - * + * * @param objs Objects * @param start Start index * @param end End diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/SpatialSorter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/SpatialSorter.java index 0745729c..14139f97 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/SpatialSorter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/SpatialSorter.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.data.spatial.SpatialComparable; * Interface for spatial sorting - ZCurves, Peano curves, Hilbert curves, ... * * @author Erich Schubert + * @since 0.5.0 */ public interface SpatialSorter { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/ZCurveSpatialSorter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/ZCurveSpatialSorter.java index d5fd10cf..08b68c5f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/ZCurveSpatialSorter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/ZCurveSpatialSorter.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.data.spatial.SpatialComparable; * materialization of the Z indexes. * * @author Erich Schubert + * @since 0.5.0 */ public class ZCurveSpatialSorter extends AbstractSpatialSorter { private static final double STOPVAL = 1E-10; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/ZCurveTransformer.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/ZCurveTransformer.java index 29c8ae72..94a6b12c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/ZCurveTransformer.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/spacefillingcurves/ZCurveTransformer.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.database.relation.RelationUtil; * Class to transform a relation to its Z coordinates. * * @author Erich Schubert + * @since 0.5.0 */ public class ZCurveTransformer { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/KernelDensityEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/KernelDensityEstimator.java index 52087f8e..20f3bee0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/KernelDensityEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/KernelDensityEstimator.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.math.statistics.kernelfunctions.KernelDensityFunction * Estimates a density using a variable width kernel density estimation. * * @author Erich Schubert + * @since 0.2 * * @apiviz.uses KernelDensityFunction */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/LinearRegression.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/LinearRegression.java index d6818129..faee3050 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/LinearRegression.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/LinearRegression.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.DoubleDoublePair; /** * * @author Arthur Zimek + * @since 0.2 */ // TODO: arthur comment // TODO: use covariance matrix, add incremental API? diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/MultipleLinearRegression.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/MultipleLinearRegression.java index 45aad7a2..42bbc712 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/MultipleLinearRegression.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/MultipleLinearRegression.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.FormatUtil; * is defined to be y = b0 + b1*x1 + b2*x2 + ... + bp*xp + e. * * @author Elke Achtert + * @since 0.2 */ public class MultipleLinearRegression { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/PolynomialRegression.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/PolynomialRegression.java index 53f02d19..3ccc5453 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/PolynomialRegression.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/PolynomialRegression.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; * + b1*x1 + b2*x2 + ... + bp*xp + e * * @author Elke Achtert + * @since 0.2 */ public class PolynomialRegression extends MultipleLinearRegression { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/ProbabilityWeightedMoments.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/ProbabilityWeightedMoments.java index 30357c9c..382600d7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/ProbabilityWeightedMoments.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/ProbabilityWeightedMoments.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.6.0 */ @Reference(authors = "J.R.M. Hosking, J. R. Wallis, and E. F. Wood", title = "Estimation of the generalized extreme-value distribution by the method of probability-weighted moments.", booktitle = "Technometrics 27.3", url = "http://dx.doi.org/10.1080/00401706.1985.10488049") public class ProbabilityWeightedMoments { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/AbstractDependenceMeasure.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/AbstractDependenceMeasure.java index 2b76b7fe..2c177328 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/AbstractDependenceMeasure.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/AbstractDependenceMeasure.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * Abstract base class for dependence measures. * * @author Erich Schubert + * @since 0.7.0 */ public abstract class AbstractDependenceMeasure implements DependenceMeasure { // In your subclass, you will need to implement at least this method: diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/CorrelationDependenceMeasure.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/CorrelationDependenceMeasure.java index e2d434b5..b67757ee 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/CorrelationDependenceMeasure.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/CorrelationDependenceMeasure.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Pearson product-moment correlation coefficient. * * @author Erich Schubert + * @since 0.7.0 */ public class CorrelationDependenceMeasure extends AbstractDependenceMeasure { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/DependenceMeasure.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/DependenceMeasure.java index 10bd7565..be2741fe 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/DependenceMeasure.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/DependenceMeasure.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.NumberArrayAdapter * Measure the dependence of two variables. * * @author Erich Schubert + * @since 0.5.0 */ public interface DependenceMeasure { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/DistanceCorrelationDependenceMeasure.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/DistanceCorrelationDependenceMeasure.java index 289c0045..c1fdac6a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/DistanceCorrelationDependenceMeasure.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/DistanceCorrelationDependenceMeasure.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * @author Marie Kiermeier * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "Székely, G. J., Rizzo, M. L., & Bakirov, N. K.", // title = "Measuring and testing dependence by correlation of distances", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/HSMDependenceMeasure.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/HSMDependenceMeasure.java index b90dbc22..6adf498c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/HSMDependenceMeasure.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/HSMDependenceMeasure.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * @author Erich Schubert * @author Robert Rödler + * @since 0.5.5 */ @Reference(authors = "A. Tatu, G. Albuquerque, M. Eisemann, P. Bak, H. Theisel, M. A. Magnor, and D. A. Keim", // title = "Automated Analytical Methods to Support Visual Exploration of High-Dimensional Data", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/HiCSDependenceMeasure.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/HiCSDependenceMeasure.java index ea06698f..335c0182 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/HiCSDependenceMeasure.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/HiCSDependenceMeasure.java @@ -63,6 +63,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * * @author Erich Schubert * @author Robert Rödler + * @since 0.7.0 */ @Reference(authors = "Elke Achtert, Hans-Peter Kriegel, Erich Schubert, Arthur Zimek", // title = "Interactive Data Mining with 3D-Parallel-Coordinate-Trees", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/HoeffdingsDDependenceMeasure.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/HoeffdingsDDependenceMeasure.java index 63f618cc..6fc96223 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/HoeffdingsDDependenceMeasure.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/HoeffdingsDDependenceMeasure.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * @author Yinchong Yang * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "W. Hoeffding", // title = "A non-parametric test of independence", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/JensenShannonEquiwidthDependenceMeasure.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/JensenShannonEquiwidthDependenceMeasure.java index e988100d..3d0d779a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/JensenShannonEquiwidthDependenceMeasure.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/JensenShannonEquiwidthDependenceMeasure.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * TODO: Offer normalized and non-normalized variants? * * @author Erich Schubert + * @since 0.7.0 */ public class JensenShannonEquiwidthDependenceMeasure extends AbstractDependenceMeasure { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/MCEDependenceMeasure.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/MCEDependenceMeasure.java index 471c1135..6058adec 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/MCEDependenceMeasure.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/MCEDependenceMeasure.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "D. Guo", // title = "Coordinating computational and visual approaches for interactive feature selection and multivariate clustering", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/MutualInformationEquiwidthDependenceMeasure.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/MutualInformationEquiwidthDependenceMeasure.java index c1aa786d..e4145704 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/MutualInformationEquiwidthDependenceMeasure.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/MutualInformationEquiwidthDependenceMeasure.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * For a median-based discretization, see {@link MCEDependenceMeasure}. * * @author Erich Schubert + * @since 0.7.0 */ public class MutualInformationEquiwidthDependenceMeasure extends AbstractDependenceMeasure { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/SURFINGDependenceMeasure.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/SURFINGDependenceMeasure.java index c37ad125..9019e087 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/SURFINGDependenceMeasure.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/SURFINGDependenceMeasure.java @@ -59,6 +59,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * @author Robert Rödler * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "Elke Achtert, Hans-Peter Kriegel, Erich Schubert, Arthur Zimek", // title = "Interactive Data Mining with 3D-Parallel-Coordinate-Trees", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/SlopeDependenceMeasure.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/SlopeDependenceMeasure.java index a5f7e60e..b3cc9e39 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/SlopeDependenceMeasure.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/SlopeDependenceMeasure.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * @author Erich Schubert * @author Robert Rödler + * @since 0.7.0 */ @Reference(authors = "Elke Achtert, Hans-Peter Kriegel, Erich Schubert, Arthur Zimek", // title = "Interactive Data Mining with 3D-Parallel-Coordinate-Trees", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/SlopeInversionDependenceMeasure.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/SlopeInversionDependenceMeasure.java index f99984c8..0aa62ad7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/SlopeInversionDependenceMeasure.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/SlopeInversionDependenceMeasure.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * @author Erich Schubert * @author Robert Rödler + * @since 0.7.0 */ @Reference(authors = "Elke Achtert, Hans-Peter Kriegel, Erich Schubert, Arthur Zimek", // title = "Interactive Data Mining with 3D-Parallel-Coordinate-Trees", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/SpearmanCorrelationDependenceMeasure.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/SpearmanCorrelationDependenceMeasure.java index 3a6a162f..3942e7e1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/SpearmanCorrelationDependenceMeasure.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/dependence/SpearmanCorrelationDependenceMeasure.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Spearman rank-correlation coefficient, also known as Spearmans Rho. * * @author Erich Schubert + * @since 0.7.0 */ public class SpearmanCorrelationDependenceMeasure extends AbstractDependenceMeasure { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/AbstractDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/AbstractDistribution.java index ef3e1dff..e7ed8a6f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/AbstractDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/AbstractDistribution.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * Abstract base class for distributions. * * @author Erich Schubert + * @since 0.6.0 */ public abstract class AbstractDistribution implements Distribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/BetaDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/BetaDistribution.java index 374ca717..d8242c0d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/BetaDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/BetaDistribution.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * * @author Jan Brusis * @author Erich Schubert + * @since 0.5.0 */ public class BetaDistribution extends AbstractDistribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/CauchyDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/CauchyDistribution.java index 808c3b00..c5edbfb6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/CauchyDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/CauchyDistribution.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Cauchy distribution. * * @author Erich Schubert + * @since 0.6.0 */ public class CauchyDistribution extends AbstractDistribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ChiDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ChiDistribution.java index 5bbcbe2b..2cc397bf 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ChiDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ChiDistribution.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Chi distribution. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.composedOf ChiSquaredDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ChiSquaredDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ChiSquaredDistribution.java index 28ccdc4b..ae6ad53b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ChiSquaredDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ChiSquaredDistribution.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Chi-Squared distribution (a specialization of the Gamma distribution). * * @author Erich Schubert + * @since 0.2 */ public class ChiSquaredDistribution extends GammaDistribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ConstantDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ConstantDistribution.java index c0bb98e8..10f5f377 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ConstantDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ConstantDistribution.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Pseudo distribution, that has a unique constant value. * * @author Erich Schubert + * @since 0.5.0 */ public class ConstantDistribution implements Distribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/Distribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/Distribution.java index 9edf4b68..84cd64e8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/Distribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/Distribution.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.math.statistics.distribution; * Statistical distributions, with their common functions. * * @author Erich Schubert + * @since 0.2 */ public interface Distribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ExponentialDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ExponentialDistribution.java index 828416d7..055d4e1f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ExponentialDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ExponentialDistribution.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Exponential distribution. * * @author Erich Schubert + * @since 0.5.5 */ public class ExponentialDistribution extends AbstractDistribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ExponentiallyModifiedGaussianDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ExponentiallyModifiedGaussianDistribution.java index a764e304..f373d219 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ExponentiallyModifiedGaussianDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/ExponentiallyModifiedGaussianDistribution.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * is a combination of a normal distribution and an exponential distribution. * * @author Erich Schubert + * @since 0.6.0 */ @Alias({ "exgaussian" }) public class ExponentiallyModifiedGaussianDistribution extends AbstractDistribution { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GammaDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GammaDistribution.java index 92af5a88..c6573016 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GammaDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GammaDistribution.java @@ -28,6 +28,7 @@ import java.util.Random; import de.lmu.ifi.dbs.elki.logging.LoggingUtil; import de.lmu.ifi.dbs.elki.math.MathUtil; import de.lmu.ifi.dbs.elki.math.random.RandomFactory; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; @@ -37,7 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Gamma Distribution, with random generation and density functions. * * @author Erich Schubert + * @since 0.4.0 */ +@Alias("de.lmu.ifi.dbs.elki.data.synthetic.bymodel.distribution.GammaDistribution") public class GammaDistribution extends AbstractDistribution { /** * Euler–Mascheroni constant diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedExtremeValueDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedExtremeValueDistribution.java index dea33d54..ff2d8b2d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedExtremeValueDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedExtremeValueDistribution.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * from the scipy definition by having the negative shape. * * @author Erich Schubert + * @since 0.6.0 */ public class GeneralizedExtremeValueDistribution extends AbstractDistribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedLogisticAlternateDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedLogisticAlternateDistribution.java index 3c4eb761..6000a1b2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedLogisticAlternateDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedLogisticAlternateDistribution.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Where {@code shape=0} yields the regular logistic distribution. * * @author Erich Schubert + * @since 0.6.0 */ public class GeneralizedLogisticAlternateDistribution extends AbstractDistribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedLogisticDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedLogisticDistribution.java index 6cb53dc9..162b47ea 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedLogisticDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedLogisticDistribution.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Where {@code shape=1} yields the regular logistic distribution. * * @author Erich Schubert + * @since 0.6.0 */ public class GeneralizedLogisticDistribution extends AbstractDistribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedParetoDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedParetoDistribution.java index 1765ffb3..2e4a7505 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedParetoDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GeneralizedParetoDistribution.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * distributions. * * @author Erich Schubert + * @since 0.6.0 */ public class GeneralizedParetoDistribution extends AbstractDistribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GumbelDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GumbelDistribution.java index d5712582..81c0f45f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GumbelDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/GumbelDistribution.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Gumbel distribution, also known as Log-Weibull distribution. * * @author Erich Schubert + * @since 0.6.0 */ public class GumbelDistribution extends AbstractDistribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/HaltonUniformDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/HaltonUniformDistribution.java index 242815b0..e021a6f1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/HaltonUniformDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/HaltonUniformDistribution.java @@ -64,6 +64,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * for example by adding scrambling. * * @author Erich Schubert + * @since 0.5.5 */ @Reference(title = "Randomized halton sequences", authors = "Wang, X. and Hickernell, F.J.", booktitle = "Mathematical and Computer Modelling Vol. 32 (7)", url = "http://dx.doi.org/10.1016/S0895-7177(00)00178-3") public class HaltonUniformDistribution implements Distribution { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/KappaDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/KappaDistribution.java index f9d723d8..81cc8191 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/KappaDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/KappaDistribution.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * TODO: add references. * * @author Erich Schubert + * @since 0.6.0 */ public class KappaDistribution extends AbstractDistribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LaplaceDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LaplaceDistribution.java index c3826cb3..92db5dd7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LaplaceDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LaplaceDistribution.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Laplace distribution also known as double exponential distribution * * @author Erich Schubert + * @since 0.5.5 */ @Alias("DoubleExponentialDistribution") public class LaplaceDistribution extends AbstractDistribution { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogGammaAlternateDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogGammaAlternateDistribution.java index b7c38566..63f67adc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogGammaAlternateDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogGammaAlternateDistribution.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Note: this matches the loggamma of SciPy. * * @author Erich Schubert + * @since 0.6.0 */ public class LogGammaAlternateDistribution extends AbstractDistribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogGammaDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogGammaDistribution.java index 60fa5292..f8796fe2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogGammaDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogGammaDistribution.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Note: this is a different loggamma than scipy uses. * * @author Erich Schubert + * @since 0.6.0 */ public class LogGammaDistribution extends AbstractDistribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogLogisticDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogLogisticDistribution.java index c2dfcc64..c7cba5ac 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogLogisticDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogLogisticDistribution.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Log-Logistic distribution also known as Fisk distribution. * * @author Erich Schubert + * @since 0.6.0 */ @Alias({ "fisk", "loglog" }) public class LogLogisticDistribution extends AbstractDistribution { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogNormalDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogNormalDistribution.java index 86f2ea43..d5a2d099 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogNormalDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogNormalDistribution.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * <tt>scipy.stats.lognorm(logstddev, shift, math.exp(logmean))</tt> * * @author Erich Schubert + * @since 0.6.0 */ @Alias({ "lognormal" }) public class LogNormalDistribution extends AbstractDistribution { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogisticDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogisticDistribution.java index 6dcafddb..b8e4f5bc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogisticDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/LogisticDistribution.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Logistic distribution. * * @author Erich Schubert + * @since 0.6.0 */ @Alias({ "log" }) public class LogisticDistribution extends AbstractDistribution { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/NormalDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/NormalDistribution.java index 56c14eca..126db305 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/NormalDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/NormalDistribution.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Gaussian distribution aka normal distribution * * @author Erich Schubert + * @since 0.5.0 */ @Alias({ "GaussianDistribution", "normal", "gauss" }) public class NormalDistribution extends AbstractDistribution { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/PoissonDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/PoissonDistribution.java index 59bb5ba7..a67fdde1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/PoissonDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/PoissonDistribution.java @@ -47,6 +47,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * </p> * * @author Erich Schubert + * @since 0.5.0 */ public class PoissonDistribution extends AbstractDistribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/RayleighDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/RayleighDistribution.java index 0ef431e0..832952e7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/RayleighDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/RayleighDistribution.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Rayleigh distribution. * * @author Erich Schubert + * @since 0.6.0 */ public class RayleighDistribution extends AbstractDistribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/SkewGeneralizedNormalDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/SkewGeneralizedNormalDistribution.java index 8cfb3e38..0cb5bcd8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/SkewGeneralizedNormalDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/SkewGeneralizedNormalDistribution.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * multiple that go by the name of a "Generalized Normal Distribution". * * @author Erich Schubert + * @since 0.6.0 */ public class SkewGeneralizedNormalDistribution extends AbstractDistribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/StudentsTDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/StudentsTDistribution.java index ced66f37..0bde3300 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/StudentsTDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/StudentsTDistribution.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * FIXME: add quantile and random function! * * @author Jan Brusis + * @since 0.5.0 */ public class StudentsTDistribution extends AbstractDistribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/UniformDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/UniformDistribution.java index 875ee737..301dc8dd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/UniformDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/UniformDistribution.java @@ -26,6 +26,7 @@ package de.lmu.ifi.dbs.elki.math.statistics.distribution; import java.util.Random; import de.lmu.ifi.dbs.elki.math.random.RandomFactory; +import de.lmu.ifi.dbs.elki.utilities.Alias; import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; @@ -34,7 +35,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Uniform distribution. * * @author Erich Schubert + * @since 0.2 */ +@Alias("de.lmu.ifi.dbs.elki.data.synthetic.bymodel.distribution.UniformDistribution") public class UniformDistribution extends AbstractDistribution { /** * Minimum diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/WaldDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/WaldDistribution.java index b96f133e..11135fed 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/WaldDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/WaldDistribution.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Inverse Gaussian distribution aka Wald distribution * * @author Erich Schubert + * @since 0.6.0 */ @Alias({ "InverseGaussianDistribution", "invgauss" }) public class WaldDistribution extends AbstractDistribution { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/WeibullDistribution.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/WeibullDistribution.java index 86ac24d9..34791481 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/WeibullDistribution.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/WeibullDistribution.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Weibull distribution. * * @author Erich Schubert + * @since 0.6.0 */ public class WeibullDistribution extends AbstractDistribution { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractExpMADEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractExpMADEstimator.java index 5ec6aaf3..6c08abd8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractExpMADEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractExpMADEstimator.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.NumberArrayAdapter * Abstract base class for estimators based on the median and MAD. * * @author Erich Schubert + * @since 0.6.0 * * @param <D> Distribution to generate. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractLMMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractLMMEstimator.java index 03e21b13..86455d52 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractLMMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractLMMEstimator.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.NumberArrayAdapter * Abstract base class for L-Moments based estimators (LMM). * * @author Erich Schubert + * @since 0.5.0 * * @param <D> Distribution class. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractLogMADEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractLogMADEstimator.java index 8e6ca26d..170b4fab 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractLogMADEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractLogMADEstimator.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.NumberArrayAdapter * Abstract base class for estimators based on the median and MAD. * * @author Erich Schubert + * @since 0.6.0 * * @param <D> Distribution to generate. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractLogMOMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractLogMOMEstimator.java index ad260a6f..9d6e5983 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractLogMOMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractLogMOMEstimator.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.NumberArrayAdapter * Abstract base class for estimators based on the statistical moments. * * @author Erich Schubert + * @since 0.5.0 * * @param <D> Distribution to generate. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractLogMeanVarianceEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractLogMeanVarianceEstimator.java index b76176e4..464d7072 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractLogMeanVarianceEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractLogMeanVarianceEstimator.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.NumberArrayAdapter * only). * * @author Erich Schubert + * @since 0.5.0 * * @param <D> Distribution to estimate. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractMADEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractMADEstimator.java index 9c630990..746408bb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractMADEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractMADEstimator.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.NumberArrayAdapter * Abstract base class for estimators based on the median and MAD. * * @author Erich Schubert + * @since 0.6.0 * * @param <D> Distribution to generate. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractMOMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractMOMEstimator.java index 8caf4cda..d9ca2dff 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractMOMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractMOMEstimator.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.NumberArrayAdapter * Abstract base class for estimators based on the statistical moments. * * @author Erich Schubert + * @since 0.5.0 * * @param <D> Distribution to generate. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractMeanVarianceEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractMeanVarianceEstimator.java index e9058df4..20abf67d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractMeanVarianceEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/AbstractMeanVarianceEstimator.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.NumberArrayAdapter * only). * * @author Erich Schubert + * @since 0.5.0 * * @param <D> Distribution to estimate. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/CauchyMADEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/CauchyMADEstimator.java index 9ced6b54..f4db08ff 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/CauchyMADEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/CauchyMADEstimator.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has CauchyDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/DistributionEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/DistributionEstimator.java index b31acf66..91d29c0e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/DistributionEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/DistributionEstimator.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.NumberArrayAdapter * Estimate distribution parameters from a sample. * * @author Erich Schubert + * @since 0.5.0 * * @param <D> Distribution type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/EMGOlivierNorbergEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/EMGOlivierNorbergEstimator.java index 38aa5380..f1fa5d95 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/EMGOlivierNorbergEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/EMGOlivierNorbergEstimator.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Naive distribution estimation using mean and sample variance. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has ExponentiallyModifiedGaussianDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExpMADDistributionEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExpMADDistributionEstimator.java index b2a935c2..51f5e46c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExpMADDistributionEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExpMADDistributionEstimator.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.math.statistics.distribution.Distribution; * exponentiated data. * * @author Erich Schubert + * @since 0.5.0 * * @param <D> Distribution estimated. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExponentialLMMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExponentialLMMEstimator.java index c33bbdfd..88ba769a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExponentialLMMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExponentialLMMEstimator.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has ExponentialDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExponentialMADEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExponentialMADEstimator.java index e639dd63..6c2d21e0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExponentialMADEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExponentialMADEstimator.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has ExponentialDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExponentialMOMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExponentialMOMEstimator.java index cce8c503..726c85b8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExponentialMOMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExponentialMOMEstimator.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * maximum-likelihood estimate (MLE), but not very robust. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has ExponentialDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExponentialMedianEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExponentialMedianEstimator.java index 0bda6711..17db5724 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExponentialMedianEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/ExponentialMedianEstimator.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has ExponentialDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GammaChoiWetteEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GammaChoiWetteEstimator.java index 3714b89c..cc746ece 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GammaChoiWetteEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GammaChoiWetteEstimator.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has GammaDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GammaLMMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GammaLMMEstimator.java index 8024a326..29f2af63 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GammaLMMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GammaLMMEstimator.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has GammaDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GammaMADEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GammaMADEstimator.java index 7032ede8..90076359 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GammaMADEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GammaMADEstimator.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has GammaDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GammaMOMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GammaMOMEstimator.java index 11aeb527..346a0fd4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GammaMOMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GammaMOMEstimator.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has GammaDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GeneralizedExtremeValueLMMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GeneralizedExtremeValueLMMEstimator.java index 1e60f8be..79020a59 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GeneralizedExtremeValueLMMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GeneralizedExtremeValueLMMEstimator.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has GeneralizedExtremeValueDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GeneralizedLogisticAlternateLMMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GeneralizedLogisticAlternateLMMEstimator.java index 1b9c3879..276f538a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GeneralizedLogisticAlternateLMMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GeneralizedLogisticAlternateLMMEstimator.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has GeneralizedLogisticAlternateDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GeneralizedParetoLMMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GeneralizedParetoLMMEstimator.java index c32f1de0..aa999b1f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GeneralizedParetoLMMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GeneralizedParetoLMMEstimator.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has GeneralizedParetoDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GumbelLMMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GumbelLMMEstimator.java index d721d083..2b29b079 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GumbelLMMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GumbelLMMEstimator.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has GumbelDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GumbelMADEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GumbelMADEstimator.java index 2e1b4f99..7e7cd8a9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GumbelMADEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/GumbelMADEstimator.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has GumbelDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LMMDistributionEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LMMDistributionEstimator.java index 1480d96f..0118b403 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LMMDistributionEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LMMDistributionEstimator.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.math.statistics.distribution.Distribution; * (LMM). * * @author Erich Schubert + * @since 0.5.0 * * @param <D> Distribution class. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LaplaceLMMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LaplaceLMMEstimator.java index c9c6d0bb..dc63ed27 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LaplaceLMMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LaplaceLMMEstimator.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Estimate Laplace distribution parameters using the method of L-Moments (LMM). * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has LaplaceDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LaplaceMADEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LaplaceMADEstimator.java index 63355fb5..c09ad3ca 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LaplaceMADEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LaplaceMADEstimator.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has LaplaceDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LaplaceMLEEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LaplaceMLEEstimator.java index 42316b32..42f27d83 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LaplaceMLEEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LaplaceMLEEstimator.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has LaplaceDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogGammaAlternateExpMADEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogGammaAlternateExpMADEstimator.java index 2b742ed2..43a2b83e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogGammaAlternateExpMADEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogGammaAlternateExpMADEstimator.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * A modified algorithm for LogGamma distributions. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has LogGammaAlternateDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogGammaChoiWetteEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogGammaChoiWetteEstimator.java index 80d02555..2f1577df 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogGammaChoiWetteEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogGammaChoiWetteEstimator.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has LogGammaDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogGammaLogMADEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogGammaLogMADEstimator.java index db228b37..7458b485 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogGammaLogMADEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogGammaLogMADEstimator.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * A modified algorithm for LogGamma distributions. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has LogGammaDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogGammaLogMOMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogGammaLogMOMEstimator.java index 193cc5ab..1e8c3b87 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogGammaLogMOMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogGammaLogMOMEstimator.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * transformed values. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has LogGammaDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogLogisticMADEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogLogisticMADEstimator.java index 942cb6af..a10ad4e4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogLogisticMADEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogLogisticMADEstimator.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has LogLogisticDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogMADDistributionEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogMADDistributionEstimator.java index 596315b3..d66d02a5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogMADDistributionEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogMADDistributionEstimator.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.math.statistics.distribution.Distribution; * Distribuition estimators that use the method of moments (MOM) in logspace. * * @author Erich Schubert + * @since 0.5.0 * * @param <D> Distribution estimated. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogMOMDistributionEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogMOMDistributionEstimator.java index bd9ec4b2..3e6d9896 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogMOMDistributionEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogMOMDistributionEstimator.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.statistics.distribution.Distribution; * i.e. that only need the statistical moments of a data set after logarithms. * * @author Erich Schubert + * @since 0.5.0 * * @param <D> Distribution estimated. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalBilkovaLMMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalBilkovaLMMEstimator.java index 4b6d62d5..658655dc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalBilkovaLMMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalBilkovaLMMEstimator.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * generalized normal distribution, as used by Hosking. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has LogNormalDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalLMMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalLMMEstimator.java index 57c5c745..854053c0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalLMMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalLMMEstimator.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has LogNormalDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalLevenbergMarquardtKDEEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalLevenbergMarquardtKDEEstimator.java index a8b84c1a..2c571e39 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalLevenbergMarquardtKDEEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalLevenbergMarquardtKDEEstimator.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * observed. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has LogNormalDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalLogMADEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalLogMADEstimator.java index 11c3c7ed..2f7e3850 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalLogMADEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalLogMADEstimator.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has LogNormalDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalLogMOMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalLogMOMEstimator.java index 6888e4ad..93ebdca3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalLogMOMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogNormalLogMOMEstimator.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * This is a maximum-likelihood-estimator (MLE). * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has LogNormalDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogisticLMMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogisticLMMEstimator.java index 7c4f20be..30c85bb4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogisticLMMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogisticLMMEstimator.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has LogisticDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogisticMADEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogisticMADEstimator.java index 1524e698..7d56fc5d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogisticMADEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/LogisticMADEstimator.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has LogisticDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/MADDistributionEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/MADDistributionEstimator.java index 80112d22..9ffb26fc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/MADDistributionEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/MADDistributionEstimator.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.math.statistics.distribution.Distribution; * need the statistical moments of a data set. * * @author Erich Schubert + * @since 0.5.0 * * @param <D> Distribution estimated. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/MOMDistributionEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/MOMDistributionEstimator.java index a85dfbd2..1968ee63 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/MOMDistributionEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/MOMDistributionEstimator.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.statistics.distribution.Distribution; * need the statistical moments of a data set. * * @author Erich Schubert + * @since 0.5.0 * * @param <D> Distribution estimated. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/MeanVarianceDistributionEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/MeanVarianceDistributionEstimator.java index 128f2ece..10c638d7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/MeanVarianceDistributionEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/MeanVarianceDistributionEstimator.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.MeanVariance; * These can implicitely (obviously) also handle full statistical moments. * * @author Erich Schubert + * @since 0.5.0 * * @param <D> Distribution type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/NormalLMMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/NormalLMMEstimator.java index 0a569de5..96dcf336 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/NormalLMMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/NormalLMMEstimator.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has NormalDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/NormalLevenbergMarquardtKDEEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/NormalLevenbergMarquardtKDEEstimator.java index 5f6e5672..54a83355 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/NormalLevenbergMarquardtKDEEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/NormalLevenbergMarquardtKDEEstimator.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * observed. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has NormalDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/NormalMADEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/NormalMADEstimator.java index 6bb5a9ea..cdbebc5b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/NormalMADEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/NormalMADEstimator.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has NormalDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/NormalMOMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/NormalMOMEstimator.java index 7f5f179b..12aeaecf 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/NormalMOMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/NormalMOMEstimator.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * extreme values. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has NormalDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/RayleighLMMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/RayleighLMMEstimator.java index a7afad4c..cd96506f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/RayleighLMMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/RayleighLMMEstimator.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * the method of L-Moments (LMM). * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has RayleighDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/RayleighMADEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/RayleighMADEstimator.java index 39babfe4..bcd67e0d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/RayleighMADEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/RayleighMADEstimator.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has RayleighDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/RayleighMLEEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/RayleighMLEEstimator.java index 4891f9bd..c0f54916 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/RayleighMLEEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/RayleighMLEEstimator.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * maximum likelihood estimate. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has RayleighDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/SkewGNormalLMMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/SkewGNormalLMMEstimator.java index 15e51d40..2000e841 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/SkewGNormalLMMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/SkewGNormalLMMEstimator.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has SkewGeneralizedNormalDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/UniformEnhancedMinMaxEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/UniformEnhancedMinMaxEstimator.java index 8b12ace1..b33b70da 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/UniformEnhancedMinMaxEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/UniformEnhancedMinMaxEstimator.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * enhances the interval appropriately. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has UniformDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/UniformLMMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/UniformLMMEstimator.java index 5008eb85..c7134ee1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/UniformLMMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/UniformLMMEstimator.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * L-Moments (LMM). * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has UniformDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/UniformMADEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/UniformMADEstimator.java index 781f72ec..29004489 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/UniformMADEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/UniformMADEstimator.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has UniformDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/UniformMinMaxEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/UniformMinMaxEstimator.java index a40c4686..e140ec2c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/UniformMinMaxEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/UniformMinMaxEstimator.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Estimate the uniform distribution by computing min and max. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has UniformDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WaldMLEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WaldMLEstimator.java index d8147006..1088dd37 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WaldMLEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WaldMLEstimator.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Estimate parameter of the Wald distribution. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has WaldDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WaldMOMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WaldMOMEstimator.java index 1ccfdf08..da56827f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WaldMOMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WaldMOMEstimator.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Estimate parameter of the Wald distribution. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has WaldDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WeibullLMMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WeibullLMMEstimator.java index 4ea8faa7..0756c113 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WeibullLMMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WeibullLMMEstimator.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * (LMM). * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has WeibullDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WeibullLogMADEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WeibullLogMADEstimator.java index 8dd068e0..22f6effc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WeibullLogMADEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WeibullLogMADEstimator.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has WeibullDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WeibullLogMOMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WeibullLogMOMEstimator.java index dd02dea4..3a96dcfd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WeibullLogMOMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/WeibullLogMOMEstimator.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * doesn't use "the" statistical moments. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has WeibullDistribution - - estimates */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/meta/BestFitEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/meta/BestFitEstimator.java index 81e2abfd..c3409d9b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/meta/BestFitEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/meta/BestFitEstimator.java @@ -87,6 +87,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * choose whichever works best. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.uses MOMDistributionEstimator * @apiviz.uses MADDistributionEstimator diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/meta/TrimmedEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/meta/TrimmedEstimator.java index ed1ffab8..54fda81c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/meta/TrimmedEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/meta/TrimmedEstimator.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * analyzes it using another estimator. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.uses DistributionEstimator * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/meta/WinsorisingEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/meta/WinsorisingEstimator.java index ad8e532d..56a7ee94 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/meta/WinsorisingEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/distribution/estimator/meta/WinsorisingEstimator.java @@ -51,6 +51,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * </p> * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.uses DistributionEstimator * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/AbstractIntrinsicDimensionalityEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/AbstractIntrinsicDimensionalityEstimator.java index 4bea246b..c3dde05f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/AbstractIntrinsicDimensionalityEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/AbstractIntrinsicDimensionalityEstimator.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.NumberArrayAdapter * Abstract base class for ID estimators. * * @author Erich Schubert + * @since 0.7.0 */ public abstract class AbstractIntrinsicDimensionalityEstimator implements IntrinsicDimensionalityEstimator { @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/AggregatedHillEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/AggregatedHillEstimator.java index 732d74ab..2cd35e60 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/AggregatedHillEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/AggregatedHillEstimator.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * @author Jonathan von Brünken * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "R. Huisman and K. G. Koedijk and C. J. M. Kool and F. Palm", // title = "Tail-Index Estimates in Small Samples", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/EnsembleEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/EnsembleEstimator.java index 019580fa..83dbb8bc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/EnsembleEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/EnsembleEstimator.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.NumberArrayAdapter * This is an experimental estimator. Please cite ELKI when using. * * @author Erich Schubert + * @since 0.7.0 */ public class EnsembleEstimator extends AbstractIntrinsicDimensionalityEstimator { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/GEDEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/GEDEstimator.java index 2514006c..82e5486b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/GEDEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/GEDEstimator.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * @author Jonathan von Brünken * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "M. E. Houle, H. Kashima, M. Nett", // title = "Generalized expansion dimension", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/HillEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/HillEstimator.java index 228aa5c0..0d761b8e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/HillEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/HillEstimator.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * @author Jonathan von Brünken * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "B. M. Hill", // title = "A simple general approach to inference about the tail of a distribution", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/IntrinsicDimensionalityEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/IntrinsicDimensionalityEstimator.java index 978869b0..159b5c98 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/IntrinsicDimensionalityEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/IntrinsicDimensionalityEstimator.java @@ -28,6 +28,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.NumberArrayAdapter * Estimate the intrinsic dimensionality from a distance list. * * @author Erich Schubert + * @since 0.7.0 */ public interface IntrinsicDimensionalityEstimator { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/LMomentsEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/LMomentsEstimator.java index 671b3e36..1435945d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/LMomentsEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/LMomentsEstimator.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * @author Jonathan von Brünken * @author Erich Schubert + * @since 0.7.0 */ public class LMomentsEstimator extends AbstractIntrinsicDimensionalityEstimator { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/MOMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/MOMEstimator.java index 174d4bf7..8379f56b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/MOMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/MOMEstimator.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "L. Amsaleg and O. Chelly and T. Furon and S. Girard and M. E. Houle and K. Kawarabayashi and M. Nett", // title = "Estimating Local Intrinsic Dimensionality", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/PWM2Estimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/PWM2Estimator.java index 5d16fa48..f8176ec8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/PWM2Estimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/PWM2Estimator.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * this. This hack causes this estimator to have a bias to underestimate the ID. * * @author Erich Schubert + * @since 0.7.0 */ public class PWM2Estimator extends AbstractIntrinsicDimensionalityEstimator { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/PWMEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/PWMEstimator.java index 9c9db16b..bcc6a21e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/PWMEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/PWMEstimator.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * @author Jonathan von Brünken * @author Erich Schubert + * @since 0.7.0 */ public class PWMEstimator extends AbstractIntrinsicDimensionalityEstimator { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/RVEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/RVEstimator.java index 52976bf4..dcff6031 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/RVEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/RVEstimator.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Oussama Chelly + * @since 0.7.0 */ @Reference(authors = "L. Amsaleg and O. Chelly and T. Furon and S. Girard and M. E. Houle and K. Kawarabayashi and M. Nett", // title = "Estimating Local Intrinsic Dimensionality", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/ZipfEstimator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/ZipfEstimator.java index c5bd60a2..21cdb93f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/ZipfEstimator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/intrinsicdimensionality/ZipfEstimator.java @@ -55,6 +55,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * TODO: possible to improve numerical precision via log1p? * * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "M. Kratz and S. I. Resnick", // title = "On Least Squares Estimates of an Exponential Tail Coefficient", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/BiweightKernelDensityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/BiweightKernelDensityFunction.java index d9252e86..7dd76cc0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/BiweightKernelDensityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/BiweightKernelDensityFunction.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Biweight (Quartic) kernel density estimator. * * @author Erich Schubert + * @since 0.6.0 */ @Alias({ "biweight", "quartic" }) public final class BiweightKernelDensityFunction implements KernelDensityFunction { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/CosineKernelDensityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/CosineKernelDensityFunction.java index b51b308e..eaabde55 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/CosineKernelDensityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/CosineKernelDensityFunction.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Cosine kernel density estimator. * * @author Erich Schubert + * @since 0.6.0 */ public final class CosineKernelDensityFunction implements KernelDensityFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/EpanechnikovKernelDensityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/EpanechnikovKernelDensityFunction.java index b83ce76c..cde35380 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/EpanechnikovKernelDensityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/EpanechnikovKernelDensityFunction.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Epanechnikov kernel density estimator. * * @author Erich Schubert + * @since 0.6.0 */ @Alias({ "epanechnikov" }) public final class EpanechnikovKernelDensityFunction implements KernelDensityFunction { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/GaussianKernelDensityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/GaussianKernelDensityFunction.java index adf9189e..5ec0fe94 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/GaussianKernelDensityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/GaussianKernelDensityFunction.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Gaussian kernel density estimator. * * @author Erich Schubert + * @since 0.6.0 */ public final class GaussianKernelDensityFunction implements KernelDensityFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/KernelDensityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/KernelDensityFunction.java index c53d5da1..ecc8567d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/KernelDensityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/KernelDensityFunction.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * Note: as of now, this API does not support asymmetric kernels. * * @author Erich Schubert + * @since 0.6.0 */ public interface KernelDensityFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/TriangularKernelDensityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/TriangularKernelDensityFunction.java index 0175f163..923f45e1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/TriangularKernelDensityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/TriangularKernelDensityFunction.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Triangular kernel density estimator. * * @author Erich Schubert + * @since 0.6.0 */ public final class TriangularKernelDensityFunction implements KernelDensityFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/TricubeKernelDensityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/TricubeKernelDensityFunction.java index c2cf5152..472646a0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/TricubeKernelDensityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/TricubeKernelDensityFunction.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Tricube kernel density estimator. * * @author Erich Schubert + * @since 0.6.0 */ public final class TricubeKernelDensityFunction implements KernelDensityFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/TriweightKernelDensityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/TriweightKernelDensityFunction.java index fd3b38e3..2573723f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/TriweightKernelDensityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/TriweightKernelDensityFunction.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Triweight kernel density estimator. * * @author Erich Schubert + * @since 0.6.0 */ @Alias({ "triweight" }) public final class TriweightKernelDensityFunction implements KernelDensityFunction { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/UniformKernelDensityFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/UniformKernelDensityFunction.java index a27d0ba4..bf07911d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/UniformKernelDensityFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/kernelfunctions/UniformKernelDensityFunction.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * Uniform / Rectangular kernel density estimator. * * @author Erich Schubert + * @since 0.6.0 */ public final class UniformKernelDensityFunction implements KernelDensityFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/AndersonDarlingTest.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/AndersonDarlingTest.java index de418391..174563b7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/AndersonDarlingTest.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/AndersonDarlingTest.java @@ -62,6 +62,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "T. W. Anderson, and D. A. Darling", // title = "Asymptotic theory of certain 'goodness of fit' criteria based on stochastic processes", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/GoodnessOfFitTest.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/GoodnessOfFitTest.java index 2882390a..a1c9aa7a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/GoodnessOfFitTest.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/GoodnessOfFitTest.java @@ -33,6 +33,7 @@ package de.lmu.ifi.dbs.elki.math.statistics.tests; * * @author Jan Brusis * @author Erich Schubert + * @since 0.5.0 */ public interface GoodnessOfFitTest { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/KolmogorovSmirnovTest.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/KolmogorovSmirnovTest.java index 3e2d98e4..f0b2ea95 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/KolmogorovSmirnovTest.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/KolmogorovSmirnovTest.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * difference of the empirical CDFs. * * @author Erich Schubert + * @since 0.5.0 */ public class KolmogorovSmirnovTest implements GoodnessOfFitTest { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/StandardizedTwoSampleAndersonDarlingTest.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/StandardizedTwoSampleAndersonDarlingTest.java index d2f9777c..a2b83496 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/StandardizedTwoSampleAndersonDarlingTest.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/StandardizedTwoSampleAndersonDarlingTest.java @@ -57,6 +57,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "F. W. Scholz, and M. A. Stephens", // title = "K-sample Anderson–Darling tests", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/WelchTTest.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/WelchTTest.java index 91049bad..50e55f58 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/WelchTTest.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/math/statistics/tests/WelchTTest.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * * @author Jan Brusis * @author Erich Schubert + * @since 0.5.0 * * @apiviz.uses StudentsTDistribution */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/Executor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/Executor.java index c6659aad..93461872 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/Executor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/Executor.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.parallel.variables.SharedVariable; * Processor executor. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.uses de.lmu.ifi.dbs.elki.parallel.processor.Processor * @apiviz.uses SharedVariable diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/ParallelCore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/ParallelCore.java index 074a3562..9e84da8a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/ParallelCore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/ParallelCore.java @@ -36,6 +36,7 @@ import java.util.concurrent.atomic.AtomicInteger; * TODO: make configurable how many threads are used. * * @author Erich Schubert + * @since 0.7.0 */ public class ParallelCore { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/ParallelExecutor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/ParallelExecutor.java index f3da8bc0..dc7c8b1c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/ParallelExecutor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/ParallelExecutor.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.parallel.variables.SharedVariable.Instance; * TODO: add progress * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has BlockArrayRunner * @apiviz.uses ParallelCore diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/SingleThreadedExecutor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/SingleThreadedExecutor.java index 21c695f1..82acc4e7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/SingleThreadedExecutor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/SingleThreadedExecutor.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.parallel.variables.SharedVariable.Instance; * Currently not used. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has SingleThreadedRunner */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/AbstractDoubleProcessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/AbstractDoubleProcessor.java index 8d640af2..c7d56f65 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/AbstractDoubleProcessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/AbstractDoubleProcessor.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.parallel.variables.SharedDouble; * Abstract base class for processors that output double values. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has Instance * @apiviz.uses SharedDouble diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/DoubleMinMaxProcessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/DoubleMinMaxProcessor.java index b751b9e3..35fb6517 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/DoubleMinMaxProcessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/DoubleMinMaxProcessor.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.parallel.variables.SharedDouble; * Sink collecting minimum and maximum values. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has Instance * @apiviz.uses SharedDouble diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/KDistanceProcessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/KDistanceProcessor.java index 0b68a88a..4166a225 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/KDistanceProcessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/KDistanceProcessor.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.parallel.variables.SharedObject; * Needs the k nearest neighbors as input, for example from {@link KNNProcessor}. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has Instance * @apiviz.uses KNNList diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/KNNProcessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/KNNProcessor.java index d8d25bdc..86ab87e8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/KNNProcessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/KNNProcessor.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.parallel.variables.SharedObject; * Processor to compute the kNN of each object. * * @author Erich Schubert + * @since 0.7.0 * * @param <O> Object type * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/Processor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/Processor.java index a2bd7c3e..024bab94 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/Processor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/Processor.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.parallel.Executor; * Class to represent a processor factory. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has Instance */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/WriteDataStoreProcessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/WriteDataStoreProcessor.java index 06bac212..710b83a5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/WriteDataStoreProcessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/WriteDataStoreProcessor.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.parallel.variables.SharedObject; * Output channel to store data in a {@link WritableDataStore}. * * @author Erich Schubert + * @since 0.7.0 * * @param <T> data type * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/WriteDoubleDataStoreProcessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/WriteDoubleDataStoreProcessor.java index ff9f25c9..2967de33 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/WriteDoubleDataStoreProcessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/WriteDoubleDataStoreProcessor.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.parallel.variables.SharedDouble; * Write double values into a {@link WritableDoubleDataStore}. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has Instance * @apiviz.uses SharedDouble diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/WriteIntegerDataStoreProcessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/WriteIntegerDataStoreProcessor.java index e71d6736..b6403ba7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/WriteIntegerDataStoreProcessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/processor/WriteIntegerDataStoreProcessor.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.parallel.variables.SharedInteger; * Write int values into a {@link WritableIntegerDataStore}. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has Instance * @apiviz.uses SharedInteger diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/variables/SharedDouble.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/variables/SharedDouble.java index ea76297a..b0f75c66 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/variables/SharedDouble.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/variables/SharedDouble.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.parallel.variables; * Direct channel connecting two processors. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has SharedDouble.Instance */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/variables/SharedInteger.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/variables/SharedInteger.java index 43471144..bb10e600 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/variables/SharedInteger.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/variables/SharedInteger.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.parallel.variables; * Direct channel connecting two processors. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has SharedInteger.Instance */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/variables/SharedObject.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/variables/SharedObject.java index 83404cce..dd047f95 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/variables/SharedObject.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/variables/SharedObject.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.parallel.variables; * Variable to share between different processors (within one thread only!) * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has SharedObject.Instance * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/variables/SharedVariable.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/variables/SharedVariable.java index fd5808fb..6499c82b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/variables/SharedVariable.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/parallel/variables/SharedVariable.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.parallel.variables; * Shared variables storing a particular type. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.has SharedVariable.Instance * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/AbstractExternalizablePage.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/AbstractExternalizablePage.java index ee4b5972..c7be2809 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/AbstractExternalizablePage.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/AbstractExternalizablePage.java @@ -31,6 +31,7 @@ import java.io.ObjectOutput; * Abstract superclass for pages. * * @author Elke Achtert + * @since 0.2 */ // todo elke revise comments public abstract class AbstractExternalizablePage implements ExternalizablePage { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/AbstractPageFile.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/AbstractPageFile.java index 6a47ac38..78978763 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/AbstractPageFile.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/AbstractPageFile.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.logging.statistics.Counter; * (in-memory and on-disk). * * @author Erich Schubert + * @since 0.4.0 * * @param <P> page type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/AbstractPageFileFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/AbstractPageFileFactory.java index a52b21bc..26bb95d2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/AbstractPageFileFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/AbstractPageFileFactory.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * Abstract page file factory. * * @author Erich Schubert + * @since 0.6.0 * * @param <P> Page type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/AbstractStoringPageFile.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/AbstractStoringPageFile.java index a26d9a4f..3b0b4f8f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/AbstractStoringPageFile.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/AbstractStoringPageFile.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.logging.statistics.LongStatistic; * objects that implement the <code>Page</code> interface. * * @author Elke Achtert + * @since 0.4.0 * * @param <P> Page type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/DefaultPageHeader.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/DefaultPageHeader.java index 0d6b8950..5e056f05 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/DefaultPageHeader.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/DefaultPageHeader.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteArrayUtil; * Default implementation of a page header. * * @author Elke Achtert + * @since 0.2 */ public class DefaultPageHeader implements PageHeader { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/ExternalizablePage.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/ExternalizablePage.java index 8c9c124d..3ffc4a35 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/ExternalizablePage.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/ExternalizablePage.java @@ -29,6 +29,7 @@ import java.io.Externalizable; * Base interface for externalizable pages. * * @author Erich Schubert + * @since 0.4.0 */ // TODO: replace with the newer ByteSerializers public interface ExternalizablePage extends Page, Externalizable { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/LRUCache.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/LRUCache.java index e9fd7db4..5c78e3ae 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/LRUCache.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/LRUCache.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * object is dropped. * * @author Elke Achtert + * @since 0.2 * * @apiviz.uses PageFile * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/LRUCachePageFileFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/LRUCachePageFileFactory.java index fa248a52..396166c8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/LRUCachePageFileFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/LRUCachePageFileFactory.java @@ -1,12 +1,5 @@ package de.lmu.ifi.dbs.elki.persistent; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.constraints.CommonConstraints; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; - /* This file is part of ELKI: Environment for Developing KDD-Applications Supported by Index-Structures @@ -30,10 +23,18 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; along with this program. If not, see <http://www.gnu.org/licenses/>. */ +import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.constraints.CommonConstraints; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameterization; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; + /** * Page file factory for memory page files. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has LRUCache * @apiviz.composedOf PageFileFactory diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/MemoryPageFile.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/MemoryPageFile.java index f0b37914..e6ed70c5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/MemoryPageFile.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/MemoryPageFile.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * Implemented as a Map with keys representing the ids of the saved pages. * * @author Elke Achtert + * @since 0.2 * * @param <P> Page type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/MemoryPageFileFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/MemoryPageFileFactory.java index 3323fd38..1f55cfab 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/MemoryPageFileFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/MemoryPageFileFactory.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.persistent; * Page file factory for memory page files. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has MemoryPageFile * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/OnDiskArray.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/OnDiskArray.java index d379dc9a..448561d1 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/OnDiskArray.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/OnDiskArray.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteArrayUtil; * by the actual data. * * @author Erich Schubert + * @since 0.2 * * @apiviz.composedOf RandomAccessFile */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/OnDiskArrayPageFile.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/OnDiskArrayPageFile.java index 5c2a56c2..111b6490 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/OnDiskArrayPageFile.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/OnDiskArrayPageFile.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.ByteBufferInputStream; * single file. All pages are stored in a specified directory. * * @author Elke Achtert + * @since 0.2 * * @apiviz.composedOf OnDiskArray * @apiviz.composedOf PageHeader diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/OnDiskArrayPageFileFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/OnDiskArrayPageFileFactory.java index d5351d3e..3b60c51d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/OnDiskArrayPageFileFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/OnDiskArrayPageFileFactory.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.FileParameter; * Page file factory for disk-based page files. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has OnDiskArrayPageFile * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/OnDiskUpperTriangleMatrix.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/OnDiskUpperTriangleMatrix.java index 4faa1e67..9cd7acdf 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/OnDiskUpperTriangleMatrix.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/OnDiskUpperTriangleMatrix.java @@ -34,6 +34,7 @@ import java.nio.ByteBuffer; * @apiviz.composedOf OnDiskArray * * @author Erich Schubert + * @since 0.2 */ public class OnDiskUpperTriangleMatrix { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/Page.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/Page.java index 042fa893..a0c7e596 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/Page.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/Page.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.persistent; * persistently saved. * * @author Elke Achtert + * @since 0.2 * * @apiviz.excludeSubtypes */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PageFile.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PageFile.java index af791951..366ac6c4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PageFile.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PageFile.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.persistent; * Page file interface. * * @author Erich Schubert + * @since 0.2 * * @apiviz.has Page * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PageFileFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PageFileFactory.java index df84defc..49400571 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PageFileFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PageFileFactory.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.persistent; * Factory interface for generating page files. * * @author Erich Schubert + * @since 0.4.0 * * @param <P> Page type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PageHeader.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PageHeader.java index 582ccfc6..1171b41e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PageHeader.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PageHeader.java @@ -31,6 +31,7 @@ import java.io.RandomAccessFile; * must at least store the size of a page in Bytes. * * @author Elke Achtert + * @since 0.2 */ public interface PageHeader { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PersistentPageFile.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PersistentPageFile.java index c6068edc..3103693f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PersistentPageFile.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PersistentPageFile.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * single file. All pages are stored in a specified directory. * * @author Elke Achtert + * @since 0.2 * * @apiviz.composedOf PageHeader * @apiviz.composedOf RandomAccessFile diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PersistentPageFileFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PersistentPageFileFactory.java index 4d44381a..405db531 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PersistentPageFileFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/persistent/PersistentPageFileFactory.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.FileParameter; * Page file factory for disk-based page files. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has PersistentPageFile * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/AbstractHierarchicalResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/AbstractHierarchicalResult.java index e45c8106..80fee1a5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/AbstractHierarchicalResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/AbstractHierarchicalResult.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.result; * Abstract class for a result object with hierarchy * * @author Erich Schubert + * @since 0.4.0 */ public abstract class AbstractHierarchicalResult implements HierarchicalResult { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/BasicResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/BasicResult.java index 527b086c..c0db5ae2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/BasicResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/BasicResult.java @@ -29,6 +29,7 @@ package de.lmu.ifi.dbs.elki.result; * stores the required short and long result names. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ClusteringVectorDumper.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ClusteringVectorDumper.java index b2f27abb..f4988e72 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ClusteringVectorDumper.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ClusteringVectorDumper.java @@ -62,6 +62,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.StringParameter; * {@link de.lmu.ifi.dbs.elki.algorithm.clustering.meta.ExternalClustering}. * * @author Erich Schubert + * @since 0.7.0 */ public class ClusteringVectorDumper implements ResultHandler { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/CollectionResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/CollectionResult.java index 0128e533..d1a86481 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/CollectionResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/CollectionResult.java @@ -32,6 +32,7 @@ import java.util.Iterator; * For example, a list of NumberVectors. * * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/DBIDSelection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/DBIDSelection.java index c2cb809a..47bb25eb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/DBIDSelection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/DBIDSelection.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDs; * * @author Heidi Kolb * @author Erich Schubert + * @since 0.4.0 */ public class DBIDSelection { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/DiscardResultHandler.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/DiscardResultHandler.java index 5b395de8..2fdbb009 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/DiscardResultHandler.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/DiscardResultHandler.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.result; * benchmarks. * * @author Erich Schubert + * @since 0.2 */ public class DiscardResultHandler implements ResultHandler { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/EvaluationResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/EvaluationResult.java index 8790a3f5..7cf49e1b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/EvaluationResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/EvaluationResult.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterStream; * Abstract evaluation result. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf EvaluationResult.MeasurementGroup */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/FrequentItemsetsResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/FrequentItemsetsResult.java index ae34e4c6..e0f8a314 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/FrequentItemsetsResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/FrequentItemsetsResult.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterStream; * Result class for Apriori Algorithm. * * @author Erich Schubert + * @since 0.2 */ public class FrequentItemsetsResult extends BasicResult implements TextWriteable { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/HierarchicalResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/HierarchicalResult.java index 383c3ad1..b7611d94 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/HierarchicalResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/HierarchicalResult.java @@ -31,6 +31,7 @@ package de.lmu.ifi.dbs.elki.result; * delegate is to keep the APIs simpler, and thus make ELKI development easier. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf ResultHierarchy */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/HistogramResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/HistogramResult.java index fde386e5..5065e2e0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/HistogramResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/HistogramResult.java @@ -29,6 +29,7 @@ import java.util.Collection; * Histogram result. * * @author Erich Schubert + * @since 0.3 * * @param <O> Object class (e.g. {@link de.lmu.ifi.dbs.elki.data.DoubleVector}) */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/IterableResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/IterableResult.java index 8d5d6c61..3126569e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/IterableResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/IterableResult.java @@ -30,6 +30,7 @@ import java.util.Iterator; * (At least when the class O is TextWriteable) * * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/KMLOutputHandler.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/KMLOutputHandler.java index de5fc586..121cff56 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/KMLOutputHandler.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/KMLOutputHandler.java @@ -96,6 +96,7 @@ import de.lmu.ifi.dbs.elki.workflow.OutputStep; * different result types. * * @author Erich Schubert + * @since 0.4.0 */ // TODO: make configurable color scheme @Reference(authors = "E. Achtert, A. Hettab, H.-P. Kriegel, E. Schubert, A. Zimek", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/LogResultStructureResultHandler.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/LogResultStructureResultHandler.java index 0660672b..d10fa0f1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/LogResultStructureResultHandler.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/LogResultStructureResultHandler.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Description; * TODO: transform this into an evaluator, then visualize, too? * * @author Erich Schubert + * @since 0.5.5 */ @Description("Development result handler that merely logs the structure of the result tree.") public class LogResultStructureResultHandler implements ResultHandler { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/OrderingFromDataStore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/OrderingFromDataStore.java index 004b2e8f..000956ba 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/OrderingFromDataStore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/OrderingFromDataStore.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDs; * Result class providing an ordering backed by a hashmap. * * @author Erich Schubert + * @since 0.2 * * @param <T> Data type in hash map */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/OrderingResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/OrderingResult.java index ae5a84b9..cb153b7d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/OrderingResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/OrderingResult.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDs; * Interface for a result providing an object ordering. * * @author Erich Schubert + * @since 0.2 */ public interface OrderingResult extends Result { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/PixmapResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/PixmapResult.java index ce9800dc..04a100e7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/PixmapResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/PixmapResult.java @@ -30,6 +30,7 @@ import java.io.File; * Result encapsulating a single image. * * @author Erich Schubert + * @since 0.4.0 */ public interface PixmapResult extends Result { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/RangeSelection.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/RangeSelection.java index 301df6c1..164317d7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/RangeSelection.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/RangeSelection.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDs; * * @author Heidi Kolb * @author Erich Schubert + * @since 0.4.0 */ public class RangeSelection extends DBIDSelection { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ReferencePointsResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ReferencePointsResult.java index 082456cf..c6d7a7d3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ReferencePointsResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ReferencePointsResult.java @@ -29,6 +29,7 @@ import java.util.Collection; * Result used in passing the reference points to the visualizers. * * @author Erich Schubert + * @since 0.3 * * @param <O> data type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/Result.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/Result.java index 6a1bd402..ab6a9c82 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/Result.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/Result.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.result; * Interface for arbitrary result objects. * * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark * @apiviz.excludeSubtypes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultHandler.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultHandler.java index 3455056f..f228bd74 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultHandler.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultHandler.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.result; * Interface for any class that can handle results * * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark * @apiviz.uses Result oneway - - processes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultHierarchy.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultHierarchy.java index 5c8b1ab4..97108674 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultHierarchy.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultHierarchy.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.hierarchy.ModifiableHierarch * Class to store a hierarchy of result objects. * * @author Erich Schubert + * @since 0.4.0 */ // TODO: add listener merging! public class ResultHierarchy extends HashMapHierarchy<Result> { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultListener.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultListener.java index 8dc3d637..2bdaf23b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultListener.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultListener.java @@ -29,6 +29,7 @@ import java.util.EventListener; * Listener interface invoked when new results are added to the result tree. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has Result */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultProcessor.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultProcessor.java index 9e7b255a..7ffd520a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultProcessor.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultProcessor.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.result; * Interface for any class that can handle results * * @author Erich Schubert + * @since 0.2 * * @apiviz.uses Result oneway - - processes */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultUtil.java index f59e9977..3a394d86 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultUtil.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.hierarchy.Hierarchy; * Utilities for handling result objects * * @author Erich Schubert + * @since 0.2 * * @apiviz.uses Result oneway - - filters */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultWriter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultWriter.java index bbbec518..39b081c4 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultWriter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ResultWriter.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.workflow.OutputStep; * Note: these classes need to be rewritten. Contributions welcome! * * @author Erich Schubert + * @since 0.2 */ public class ResultWriter implements ResultHandler { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/SamplingResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/SamplingResult.java index 973714fe..10ecaf5c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/SamplingResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/SamplingResult.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * Wrapper for storing the current database sample. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf DBIDs */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ScalesResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ScalesResult.java index 3617eb9d..b89a3dc1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ScalesResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/ScalesResult.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.math.scales.Scales; * Class to keep shared scales across visualizers. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf LinearScale */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/SelectionResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/SelectionResult.java index 783cd41d..43bbe201 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/SelectionResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/SelectionResult.java @@ -30,6 +30,7 @@ package de.lmu.ifi.dbs.elki.result; * DBIDSelection object should be seen as static contents of this result. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf DBIDSelection */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/SettingsResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/SettingsResult.java index 6a1f5f91..3b6bb147 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/SettingsResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/SettingsResult.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.TrackedPara * particular result. * * @author Erich Schubert + * @since 0.3 */ public class SettingsResult extends BasicResult { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/BasicOutlierScoreMeta.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/BasicOutlierScoreMeta.java index bb44a657..a150b462 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/BasicOutlierScoreMeta.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/BasicOutlierScoreMeta.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * {@link OutlierScoreMeta} interface. * * @author Erich Schubert + * @since 0.3 */ public class BasicOutlierScoreMeta implements OutlierScoreMeta { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/InvertedOutlierScoreMeta.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/InvertedOutlierScoreMeta.java index 0a55e07d..d8d7f2a3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/InvertedOutlierScoreMeta.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/InvertedOutlierScoreMeta.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.result.outlier; * Class to signal a value-inverted outlier score, i.e. low values are outliers. * * @author Erich Schubert + * @since 0.3 */ public class InvertedOutlierScoreMeta extends BasicOutlierScoreMeta { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/OrderingFromRelation.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/OrderingFromRelation.java index 99c0a48e..86911e6b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/OrderingFromRelation.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/OrderingFromRelation.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.result.OrderingResult; * Ordering obtained from an outlier score. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses DoubleRelation */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/OutlierResult.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/OutlierResult.java index 3aa2337d..daa62fe3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/OutlierResult.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/OutlierResult.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.result.OrderingResult; * parts. * * @author Erich Schubert + * @since 0.3 * * @apiviz.landmark * @apiviz.composedOf OutlierScoreMeta diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/OutlierScoreMeta.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/OutlierScoreMeta.java index 4ce606bf..8f7a0e5c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/OutlierScoreMeta.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/OutlierScoreMeta.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.result.Result; * return {@link Double#NEGATIVE_INFINITY} or {@link Double#POSITIVE_INFINITY}. * * @author Erich Schubert + * @since 0.3 */ public interface OutlierScoreMeta extends Result { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/ProbabilisticOutlierScore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/ProbabilisticOutlierScore.java index bc71379f..2d15dee4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/ProbabilisticOutlierScore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/ProbabilisticOutlierScore.java @@ -30,6 +30,7 @@ package de.lmu.ifi.dbs.elki.result.outlier; * But the baseline may be different from 0.0! * * @author Erich Schubert + * @since 0.3 */ public class ProbabilisticOutlierScore implements OutlierScoreMeta { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/QuotientOutlierScoreMeta.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/QuotientOutlierScoreMeta.java index 7a5ba0ff..53e9c98f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/QuotientOutlierScoreMeta.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/outlier/QuotientOutlierScoreMeta.java @@ -29,6 +29,7 @@ package de.lmu.ifi.dbs.elki.result.outlier; * Score for outlier values generated by a quotient. * * @author Erich Schubert + * @since 0.3 * */ public class QuotientOutlierScoreMeta extends BasicOutlierScoreMeta { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/MultipleFilesOutput.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/MultipleFilesOutput.java index 833e95a2..57bb3454 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/MultipleFilesOutput.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/MultipleFilesOutput.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * Manage output to multiple files. * * @author Erich Schubert + * @since 0.2 */ public class MultipleFilesOutput implements StreamFactory { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/SingleStreamOutput.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/SingleStreamOutput.java index 299a665d..764d0e04 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/SingleStreamOutput.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/SingleStreamOutput.java @@ -35,6 +35,7 @@ import java.util.zip.GZIPOutputStream; * Class to output all result data to a single stream (e.g. Stdout, single file) * * @author Erich Schubert + * @since 0.2 */ public class SingleStreamOutput implements StreamFactory { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/StreamFactory.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/StreamFactory.java index 2f0b51a4..91800a93 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/StreamFactory.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/StreamFactory.java @@ -32,6 +32,7 @@ import java.io.PrintStream; * Note: these classes need to be rewritten. Contributions welcome! * * @author Erich Schubert + * @since 0.2 */ public interface StreamFactory { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/TextWriteable.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/TextWriteable.java index 90e54841..1559971a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/TextWriteable.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/TextWriteable.java @@ -29,6 +29,7 @@ package de.lmu.ifi.dbs.elki.result.textwriter; * human reading and storage in CSV files. * * @author Erich Schubert + * @since 0.2 */ //TODO: split TextWriteable interface into data writing and metadata writing? public interface TextWriteable { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/TextWriter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/TextWriter.java index cca91f75..49aeb2fa 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/TextWriter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/TextWriter.java @@ -59,8 +59,10 @@ import de.lmu.ifi.dbs.elki.result.ResultUtil; import de.lmu.ifi.dbs.elki.result.SettingsResult; import de.lmu.ifi.dbs.elki.result.textwriter.naming.NamingScheme; import de.lmu.ifi.dbs.elki.result.textwriter.naming.SimpleEnumeratingScheme; +import de.lmu.ifi.dbs.elki.result.textwriter.writers.TextWriterDoubleArray; import de.lmu.ifi.dbs.elki.result.textwriter.writers.TextWriterDoubleDoublePair; import de.lmu.ifi.dbs.elki.result.textwriter.writers.TextWriterIgnore; +import de.lmu.ifi.dbs.elki.result.textwriter.writers.TextWriterIntArray; import de.lmu.ifi.dbs.elki.result.textwriter.writers.TextWriterObjectArray; import de.lmu.ifi.dbs.elki.result.textwriter.writers.TextWriterObjectInline; import de.lmu.ifi.dbs.elki.result.textwriter.writers.TextWriterPair; @@ -69,8 +71,8 @@ import de.lmu.ifi.dbs.elki.result.textwriter.writers.TextWriterVector; import de.lmu.ifi.dbs.elki.utilities.HandlerList; import de.lmu.ifi.dbs.elki.utilities.datastructures.hierarchy.Hierarchy; import de.lmu.ifi.dbs.elki.utilities.exceptions.UnableToComplyException; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.TrackedParameter; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.SerializedParameterization; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.TrackedParameter; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ClassParameter; import de.lmu.ifi.dbs.elki.utilities.pairs.DoubleDoublePair; import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; @@ -81,6 +83,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; * Note: these classes need to be rewritten. Contributions welcome! * * @author Erich Schubert + * @since 0.2 * * @apiviz.landmark * @apiviz.uses TextWriterStream oneway - - writesTo @@ -107,6 +110,8 @@ public class TextWriter { writers.insertHandler(Pair.class, new TextWriterPair()); writers.insertHandler(DoubleDoublePair.class, new TextWriterDoubleDoublePair()); writers.insertHandler(FeatureVector.class, trivialwriter); + writers.insertHandler(double[].class, new TextWriterDoubleArray()); + writers.insertHandler(int[].class, new TextWriterIntArray()); // these object can be serialized inline with toString() writers.insertHandler(String.class, trivialwriter); writers.insertHandler(Double.class, trivialwriter); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/TextWriterStream.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/TextWriterStream.java index f6476e52..98237e3e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/TextWriterStream.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/TextWriterStream.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.HandlerList; * Representation of an output stream to a text file. * * @author Erich Schubert + * @since 0.2 * * @apiviz.uses de.lmu.ifi.dbs.elki.result.textwriter.StreamFactory oneway - - * wraps diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/TextWriterWriterInterface.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/TextWriterWriterInterface.java index 4d9109eb..ffb36758 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/TextWriterWriterInterface.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/TextWriterWriterInterface.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.UnableToComplyException; * Base class for object writers. * * @author Erich Schubert + * @since 0.2 * * @param <O> Object type (usually the class itself) */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/naming/NamingScheme.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/naming/NamingScheme.java index 1524d32a..e8c6285c 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/naming/NamingScheme.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/naming/NamingScheme.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.data.Cluster; * Naming scheme implementation for clusterings. * * @author Erich Schubert + * @since 0.2 * * @apiviz.uses Cluster */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/naming/SimpleEnumeratingScheme.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/naming/SimpleEnumeratingScheme.java index 7aa62404..794c40a2 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/naming/SimpleEnumeratingScheme.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/naming/SimpleEnumeratingScheme.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.data.Clustering; * as name, and add an enumeration postfix * * @author Erich Schubert + * @since 0.2 * * @apiviz.uses Clustering */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterDoubleArray.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterDoubleArray.java new file mode 100644 index 00000000..cfadd3ef --- /dev/null +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterDoubleArray.java @@ -0,0 +1,51 @@ +package de.lmu.ifi.dbs.elki.result.textwriter.writers; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterStream; +import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterWriterInterface; +import de.lmu.ifi.dbs.elki.utilities.FormatUtil; + +/** + * Write a double array. + * + * @author Erich Schubert + * @since 0.2 + */ +public class TextWriterDoubleArray extends TextWriterWriterInterface<double[]> { + /** + * Serialize an object into the inline section. + */ + @Override + public void write(TextWriterStream out, String label, double[] v) { + StringBuilder buf = new StringBuilder(); + if(label != null) { + buf.append(label).append('='); + } + if(v != null) { + FormatUtil.formatTo(buf, v, " "); + } + out.inlinePrintNoQuotes(buf.toString()); + } +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterDoubleDoublePair.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterDoubleDoublePair.java index c827cf7e..75f9394f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterDoubleDoublePair.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterDoubleDoublePair.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.DoubleDoublePair; * Write a pair * * @author Erich Schubert + * @since 0.2 * */ public class TextWriterDoubleDoublePair extends TextWriterWriterInterface<DoubleDoublePair> { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterIgnore.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterIgnore.java index 6f3a67ce..a632d43a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterIgnore.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterIgnore.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterWriterInterface; * Ignore the given object when serializing to text. * * @author Erich Schubert + * @since 0.2 */ public class TextWriterIgnore extends TextWriterWriterInterface<Object> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterIntArray.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterIntArray.java new file mode 100644 index 00000000..2e275f46 --- /dev/null +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterIntArray.java @@ -0,0 +1,51 @@ +package de.lmu.ifi.dbs.elki.result.textwriter.writers; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterStream; +import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterWriterInterface; +import de.lmu.ifi.dbs.elki.utilities.FormatUtil; + +/** + * Write a double array. + * + * @author Erich Schubert + * @since 0.2 + */ +public class TextWriterIntArray extends TextWriterWriterInterface<int[]> { + /** + * Serialize an object into the inline section. + */ + @Override + public void write(TextWriterStream out, String label, int[] v) { + StringBuilder buf = new StringBuilder(); + if(label != null) { + buf.append(label).append('='); + } + if(v != null) { + FormatUtil.formatTo(buf, v, " "); + } + out.inlinePrintNoQuotes(buf.toString()); + } +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterObjectArray.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterObjectArray.java index bfac06c3..67a4635f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterObjectArray.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterObjectArray.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterWriterInterface; * Write an object into the inline section, using the objects toString method. * * @author Erich Schubert + * @since 0.2 * */ public class TextWriterObjectArray<T> extends TextWriterWriterInterface<T[]> { @@ -40,7 +41,7 @@ public class TextWriterObjectArray<T> extends TextWriterWriterInterface<T[]> { public void write(TextWriterStream out, String label, T[] v) { StringBuilder buf = new StringBuilder(); if(label != null) { - buf.append(label).append("="); + buf.append(label).append('='); } if(v != null) { for (T o : v) { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterObjectComment.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterObjectComment.java index 519fd41d..338dfd98 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterObjectComment.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterObjectComment.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterWriterInterface; * method. * * @author Erich Schubert + * @since 0.2 * */ public class TextWriterObjectComment extends TextWriterWriterInterface<Object> { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterObjectInline.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterObjectInline.java index 8782e49f..1e5f5268 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterObjectInline.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterObjectInline.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterWriterInterface; * Write an object into the inline section, using the objects toString method. * * @author Erich Schubert + * @since 0.2 * */ public class TextWriterObjectInline extends TextWriterWriterInterface<Object> { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterPair.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterPair.java index 3870dcf6..ff428381 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterPair.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterPair.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; * Write a pair * * @author Erich Schubert + * @since 0.2 * */ public class TextWriterPair extends TextWriterWriterInterface<Pair<?,?>> { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterTextWriteable.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterTextWriteable.java index fe99f668..29c653df 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterTextWriteable.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterTextWriteable.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterWriterInterface; * Write an object, using the objects own {@link TextWriteable} interface. * * @author Erich Schubert + * @since 0.2 * * @apiviz.uses TextWriteable */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterVector.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterVector.java index 568f4e30..a4b2d0ef 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterVector.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/result/textwriter/writers/TextWriterVector.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.result.textwriter.TextWriterWriterInterface; * Write an object into the inline section, using the objects toString method. * * @author Erich Schubert + * @since 0.2 */ public class TextWriterVector extends TextWriterWriterInterface<Vector> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/Alias.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/Alias.java index ea5d864d..ba4e385a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/Alias.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/Alias.java @@ -33,6 +33,7 @@ import java.lang.annotation.Target; * This interface defines alias names for classes. * * @author Erich Schubert + * @since 0.3 */ @Documented @Retention(RetentionPolicy.RUNTIME) diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/BitsUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/BitsUtil.java index 205336df..5869ab4c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/BitsUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/BitsUtil.java @@ -37,6 +37,7 @@ import java.util.Arrays; * <code>I</code> modify in-place. * * @author Erich Schubert + * @since 0.5.0 */ public final class BitsUtil { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ClassGenericsUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ClassGenericsUtil.java index 8c938e02..e746114d 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ClassGenericsUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ClassGenericsUtil.java @@ -61,6 +61,8 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * developer should use {@link #instantiate} instead. * </p> * + * @author Erich Schubert + * @since 0.2 */ public final class ClassGenericsUtil { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/DatabaseUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/DatabaseUtil.java index a4976b5d..e4f708d9 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/DatabaseUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/DatabaseUtil.java @@ -49,6 +49,7 @@ import de.lmu.ifi.dbs.elki.index.preprocessed.knn.MaterializeKNNPreprocessor; * covariances etc. * * @author Erich Schubert + * @since 0.2 */ public final class DatabaseUtil { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ELKIServiceLoader.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ELKIServiceLoader.java index dd3a9ba6..bdddac1d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ELKIServiceLoader.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ELKIServiceLoader.java @@ -29,7 +29,6 @@ import java.net.URL; import java.util.Enumeration; import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; -import de.lmu.ifi.dbs.elki.utilities.io.BufferedLineReader; /** * Class that emulates the behavior of an java ServiceLoader, except that the @@ -37,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.io.BufferedLineReader; * also we need to do the instantiations our way with the parameterizable API. * * @author Erich Schubert + * @since 0.5.0 */ public class ELKIServiceLoader { /** @@ -79,11 +79,35 @@ public class ELKIServiceLoader { Enumeration<URL> configfiles = cl.getResources(fullName); while(configfiles.hasMoreElements()) { URL nextElement = configfiles.nextElement(); + char[] buf = new char[0x4000]; try ( - InputStreamReader is = new InputStreamReader(nextElement.openStream(), "utf-8"); - BufferedLineReader r = new BufferedLineReader(is)) { - while(r.nextLine()) { - parseLine(parent, r.getBuffer(), nextElement); + InputStreamReader is = new InputStreamReader(nextElement.openStream(), "UTF-8");) { + int start = 0, cur = 0, valid = is.read(buf, 0, buf.length); + char c; + while(cur < valid) { + // Find newline or end + while(cur < valid && (c = buf[cur]) != '\n' && c != '\r') { + cur++; + } + if(cur == valid && is.ready()) { + // Move consumed buffer contents: + if(start > 0) { + System.arraycopy(buf, start, buf, 0, valid - start); + valid -= start; + cur -= start; + start = 0; + } + else if(valid == buf.length) { + throw new IOException("Buffer size exceeded. Maximum line length in service files is: " + buf.length + " in file: " + fullName); + } + valid = is.read(buf, valid, buf.length - valid); + continue; + } + parseLine(parent, buf, start, cur, nextElement); + while(cur < valid && ((c = buf[cur]) == '\n' || c == '\r')) { + cur++; + } + start = cur; } } catch(IOException x) { @@ -103,38 +127,33 @@ public class ELKIServiceLoader { * @param line Line to read * @param nam File name for error reporting */ - private static void parseLine(Class<?> parent, CharSequence line, URL nam) { - if(line == null) { - return; - } - int begin = 0, end = line.length(); - while(begin < end && line.charAt(begin) == ' ') { + private static void parseLine(Class<?> parent, char[] line, int begin, int end, URL nam) { + while(begin < end && line[begin] == ' ') { begin++; } - if(begin >= end || line.charAt(begin) == '#') { + if(begin >= end || line[begin] == '#') { return; // Empty/comment lines are okay, continue } - assert(begin == 0 || line.charAt(begin - 1) == ' '); // Find end of class name: int cend = begin + 1; - while(cend < end && line.charAt(cend) != ' ') { + while(cend < end && line[cend] != ' ') { cend++; } // Class name: - String cname = line.subSequence(begin, cend).toString(); + String cname = new String(line, begin, cend - begin); ELKIServiceRegistry.register(parent, cname); for(int abegin = cend + 1, aend = -1; abegin < end; abegin = aend + 1) { // Skip whitespace: - while(abegin < end && line.charAt(abegin) == ' ') { + while(abegin < end && line[abegin] == ' ') { abegin++; } // Find next whitespace: aend = abegin + 1; - while(aend < end && line.charAt(aend) != ' ') { + while(aend < end && line[aend] != ' ') { aend++; } if(abegin < aend) { - ELKIServiceRegistry.registerAlias(parent, line.subSequence(abegin, aend).toString(), cname); + ELKIServiceRegistry.registerAlias(parent, new String(line, abegin, aend - abegin), cname); } } return; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ELKIServiceRegistry.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ELKIServiceRegistry.java index 512de9d1..841dd41a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ELKIServiceRegistry.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ELKIServiceRegistry.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * Registry of available implementations in ELKI. * * @author Erich Schubert + * @since 0.7.0 */ public class ELKIServiceRegistry { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ELKIServiceScanner.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ELKIServiceScanner.java index 1bd139c4..05083a60 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ELKIServiceScanner.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ELKIServiceScanner.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.logging.Logging; * A collection of inspection-related utility functions. * * @author Erich Schubert + * @since 0.7.0 */ public class ELKIServiceScanner { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/FileUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/FileUtil.java index 5ad6d392..17a0e2c2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/FileUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/FileUtil.java @@ -35,6 +35,7 @@ import java.util.zip.GZIPInputStream; * Various static helper methods to deal with files and file names. * * @author Erich Schubert + * @since 0.2 */ public final class FileUtil { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/FormatUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/FormatUtil.java index ad385bcb..dc634eb2 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/FormatUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/FormatUtil.java @@ -38,6 +38,10 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; /** * Utility methods for output formatting of various number objects + * + * @author Arthur Zimek + * @author Erich Schubert + * @since 0.2 */ public final class FormatUtil { /** @@ -321,22 +325,33 @@ public final class FormatUtil { /** * Formats the int array a for printing purposes. * + * @param buf The buffer to serialize to * @param a the int array to be formatted - * @param sep the separator between the single values of the float array, e.g. - * ',' - * @return a String representing the int array a + * @param sep the separator between the single values of the array, e.g. ',' + * @return The output buffer {@code buf} */ - public static String format(int[] a, String sep) { + public static StringBuilder formatTo(StringBuilder buf, int[] a, String sep) { if(a.length == 0) { - return ""; + return buf; } - StringBuilder buffer = new StringBuilder(); - buffer.append(a[0]); + buf.append(a[0]); for(int i = 1; i < a.length; i++) { - buffer.append(sep); - buffer.append(a[i]); + buf.append(sep); + buf.append(a[i]); } - return buffer.toString(); + return buf; + } + + /** + * Formats the int array a for printing purposes. + * + * @param a the int array to be formatted + * @param sep the separator between the single values of the array, e.g. ',' + * @return a String representing the int array a + */ + public static String format(int[] a, String sep) { + return (a == null) ? "null" : (a.length == 0) ? "" : // + formatTo(new StringBuilder(), a, sep).toString(); } /** @@ -1302,8 +1317,8 @@ public final class FormatUtil { * Infinity pattern, with any capitalization */ private static final char[] INFINITY_PATTERN = { // - 'I', 'n', 'f', 'i', 'n', 'i', 't', 'y', // - 'i', 'N', 'F', 'I', 'N', 'I', 'T', 'Y' }; + 'I', 'n', 'f', 'i', 'n', 'i', 't', 'y', // + 'i', 'N', 'F', 'I', 'N', 'I', 'T', 'Y' }; /** Length of pattern */ private static final int INFINITY_LENGTH = INFINITY_PATTERN.length >> 1; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/HandlerList.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/HandlerList.java index e85d9bbd..f82ba9f3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/HandlerList.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/HandlerList.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; * query object can be cast to the handlers restriction class. * * @author Erich Schubert + * @since 0.2 * * @param <H> Parent class/interface for all handlers */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/Util.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/Util.java index 5ed07ec3..24a94ec3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/Util.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/Util.java @@ -33,6 +33,10 @@ import java.util.Random; * classes. * * @see de.lmu.ifi.dbs.elki.utilities + * + * @author Arthur Zimek + * @author Erich Schubert + * @since 0.2 */ public final class Util { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/QuickSelect.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/QuickSelect.java index 070876ca..1d852688 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/QuickSelect.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/QuickSelect.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.database.ids.ModifiableDoubleDBIDList; * Charles Antony Richard Hoare * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.uses ArrayModifiableDBIDs * @apiviz.uses List diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ArrayAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ArrayAdapter.java index 5a2a1056..fd8624de 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ArrayAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ArrayAdapter.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike; * Adapter for array-like things. For example, arrays and lists. * * @author Erich Schubert + * @since 0.4.0 * * @param <T> Item type * @param <A> Array object type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ArrayDBIDsAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ArrayDBIDsAdapter.java index a6881e43..640d5c70 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ArrayDBIDsAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ArrayDBIDsAdapter.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBID; * Use a DBID array in a generic array-like context. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses ArrayDBIDs */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ArrayLikeUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ArrayLikeUtil.java index dc4f3b1c..386243f6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ArrayLikeUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ArrayLikeUtil.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; * reorganizing the objects into a real array. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.landmark * @apiviz.composedOf ArrayAdapter diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/DoubleArray.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/DoubleArray.java index 2f827bb3..ca225b41 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/DoubleArray.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/DoubleArray.java @@ -27,12 +27,28 @@ import java.util.Arrays; /** * Array of double values. * - * TODO: add remove, sort etc. - * * @author Erich Schubert + * @since 0.7.0 */ public class DoubleArray implements NumberArrayAdapter<Double, DoubleArray> { /** + * Maximum array size permitted by Java. + * + * This is JVM dependent, but 2^31 - 5 is the usual OpenJDK8 value. + */ + private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 5; + + /** + * Last value where we can grow by 50%. + */ + private static final int LAST_GROW_SIZE = 0x5555_5551; + + // Assert that these values match. + static { + assert (LAST_GROW_SIZE + (LAST_GROW_SIZE >>> 1) + 1 <= MAX_ARRAY_SIZE); + } + + /** * (Reused) store for numerical attributes. */ public double[] data; @@ -55,6 +71,12 @@ public class DoubleArray implements NumberArrayAdapter<Double, DoubleArray> { * @param initialsize Initial size. */ public DoubleArray(int initialsize) { + if(initialsize < 0) { + initialsize = 11; + } + else if(initialsize > MAX_ARRAY_SIZE) { + initialsize = MAX_ARRAY_SIZE; + } this.data = new double[initialsize]; this.size = 0; } @@ -80,18 +102,31 @@ public class DoubleArray implements NumberArrayAdapter<Double, DoubleArray> { } /** - * Add a numeric attribute value. + * Append a value. * * @param attribute Attribute value. */ public void add(double attribute) { if(data.length == size) { - data = Arrays.copyOf(data, size << 1); + grow(); } data[size++] = attribute; } /** + * Grow the current array. + * + * @throws OutOfMemoryError + */ + private void grow() throws OutOfMemoryError { + if(data.length == MAX_ARRAY_SIZE) { + throw new OutOfMemoryError("Array size has reached the Java maximum."); + } + final int newsize = (size >= LAST_GROW_SIZE) ? MAX_ARRAY_SIZE : (size + (size >> 1) + 1); + data = Arrays.copyOf(data, newsize); + } + + /** * Get the value at this position. * * @param pos Position @@ -144,8 +179,12 @@ public class DoubleArray implements NumberArrayAdapter<Double, DoubleArray> { */ public void insert(int pos, double val) { if(size == data.length) { - double[] oldd = data; - data = new double[size << 1]; + if(data.length == MAX_ARRAY_SIZE) { + throw new OutOfMemoryError("Array size has reached the Java maximum."); + } + final int newsize = (size >= LAST_GROW_SIZE) ? MAX_ARRAY_SIZE : (size + (size >> 1) + 1); + final double[] oldd = data; + data = new double[newsize]; System.arraycopy(oldd, 0, data, 0, pos); System.arraycopy(oldd, pos, data, pos + 1, size - pos); } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/DoubleArrayAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/DoubleArrayAdapter.java index 719aea8a..221335e9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/DoubleArrayAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/DoubleArrayAdapter.java @@ -26,6 +26,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike; * Use a double array as, well, double array in the ArrayAdapter API. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.exclude */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ExtendedArray.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ExtendedArray.java index 4dfd1ecb..047e5f06 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ExtendedArray.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ExtendedArray.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike; * Class to extend an array with a single element virtually. * * @author Erich Schubert + * @since 0.5.0 * * @param <T> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/FeatureVectorAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/FeatureVectorAdapter.java index 59df30ad..338358f1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/FeatureVectorAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/FeatureVectorAdapter.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.data.FeatureVector; * Use the static instance from {@link ArrayLikeUtil}! * * @author Erich Schubert + * @since 0.4.0 * * @param <F> Feature type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/FlatMatrixAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/FlatMatrixAdapter.java index 487f2d84..1c33872d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/FlatMatrixAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/FlatMatrixAdapter.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Matrix; * Use a matrix as array, by flattening it into a sequence. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.exclude */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/FloatArrayAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/FloatArrayAdapter.java index fd82178a..6f4bfa78 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/FloatArrayAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/FloatArrayAdapter.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike; * Use a double array as, well, double array in the ArrayAdapter API. * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.exclude */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/IdentityArrayAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/IdentityArrayAdapter.java index 3766492d..d81d68f3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/IdentityArrayAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/IdentityArrayAdapter.java @@ -29,6 +29,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike; * Use the static instance from {@link ArrayLikeUtil}! * * @author Erich Schubert + * @since 0.4.0 * * @param <T> Item type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/IntegerArray.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/IntegerArray.java new file mode 100644 index 00000000..15393114 --- /dev/null +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/IntegerArray.java @@ -0,0 +1,264 @@ +package de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike; +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2015 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import java.util.Arrays; + +/** + * Array of int values. + * + * @author Erich Schubert + * @since 0.7.0 + */ +public class IntegerArray implements NumberArrayAdapter<Integer, IntegerArray> { + /** + * Maximum array size permitted by Java. + * + * This is JVM dependent, but 2^31 - 5 is the usual OpenJDK8 value. + */ + private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 5; + + /** + * Last value where we can grow by 50%. + */ + private static final int LAST_GROW_SIZE = 0x5555_5551; + + // Assert that these values match. + static { + assert (LAST_GROW_SIZE + (LAST_GROW_SIZE >>> 1) + 1 <= MAX_ARRAY_SIZE); + } + + /** + * (Reused) store for numerical attributes. + */ + public int[] data; + + /** + * Number of numerical attributes. + */ + public int size; + + /** + * Constructor. + */ + public IntegerArray() { + this(11); + } + + /** + * Constructor. + * + * @param initialsize Initial size. + */ + public IntegerArray(int initialsize) { + if(initialsize < 0) { + initialsize = 11; + } + else if(initialsize > MAX_ARRAY_SIZE) { + initialsize = MAX_ARRAY_SIZE; + } + this.data = new int[initialsize]; + this.size = 0; + } + + /** + * Constructor from an existing array. + * + * The new array will be allocated as small as possible, so modifications will + * cause a resize! + * + * @param existing Existing array + */ + public IntegerArray(IntegerArray existing) { + this.data = Arrays.copyOf(existing.data, existing.size); + this.size = existing.size; + } + + /** + * Reset the numeric attribute counter. + */ + public void clear() { + size = 0; + } + + /** + * Append a value. + * + * @param attribute Attribute value. + */ + public void add(int attribute) { + if(data.length == size) { + grow(); + } + data[size++] = attribute; + } + + /** + * Grow the current array. + * + * @throws OutOfMemoryError + */ + private void grow() throws OutOfMemoryError { + if(data.length == MAX_ARRAY_SIZE) { + throw new OutOfMemoryError("Array size has reached the Java maximum."); + } + final int newsize = (size >= LAST_GROW_SIZE) ? MAX_ARRAY_SIZE : (size + (size >> 1) + 1); + data = Arrays.copyOf(data, newsize); + } + + /** + * Get the value at this position. + * + * @param pos Position + * @return Value + */ + public int get(int pos) { + if(pos < 0 || pos >= size) { + throw new ArrayIndexOutOfBoundsException(pos); + } + return data[pos]; + } + + /** + * Set the value at this position. + * + * @param pos Position + * @param value Value + */ + public void set(int pos, int value) { + if(pos < 0 || pos > size) { + throw new ArrayIndexOutOfBoundsException(pos); + } + if(pos == size) { + add(value); + return; + } + data[pos] = value; + } + + /** + * Remove a range from the array. + * + * @param start Start + * @param len Length + */ + public void remove(int start, int len) { + final int end = start + len; + if(end > size) { + throw new ArrayIndexOutOfBoundsException(size); + } + System.arraycopy(data, end, data, start, size - end); + size -= len; + } + + /** + * Insert a value at the given position. + * + * @param pos Insert position + * @param val Value to insert + */ + public void insert(int pos, int val) { + if(size == data.length) { + if(data.length == MAX_ARRAY_SIZE) { + throw new OutOfMemoryError("Array size has reached the Java maximum."); + } + final int newsize = (size >= LAST_GROW_SIZE) ? MAX_ARRAY_SIZE : (size + (size >> 1) + 1); + final int[] oldd = data; + data = new int[newsize]; + System.arraycopy(oldd, 0, data, 0, pos); + System.arraycopy(oldd, pos, data, pos + 1, size - pos); + } + else { + System.arraycopy(data, pos, data, pos + 1, size - pos); + } + data[pos] = val; + size++; + } + + /** + * Get the size of the array. + * + * @return Size + */ + public int size() { + return size; + } + + /** + * Sort the contents. + */ + public void sort() { + Arrays.sort(data, 0, size); + } + + // NumberArrayAdapter: + + @Override + public int size(IntegerArray array) { + return array.size; + } + + @Override + public Integer get(IntegerArray array, int off) throws IndexOutOfBoundsException { + return array.data[off]; + } + + @Override + public double getDouble(IntegerArray array, int off) throws IndexOutOfBoundsException { + return (double) array.data[off]; + } + + @Override + public float getFloat(IntegerArray array, int off) throws IndexOutOfBoundsException { + return (float) array.data[off]; + } + + @Override + public int getInteger(IntegerArray array, int off) throws IndexOutOfBoundsException { + return array.data[off]; + } + + @Override + public short getShort(IntegerArray array, int off) throws IndexOutOfBoundsException { + return (short) array.data[off]; + } + + @Override + public long getLong(IntegerArray array, int off) throws IndexOutOfBoundsException { + return (long) array.data[off]; + } + + @Override + public byte getByte(IntegerArray array, int off) throws IndexOutOfBoundsException { + return (byte) array.data[off]; + } + + /** + * Return a copy of the contents as array. + * + * @return Copy of the contents. + */ + public int[] toArray() { + return Arrays.copyOf(data, size); + } +}
\ No newline at end of file diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ListArrayAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ListArrayAdapter.java index 242caa48..7e92978a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ListArrayAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/ListArrayAdapter.java @@ -30,6 +30,7 @@ import java.util.List; * Use the static instance from {@link ArrayLikeUtil}! * * @author Erich Schubert + * @since 0.4.0 * * @param <T> Data object type. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/NumberArrayAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/NumberArrayAdapter.java index 532862cc..c0777fbd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/NumberArrayAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/NumberArrayAdapter.java @@ -26,6 +26,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike; * Adapter for arrays of numbers, to avoid boxing. * * @author Erich Schubert + * @since 0.5.0 * * @param <N> Number type * @param <A> Array type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/NumberListArrayAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/NumberListArrayAdapter.java index e712ac9a..4c0fec71 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/NumberListArrayAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/NumberListArrayAdapter.java @@ -32,6 +32,7 @@ import java.util.List; * Use the static instance from {@link ArrayLikeUtil}! * * @author Erich Schubert + * @since 0.5.0 * * @param <T> Data object type. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/NumberVectorAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/NumberVectorAdapter.java index 8192f3b8..bb66c33e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/NumberVectorAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/NumberVectorAdapter.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.data.NumberVector; * Use the static instance from {@link ArrayLikeUtil}! * * @author Erich Schubert + * @since 0.5.0 */ public class NumberVectorAdapter implements NumberArrayAdapter<Number, NumberVector> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/SingleSubsetArrayAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/SingleSubsetArrayAdapter.java index 3d8e8c3e..cd905948 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/SingleSubsetArrayAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/SingleSubsetArrayAdapter.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike; * Single-item subset adapter * * @author Erich Schubert + * @since 0.4.0 * * @param <T> Entry type * @param <A> Array type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/SubsetArrayAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/SubsetArrayAdapter.java index 077a0e8d..1299d178 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/SubsetArrayAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/SubsetArrayAdapter.java @@ -26,6 +26,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike; * Subset array adapter (allows reordering and projection). * * @author Erich Schubert + * @since 0.4.0 * * @param <T> Entry type * @param <A> Array type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/SubsetNumberArrayAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/SubsetNumberArrayAdapter.java index 8a1a064b..7d1d1890 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/SubsetNumberArrayAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/SubsetNumberArrayAdapter.java @@ -26,6 +26,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike; * Subset array adapter (allows reordering and projection) * * @author Erich Schubert + * @since 0.4.0 * * @param <T> Entry type * @param <A> Array type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/VectorAdapter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/VectorAdapter.java index 26da061a..48705ece 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/VectorAdapter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arraylike/VectorAdapter.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; * Use the static instance from {@link ArrayLikeUtil}! * * @author Erich Schubert + * @since 0.5.0 */ public class VectorAdapter implements NumberArrayAdapter<Double, Vector> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/DoubleIntegerArrayQuickSort.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/DoubleIntegerArrayQuickSort.java index a48a175b..47bc1281 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/DoubleIntegerArrayQuickSort.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/DoubleIntegerArrayQuickSort.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.arrays; * best of 5 heuristic. * * @author Erich Schubert + * @since 0.5.5 */ public class DoubleIntegerArrayQuickSort { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/IntegerArrayQuickSort.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/IntegerArrayQuickSort.java index ece63ea6..c1b64097 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/IntegerArrayQuickSort.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/IntegerArrayQuickSort.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * objects. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.uses IntegerComparator */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/IntegerComparator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/IntegerComparator.java index 11f79e45..2cb8e755 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/IntegerComparator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/arrays/IntegerComparator.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.arrays; * Interface for comparing two Integer. * * @author Erich Schubert + * @since 0.4.0 */ public interface IntegerComparator { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hash/Unique.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hash/Unique.java index 5e991156..294d7220 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hash/Unique.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hash/Unique.java @@ -33,6 +33,7 @@ import java.util.Arrays; * allows retrieving existing values. * * @author Erich Schubert + * @since 0.7.0 * * @param <E> */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ComparableMaxHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ComparableMaxHeap.java index 968251d6..54f6821b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ComparableMaxHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ComparableMaxHeap.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * Binary heap for primitive types. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has UnsortedIter * @param <K> Key type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ComparableMinHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ComparableMinHeap.java index 8cd4ef0a..4a1cc8a9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ComparableMinHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ComparableMinHeap.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * Binary heap for primitive types. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has UnsortedIter * @param <K> Key type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ComparatorMaxHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ComparatorMaxHeap.java index f3cc6d56..78c00bc5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ComparatorMaxHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ComparatorMaxHeap.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * Binary heap for primitive types. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has UnsortedIter * @param <K> Key type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ComparatorMinHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ComparatorMinHeap.java index 12a15d46..466c3e7b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ComparatorMinHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ComparatorMinHeap.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * Binary heap for primitive types. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has UnsortedIter * @param <K> Key type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleHeap.java index ba853032..76927fc3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleHeap.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.iterator.Iter; * Basic in-memory heap for double values. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has UnsortedIter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleIntegerHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleIntegerHeap.java index 2adc17fd..96ca70c2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleIntegerHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleIntegerHeap.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.iterator.Iter; * Basic in-memory heap interface, for double keys and int values. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has UnsortedIter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleIntegerMaxHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleIntegerMaxHeap.java index b0e62c30..ae40da63 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleIntegerMaxHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleIntegerMaxHeap.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * Binary heap for primitive types. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has UnsortedIter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleIntegerMinHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleIntegerMinHeap.java index d94b63c1..bfc21240 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleIntegerMinHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleIntegerMinHeap.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * Binary heap for primitive types. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has UnsortedIter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleLongHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleLongHeap.java index 551c4131..f4011bcd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleLongHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleLongHeap.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.iterator.Iter; * Basic in-memory heap interface, for double keys and long values. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has UnsortedIter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleLongMaxHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleLongMaxHeap.java index b0f0af50..88a7ee7c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleLongMaxHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleLongMaxHeap.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * Binary heap for primitive types. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has UnsortedIter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleLongMinHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleLongMinHeap.java index fcc3526d..7fc2a5dd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleLongMinHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleLongMinHeap.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * Binary heap for primitive types. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has UnsortedIter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleMaxHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleMaxHeap.java index d1a6ed0f..92a1ba9c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleMaxHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleMaxHeap.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * Binary heap for primitive types. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has UnsortedIter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleMinHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleMinHeap.java index f4c53260..3c8eda0b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleMinHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleMinHeap.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * Binary heap for primitive types. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has UnsortedIter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleObjectHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleObjectHeap.java index 77a380bf..a822cb64 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleObjectHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleObjectHeap.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.iterator.Iter; * Basic in-memory heap interface, for double keys and V values. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has UnsortedIter * @param <V> Value type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleObjectMaxHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleObjectMaxHeap.java index 96b03a67..6e8e5c02 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleObjectMaxHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleObjectMaxHeap.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * Binary heap for primitive types. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has UnsortedIter * @param <V> Value type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleObjectMinHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleObjectMinHeap.java index c04fb7cb..b87e6281 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleObjectMinHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoubleObjectMinHeap.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * Binary heap for primitive types. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has UnsortedIter * @param <V> Value type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoublePriorityObject.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoublePriorityObject.java index 342c064d..cd8ef1cb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoublePriorityObject.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/DoublePriorityObject.java @@ -31,6 +31,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.heap; * the priority. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Stored object type. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/Heap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/Heap.java index 5f6b27c2..fe8aaa53 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/Heap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/Heap.java @@ -36,6 +36,7 @@ import java.util.Comparator; * O(n log n). This is implemented via a simple validTo counter. * * @author Erich Schubert + * @since 0.4.0 * * @param <E> Element type. Should be {@link java.lang.Comparable} or a * {@link java.util.Comparator} needs to be given. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerHeap.java index c7e897d8..4a1a7ca7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerHeap.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.iterator.Iter; * Basic in-memory heap for int values. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has UnsortedIter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerMaxHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerMaxHeap.java index a4e54147..54af796b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerMaxHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerMaxHeap.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * Binary heap for primitive types. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has UnsortedIter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerMinHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerMinHeap.java index 0e56e2e1..17ece116 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerMinHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerMinHeap.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * Binary heap for primitive types. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has UnsortedIter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerObjectHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerObjectHeap.java index defacf83..08eecf02 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerObjectHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerObjectHeap.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.iterator.Iter; * Basic in-memory heap interface, for int keys and V values. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has UnsortedIter * @param <V> Value type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerObjectMaxHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerObjectMaxHeap.java index ce3d7809..7f62c277 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerObjectMaxHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerObjectMaxHeap.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * Binary heap for primitive types. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has UnsortedIter * @param <V> Value type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerObjectMinHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerObjectMinHeap.java index c087d7d2..b46dadaa 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerObjectMinHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerObjectMinHeap.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.math.MathUtil; * Binary heap for primitive types. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.has UnsortedIter * @param <V> Value type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerPriorityObject.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerPriorityObject.java index c809e113..4e7c21c2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerPriorityObject.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/IntegerPriorityObject.java @@ -31,6 +31,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.heap; * the priority. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Stored object type. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ObjectHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ObjectHeap.java index 8b00dbbe..20ee0547 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ObjectHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/ObjectHeap.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.iterator.Iter; * Basic in-memory heap for K values. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has UnsortedIter * @param <K> Key type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TiedTopBoundedHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TiedTopBoundedHeap.java index f9628f1a..ea1a356a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TiedTopBoundedHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TiedTopBoundedHeap.java @@ -33,6 +33,7 @@ import java.util.List; * elements. * * @author Erich Schubert + * @since 0.4.0 * * @param <E> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TiedTopBoundedUpdatableHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TiedTopBoundedUpdatableHeap.java index 88036e00..83261ef5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TiedTopBoundedUpdatableHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TiedTopBoundedUpdatableHeap.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * elements. * * @author Erich Schubert + * @since 0.4.0 * * @param <E> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TopBoundedHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TopBoundedHeap.java index 9fd95a1b..b884c58a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TopBoundedHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TopBoundedHeap.java @@ -30,6 +30,7 @@ import java.util.Comparator; * {@code k} Elements only. * * @author Erich Schubert + * @since 0.4.0 * * @param <E> Element type. Should be {@link Comparable} or a {@link Comparator} * needs to be given. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TopBoundedUpdatableHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TopBoundedUpdatableHeap.java index 80b5768a..ff0dd369 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TopBoundedUpdatableHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/TopBoundedUpdatableHeap.java @@ -30,6 +30,7 @@ import java.util.Comparator; * {@code k} Elements only. * * @author Erich Schubert + * @since 0.4.0 * * @param <E> Element type. Should be {@link Comparable} or a {@link Comparator} * needs to be given. diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/UpdatableHeap.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/UpdatableHeap.java index be089725..4af70021 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/UpdatableHeap.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/heap/UpdatableHeap.java @@ -32,6 +32,7 @@ import java.util.Comparator; * A heap as used in OPTICS that allows updating entries. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/FilteredIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/FilteredIter.java index 67876387..aac710e8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/FilteredIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/FilteredIter.java @@ -26,6 +26,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.hierarchy; * Filtered iterator. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf Hierarchy.Iter * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/HashMapHierarchy.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/HashMapHierarchy.java index 59ec00f0..2f478866 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/HashMapHierarchy.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/HashMapHierarchy.java @@ -29,6 +29,7 @@ import java.util.HashMap; * Centralized hierarchy implementation, using a HashMap of Lists. * * @author Erich Schubert + * @since 0.6.0 * * @param <O> Object type (arbitrary!) */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/Hierarchy.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/Hierarchy.java index 6c932451..04d1cd5b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/Hierarchy.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/Hierarchy.java @@ -29,6 +29,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.hierarchy; * object, i.e. {@code hierarchy.iterChildren(object);}. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has Iter * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/ModifiableHierarchy.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/ModifiableHierarchy.java index 3496e41c..4b3af7c2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/ModifiableHierarchy.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/ModifiableHierarchy.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.hierarchy; * Modifiable Hierarchy. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/StackedIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/StackedIter.java index 52ecc0e3..93aa71b7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/StackedIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/hierarchy/StackedIter.java @@ -26,6 +26,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.hierarchy; * Filtered iterator. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf Hierarchy * @apiviz.composedOf Hierarchy.Iter diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/AbstractObjDynamicHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/AbstractObjDynamicHistogram.java index 9c2f3a60..d07e078b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/AbstractObjDynamicHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/AbstractObjDynamicHistogram.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.BitsUtil; * into the histogram. * * @author Erich Schubert + * @since 0.5.5 * * @param <T> Data type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/AbstractObjStaticHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/AbstractObjStaticHistogram.java index 709f7ceb..743bb179 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/AbstractObjStaticHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/AbstractObjStaticHistogram.java @@ -30,6 +30,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.histogram; * left and right. * * @author Erich Schubert + * @since 0.5.5 * * @param <T> Data type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/AbstractStaticHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/AbstractStaticHistogram.java index b0728ddb..a1a81174 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/AbstractStaticHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/AbstractStaticHistogram.java @@ -31,6 +31,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.histogram; * adapted for multiple use cases. * * @author Erich Schubert + * @since 0.5.5 */ public abstract class AbstractStaticHistogram implements Histogram { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/DoubleArrayStaticHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/DoubleArrayStaticHistogram.java index 7ea5b623..4e0081d5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/DoubleArrayStaticHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/DoubleArrayStaticHistogram.java @@ -29,6 +29,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. * primitive in Java. * * @author Erich Schubert + * @since 0.5.5 */ public final class DoubleArrayStaticHistogram extends AbstractObjStaticHistogram<double[]> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/DoubleDynamicHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/DoubleDynamicHistogram.java index 2f2e6a02..88a70ad9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/DoubleDynamicHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/DoubleDynamicHistogram.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.BitsUtil; * bins to the data fed into the histogram. * * @author Erich Schubert + * @since 0.5.5 */ public class DoubleDynamicHistogram extends DoubleStaticHistogram { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/DoubleHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/DoubleHistogram.java index 9a26c264..84f06713 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/DoubleHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/DoubleHistogram.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.histogram; * Histogram storing double values. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has Iter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/DoubleStaticHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/DoubleStaticHistogram.java index 63ba3e21..6d4dc22b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/DoubleStaticHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/DoubleStaticHistogram.java @@ -32,6 +32,7 @@ import java.util.Arrays; * left and right. * * @author Erich Schubert + * @since 0.5.5 */ public class DoubleStaticHistogram extends AbstractStaticHistogram implements DoubleHistogram { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/FloatDynamicHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/FloatDynamicHistogram.java index 261c7a7f..007ef6e6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/FloatDynamicHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/FloatDynamicHistogram.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.BitsUtil; * bins to the data fed into the histogram. * * @author Erich Schubert + * @since 0.5.5 */ public class FloatDynamicHistogram extends FloatStaticHistogram { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/FloatHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/FloatHistogram.java index 81edb88c..18e992b8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/FloatHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/FloatHistogram.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.histogram; * Histogram storing float values. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has Iter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/FloatStaticHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/FloatStaticHistogram.java index 6e4d78f5..079e8e0e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/FloatStaticHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/FloatStaticHistogram.java @@ -32,6 +32,7 @@ import java.util.Arrays; * left and right. * * @author Erich Schubert + * @since 0.5.5 */ public class FloatStaticHistogram extends AbstractStaticHistogram implements FloatHistogram { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/Histogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/Histogram.java index a8fd60c0..1632fc45 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/Histogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/Histogram.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.iterator.ArrayIter; * to be shared for primitive types, too! * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has Iter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/IntArrayStaticHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/IntArrayStaticHistogram.java index d3d278ee..8e838b4e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/IntArrayStaticHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/IntArrayStaticHistogram.java @@ -29,6 +29,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. * primitive in Java. * * @author Erich Schubert + * @since 0.5.5 */ public final class IntArrayStaticHistogram extends AbstractObjStaticHistogram<int[]> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/IntDynamicHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/IntDynamicHistogram.java index 4d3a5045..13ab7b35 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/IntDynamicHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/IntDynamicHistogram.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.BitsUtil; * bins to the data fed into the histogram. * * @author Erich Schubert + * @since 0.5.5 */ public class IntDynamicHistogram extends IntStaticHistogram { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/IntHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/IntHistogram.java index d448c852..ce2b39aa 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/IntHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/IntHistogram.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.histogram; * Histogram storing int values. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has Iter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/IntStaticHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/IntStaticHistogram.java index bd367837..3cbe83bc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/IntStaticHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/IntStaticHistogram.java @@ -32,6 +32,7 @@ import java.util.Arrays; * left and right. * * @author Erich Schubert + * @since 0.5.5 */ public class IntStaticHistogram extends AbstractStaticHistogram implements IntHistogram { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/LongArrayStaticHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/LongArrayStaticHistogram.java index 907fa7ca..a922935a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/LongArrayStaticHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/LongArrayStaticHistogram.java @@ -29,6 +29,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.histogram; * primitive in Java. * * @author Erich Schubert + * @since 0.5.5 */ public final class LongArrayStaticHistogram extends AbstractObjStaticHistogram<long[]> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/LongDynamicHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/LongDynamicHistogram.java index 78385a30..cc5b5dc6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/LongDynamicHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/LongDynamicHistogram.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.BitsUtil; * bins to the data fed into the histogram. * * @author Erich Schubert + * @since 0.5.5 */ public class LongDynamicHistogram extends LongStaticHistogram { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/LongHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/LongHistogram.java index ec1ba994..893e0f47 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/LongHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/LongHistogram.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.histogram; * Histogram storing long values. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has Iter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/LongStaticHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/LongStaticHistogram.java index ae37dbcc..9cc201ae 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/LongStaticHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/LongStaticHistogram.java @@ -32,6 +32,7 @@ import java.util.Arrays; * left and right. * * @author Erich Schubert + * @since 0.5.5 */ public class LongStaticHistogram extends AbstractStaticHistogram implements LongHistogram { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/MeanVarianceStaticHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/MeanVarianceStaticHistogram.java index f3d054cd..5adcc9bd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/MeanVarianceStaticHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/MeanVarianceStaticHistogram.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.math.MeanVariance; * left and right. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.composedOf MeanVariance */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/ObjHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/ObjHistogram.java index e1d75b76..2ce2926f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/ObjHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/ObjHistogram.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.histogram; * Basic interface for object based histograms (static and flexible). * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has Iter * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/ShortDynamicHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/ShortDynamicHistogram.java index 8fd1ffbd..d0a932a1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/ShortDynamicHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/ShortDynamicHistogram.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.BitsUtil; * bins to the data fed into the histogram. * * @author Erich Schubert + * @since 0.5.5 */ public class ShortDynamicHistogram extends ShortStaticHistogram { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/ShortHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/ShortHistogram.java index 706d43e8..14e1ec55 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/ShortHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/ShortHistogram.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.histogram; * Histogram storing short values. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.has Iter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/ShortStaticHistogram.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/ShortStaticHistogram.java index 4c49f595..ebfc6365 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/ShortStaticHistogram.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/histogram/ShortStaticHistogram.java @@ -32,6 +32,7 @@ import java.util.Arrays; * left and right. * * @author Erich Schubert + * @since 0.5.5 */ public class ShortStaticHistogram extends AbstractStaticHistogram implements ShortHistogram { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/iterator/ArrayIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/iterator/ArrayIter.java index d3deb054..3f26f417 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/iterator/ArrayIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/iterator/ArrayIter.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.iterator; * Array iterators can also go backwards and seek. * * @author Erich Schubert + * @since 0.2 * * @apiviz.excludeSubtypes */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/iterator/ArrayListIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/iterator/ArrayListIter.java index 175ccfb2..441eaee4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/iterator/ArrayListIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/iterator/ArrayListIter.java @@ -32,6 +32,7 @@ import java.util.List; * access and seeking (i.e. ArrayLists, but not Linked Lists!) * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.excludeSubtypes * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/iterator/Iter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/iterator/Iter.java index d362ff37..23cf34fe 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/iterator/Iter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/iterator/Iter.java @@ -52,6 +52,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.iterator; * </pre> * * @author Erich Schubert + * @since 0.5.0 * * @apiviz.landmark * @apiviz.excludeSubtypes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/iterator/MIter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/iterator/MIter.java index b7b69cc7..557870de 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/iterator/MIter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/iterator/MIter.java @@ -40,6 +40,7 @@ package de.lmu.ifi.dbs.elki.utilities.datastructures.iterator; * </pre> * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.excludeSubtypes */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/UnionFind.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/UnionFind.java index bbba1c8e..55b0b561 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/UnionFind.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/UnionFind.java @@ -27,9 +27,10 @@ import de.lmu.ifi.dbs.elki.database.ids.DBIDRef; import de.lmu.ifi.dbs.elki.database.ids.DBIDs; /** - * Union-find implementations in ELKI + * Union-find implementations in ELKI, for DBID objects. * * @author Erich Schubert + * @since 0.7.0 */ public interface UnionFind { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/UnionFindUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/UnionFindUtil.java index ee403a66..38ec2559 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/UnionFindUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/UnionFindUtil.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.ids.StaticDBIDs; * Union-find algorithm factory, to choose the best implementation. * * @author Erich Schubert + * @since 0.7.0 */ public class UnionFindUtil { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/WeightedQuickUnionInteger.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/WeightedQuickUnionInteger.java new file mode 100644 index 00000000..b7fc8478 --- /dev/null +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/WeightedQuickUnionInteger.java @@ -0,0 +1,174 @@ +package de.lmu.ifi.dbs.elki.utilities.datastructures.unionfind; + +/* + This file is part of ELKI: + Environment for Developing KDD-Applications Supported by Index-Structures + + Copyright (C) 2016 + Ludwig-Maximilians-Universität München + Lehr- und Forschungseinheit für Datenbanksysteme + ELKI Development Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +import java.util.Arrays; + +import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; +import gnu.trove.list.TIntList; +import gnu.trove.list.array.TIntArrayList; + +/** + * Union-find algorithm for primitive integers, with optimizations. + * + * This is the weighted quick union approach, weighted by count and using + * path-halving for optimization. + * + * Reference: + * <p> + * R. Sedgewick<br /> + * 1.3 Union-Find Algorithms<br /> + * Algorithms in C, Parts 1-4 + * </p> + * + * @author Erich Schubert + * @since 0.7.0 + */ +@Reference(authors = "R. Sedgewick", // +title = "1.3 Union-Find Algorithms", // +booktitle = "Algorithms in C, Parts 1-4") +public class WeightedQuickUnionInteger { + /** + * Number of used indexes. + */ + private int used; + + /** + * Parent element + */ + private int[] parent; + + /** + * Weight, for optimization. + */ + private int[] weight; + + /** + * Initial size. + */ + private static final int INITIAL_SIZE = 51; + + /** + * Constructor. + */ + public WeightedQuickUnionInteger() { + weight = new int[INITIAL_SIZE]; + parent = new int[INITIAL_SIZE]; + } + + /** + * Occupy the next unused index. + * + * @param weight Initial weight. + * @return Next unused index. + */ + public int nextIndex(int weight) { + if(used == parent.length) { + int nsize = used + (used >> 1); + this.weight = Arrays.copyOf(this.weight, nsize); + this.parent = Arrays.copyOf(this.parent, nsize); + } + this.weight[used] = weight; + this.parent[used] = used; + return used++; + } + + /** + * Find the parent of an object. + * + * @param cur Current entry + * @return Parent entry + */ + public int find(int cur) { + assert (cur >= 0 && cur < parent.length); + int p = parent[cur], tmp; + while(cur != p) { + tmp = p; + p = parent[cur] = parent[p]; // Perform simple path compression. + cur = tmp; + } + return cur; + } + + /** + * Join the components of elements p and q. + * + * @param first First element + * @param second Second element + * @return Component id. + */ + public int union(int first, int second) { + int firstComponent = find(first), secondComponent = find(second); + if(firstComponent == secondComponent) { + return firstComponent; + } + final int w1 = weight[firstComponent], w2 = weight[secondComponent]; + if(w1 > w2) { + parent[secondComponent] = firstComponent; + weight[firstComponent] += w2; + return firstComponent; + } + else { + parent[firstComponent] = secondComponent; + weight[secondComponent] += w1; + return secondComponent; + } + } + + /** + * Test if two components are connected. + * + * @param first First element + * @param second Second element + * @return {@code true} if they are in the same component. + */ + public boolean isConnected(int first, int second) { + return find(first) == find(second); + } + + /** + * Collect all component root elements. + * + * @return Root elements + */ + public TIntList getRoots() { + TIntList roots = new TIntArrayList(); + for(int i = 0; i < used; i++) { + // roots or one element in component + if(parent[i] == i) { + roots.add(i); + } + } + return roots; + } + + /** + * Number of allocated indexes. + * + * @return Index number. + */ + public int size() { + return used; + } +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/WeightedQuickUnionRangeDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/WeightedQuickUnionRangeDBIDs.java index 60c719e2..5440e2b5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/WeightedQuickUnionRangeDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/WeightedQuickUnionRangeDBIDs.java @@ -51,6 +51,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * * @author Evgeniy Faerman * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "R. Sedgewick", // title = "1.3 Union-Find Algorithms", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/WeightedQuickUnionStaticDBIDs.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/WeightedQuickUnionStaticDBIDs.java index 0e4dd24b..9ed8d618 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/WeightedQuickUnionStaticDBIDs.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/datastructures/unionfind/WeightedQuickUnionStaticDBIDs.java @@ -60,6 +60,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * * @author Evgeniy Faerman * @author Erich Schubert + * @since 0.7.0 */ @Reference(authors = "R. Sedgewick", // title = "1.3 Union-Find Algorithms", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/Description.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/Description.java index 163af834..1b4963bd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/Description.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/Description.java @@ -33,6 +33,7 @@ import java.lang.annotation.Target; * Class/algorithm description * * @author Erich Schubert + * @since 0.3 */ @Documented @Retention(RetentionPolicy.RUNTIME) diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/DocumentationUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/DocumentationUtil.java index 0fbc3b96..6caa488b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/DocumentationUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/DocumentationUtil.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.utilities.documentation; * Utilities for extracting documentation from class annotations. * * @author Erich Schubert + * @since 0.3 * * @apiviz.uses de.lmu.ifi.dbs.elki.utilities.documentation.Title * @apiviz.uses de.lmu.ifi.dbs.elki.utilities.documentation.Description diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/Reference.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/Reference.java index 9c84661e..9e8a37ff 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/Reference.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/Reference.java @@ -33,6 +33,7 @@ import java.lang.annotation.Target; * Annotation to specify a reference. * * @author Erich Schubert + * @since 0.3 */ @Documented @Retention(RetentionPolicy.RUNTIME) diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/Restricted.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/Restricted.java index 29955acf..a1725b64 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/Restricted.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/Restricted.java @@ -34,6 +34,7 @@ import java.lang.annotation.Target; * associated patents, and therefore must not be included in the release. * * @author Erich Schubert + * @since 0.3 */ @Documented @Retention(RetentionPolicy.RUNTIME) diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/Title.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/Title.java index 77889f03..5e7af068 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/Title.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/documentation/Title.java @@ -33,6 +33,7 @@ import java.lang.annotation.Target; * Simple interface to provide a nicer title for the class. * * @author Erich Schubert + * @since 0.3 */ @Documented @Retention(RetentionPolicy.RUNTIME) diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVoting.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVoting.java index 994b8a1b..12e15692 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVoting.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVoting.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.ensemble; * Interface for ensemble voting rules * * @author Erich Schubert + * @since 0.4.0 */ public interface EnsembleVoting { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingInverseMultiplicative.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingInverseMultiplicative.java index 0b4c245f..f0238cc1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingInverseMultiplicative.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingInverseMultiplicative.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * {@code 1-product(1-s_i)} * * @author Erich Schubert + * @since 0.5.0 */ public class EnsembleVotingInverseMultiplicative implements EnsembleVoting { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMax.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMax.java index 67e86277..ba59c1c1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMax.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMax.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.ensemble; * Simple combination rule, by taking the maximum. * * @author Erich Schubert + * @since 0.2 */ public class EnsembleVotingMax implements EnsembleVoting { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMean.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMean.java index 8eec61e4..bf26f9ed 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMean.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMean.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.ensemble; * Simple combination rule, by taking the mean * * @author Erich Schubert + * @since 0.2 */ public class EnsembleVotingMean implements EnsembleVoting { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMedian.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMedian.java index ddd81d40..d48bd474 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMedian.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMedian.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * Note: median is very similar to a <em>majority voting</em>! * * @author Erich Schubert + * @since 0.4.0 */ public class EnsembleVotingMedian implements EnsembleVoting { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMin.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMin.java index 99f193c1..2916be9b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMin.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMin.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.utilities.ensemble; * Simple combination rule, by taking the minimum. * * @author Erich Schubert + * @since 0.5.0 */ public class EnsembleVotingMin implements EnsembleVoting { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMultiplicative.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMultiplicative.java index 5e4f34cd..adfa5b71 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMultiplicative.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/ensemble/EnsembleVotingMultiplicative.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * {@code product(s_i)} * * @author Erich Schubert + * @since 0.5.0 */ public class EnsembleVotingMultiplicative implements EnsembleVoting { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/APIViolationException.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/APIViolationException.java index b6a56a48..82632083 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/APIViolationException.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/APIViolationException.java @@ -36,6 +36,7 @@ package de.lmu.ifi.dbs.elki.utilities.exceptions; * the Java compiler). * * @author Erich Schubert + * @since 0.4.0 */ public class APIViolationException extends AbortException { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/AbortException.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/AbortException.java index 678abdd9..764c68e8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/AbortException.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/AbortException.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.utilities.exceptions; * Exception for aborting some process and transporting a message. * * @author Arthur Zimek + * @since 0.2 */ public class AbortException extends RuntimeException { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/ExceptionMessages.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/ExceptionMessages.java index 68560813..c0302f97 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/ExceptionMessages.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/ExceptionMessages.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.exceptions; * Interface to collect exception messages that are used in several cases. * * @author Arthur Zimek + * @since 0.2 */ public interface ExceptionMessages { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/NotImplementedException.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/NotImplementedException.java index 89f33361..ac116a38 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/NotImplementedException.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/NotImplementedException.java @@ -29,6 +29,7 @@ package de.lmu.ifi.dbs.elki.utilities.exceptions; * See {@link ExceptionMessages} for common explanations. * * @author Erich Schubert + * @since 0.4.0 */ public class NotImplementedException extends AbortException { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/ObjectNotFoundException.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/ObjectNotFoundException.java index f44c11b9..1275c6ae 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/ObjectNotFoundException.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/ObjectNotFoundException.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.database.ids.DBID; * Exception thrown when the requested object was not found in the database. * * @author Erich Schubert + * @since 0.4.0 */ public class ObjectNotFoundException extends RuntimeException { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/UnableToComplyException.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/UnableToComplyException.java index ee00ff06..c004e401 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/UnableToComplyException.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/exceptions/UnableToComplyException.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.utilities.exceptions; * General Exception to state inability to execute an operation. * * @author Arthur Zimek + * @since 0.2 */ @SuppressWarnings("serial") public class UnableToComplyException extends Exception { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/BufferedLineReader.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/BufferedLineReader.java index b93c28bf..d387093e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/BufferedLineReader.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/BufferedLineReader.java @@ -28,12 +28,13 @@ import java.io.InputStreamReader; /** * Class for buffered IO, avoiding some of the overheads of the Java API. - * + * * The main difference to the standard Java API is that this implementation will * reuse the buffer. <b>After a call to {@code nextLine()}, the buffer will be * overwitten!</b> - * + * * @author Erich Schubert + * @since 0.7.0 */ public class BufferedLineReader implements AutoCloseable { /** @@ -44,7 +45,7 @@ public class BufferedLineReader implements AutoCloseable { /** * The buffer we read the data into. */ - protected StringBuilder buf = new StringBuilder(); + protected StringBuilder buf = new StringBuilder(1024); /** * Current line number. @@ -98,9 +99,9 @@ public class BufferedLineReader implements AutoCloseable { /** * Reset to a new line reader. - * + * * <b>A previous reader will not be closed automatically!</b> - * + * * @param r New reader */ public void reset(LineReader r) { @@ -110,9 +111,9 @@ public class BufferedLineReader implements AutoCloseable { /** * Reset to a new line reader. - * + * * <b>A previous stream will not be closed automatically!</b> - * + * * @param in New input stream reader */ public void reset(InputStream in) { @@ -122,9 +123,9 @@ public class BufferedLineReader implements AutoCloseable { /** * Reset to a new line reader. - * + * * <b>A previous stream will not be closed automatically!</b> - * + * * @param in New input stream reader */ public void reset(InputStreamReader in) { @@ -134,9 +135,9 @@ public class BufferedLineReader implements AutoCloseable { /** * Get the reader buffer. - * + * * <b>After a call to {@code nextLine()}, the buffer will be overwitten!</b> - * + * * @return Buffer. */ public CharSequence getBuffer() { @@ -145,7 +146,7 @@ public class BufferedLineReader implements AutoCloseable { /** * Get the current line number. - * + * * @return Current line number */ public int getLineNumber() { @@ -154,7 +155,7 @@ public class BufferedLineReader implements AutoCloseable { /** * Read the next line. - * + * * @return {@code true} if another line was read successfully. * @throws IOException on IO errors. */ @@ -179,7 +180,7 @@ public class BufferedLineReader implements AutoCloseable { /** * Get the length of the string, not taking trailing linefeeds into account. - * + * * @param line Input line * @return Length */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/ByteArrayUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/ByteArrayUtil.java index 49493e33..8cb7570a 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/ByteArrayUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/ByteArrayUtil.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * {@link java.io.ByteArrayOutputStream} * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.landmark * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/ByteBufferInputStream.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/ByteBufferInputStream.java index 138957bd..1fcb1f3c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/ByteBufferInputStream.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/ByteBufferInputStream.java @@ -30,6 +30,7 @@ import java.nio.ByteBuffer; * Wrap an existing ByteBuffer as InputStream. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has ByteBuffer */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/ByteBufferOutputStream.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/ByteBufferOutputStream.java index 3e2b397c..8e07f075 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/ByteBufferOutputStream.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/ByteBufferOutputStream.java @@ -30,6 +30,7 @@ import java.nio.ByteBuffer; * Wrap an existing ByteBuffer as OutputStream. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has ByteBuffer */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/ByteBufferSerializer.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/ByteBufferSerializer.java index 94f882ab..c58d6063 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/ByteBufferSerializer.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/ByteBufferSerializer.java @@ -30,6 +30,7 @@ import java.nio.ByteBuffer; * Class to convert from and to byte arrays (in index structures). * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has ByteBuffer - - oneway «serializes to/from» * @apiviz.excludeSubtypes diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/FixedSizeByteBufferSerializer.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/FixedSizeByteBufferSerializer.java index ac966c7e..e360fc43 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/FixedSizeByteBufferSerializer.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/FixedSizeByteBufferSerializer.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.io; * Serializers with a fixed length serialization. * * @author Erich Schubert + * @since 0.4.0 * @apiviz.excludeSubtypes * * @param <T> Type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/LineReader.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/LineReader.java index 3bec4ad4..01b1336d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/LineReader.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/LineReader.java @@ -4,7 +4,7 @@ package de.lmu.ifi.dbs.elki.utilities.io; This file is part of ELKI: Environment for Developing KDD-Applications Supported by Index-Structures - Copyright (C) 2015 + Copyright (C) 2016 Ludwig-Maximilians-Universität München Lehr- und Forschungseinheit für Datenbanksysteme ELKI Development Team @@ -30,43 +30,52 @@ import java.io.Reader; /** * Fast class to read a file, line per line. - * + * * Lines must be split using Unix newlines <code>\n</code>, linefeeds * <code>\r</code> are ignored. - * + * * This is a rather minimal implementation, which supposedly pays off in * performance. In particular, this class allows recycling the buffer, which * will yield less object allocations and thus less garbage collection. - * + * * Usage example: - * + * * <pre> * StringBuilder buf = new StringBuilder(); * LineReader reader = new LineReader(inputStream); * // Clear buffer, and append next line. - * while(reader.readLine(buf.delete(0, buf.length()))) { + * while(reader.readLine(buf.setLength(0))) { * // process string in buffer. * } * </pre> - * + * * @author Erich Schubert + * @since 0.7.0 */ public class LineReader implements AutoCloseable { - /** Buffer size to use */ + /** + * Default buffer size to use + */ final static int BUFFER_SIZE = 4096; - /** Input stream to read from */ + /** + * Input stream to read from + */ Reader in; - /** Character buffer */ - char[] buffer = new char[BUFFER_SIZE]; + /** + * Character buffer + */ + char[] buffer; - /** Current position, and length of buffer */ + /** + * Current position, and length of buffer + */ int pos = 0, end = 0; /** * Constructor - * + * * @param in Stream */ public LineReader(InputStream in) { @@ -75,16 +84,37 @@ public class LineReader implements AutoCloseable { /** * Constructor - * + * * @param in Reader */ public LineReader(Reader in) { + this(in, BUFFER_SIZE); + } + + /** + * Constructor + * + * @param in Reader + * @param buffersize Buffer size + */ + public LineReader(InputStream in, int buffersize) { + this(new InputStreamReader(in), buffersize); + } + + /** + * Constructor + * + * @param in Reader + * @param buffersize Buffer size + */ + public LineReader(Reader in, int buffersize) { this.in = in; + this.buffer = new char[buffersize]; } /** * Read a line into the given buffer. - * + * * @param buf Buffer. * @return {@code true} if some characters have been read. */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/TokenizedReader.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/TokenizedReader.java index f9363d57..0afcb9ab 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/TokenizedReader.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/TokenizedReader.java @@ -31,6 +31,7 @@ import java.util.regex.Pattern; * Reader that will tokenize the input data as desired. * * @author Erich Schubert + * @since 0.7.0 * * @apiviz.composedOf Tokenizer */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/Tokenizer.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/Tokenizer.java index 67339cd2..b86923d7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/Tokenizer.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/io/Tokenizer.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.datastructures.iterator.Iter; * String tokenizer. * * @author Erich Schubert + * @since 0.6.0 */ public class Tokenizer implements Iter { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/AbstractParameterizer.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/AbstractParameterizer.java index f8a7b390..a3559e86 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/AbstractParameterizer.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/AbstractParameterizer.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * Abstract base class that handles the parameterization of a class. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses Parameterization * @apiviz.has de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/InternalParameterizationErrors.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/InternalParameterizationErrors.java index 3301c31c..9173cc24 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/InternalParameterizationErrors.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/InternalParameterizationErrors.java @@ -32,6 +32,7 @@ import java.util.Collection; * This is meant for reporting re-parameterization errors. * * @author Erich Schubert + * @since 0.3 */ public class InternalParameterizationErrors extends ParameterException { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/NoParameterValueException.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/NoParameterValueException.java index 50ad6215..36c23718 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/NoParameterValueException.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/NoParameterValueException.java @@ -25,6 +25,9 @@ package de.lmu.ifi.dbs.elki.utilities.optionhandling; /** * Thrown by OptionHandler in case of incorrect parameter-array. + * + * @author Arthur Zimek + * @since 0.2 */ public class NoParameterValueException extends ParameterException { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/OptionID.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/OptionID.java index 20cdc6c7..67c6326e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/OptionID.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/OptionID.java @@ -29,6 +29,7 @@ package de.lmu.ifi.dbs.elki.utilities.optionhandling; * within this class. * * @author Elke Achtert + * @since 0.2 */ public final class OptionID { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/OptionUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/OptionUtil.java index a72035f9..2f0def2b 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/OptionUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/OptionUtil.java @@ -39,6 +39,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; /** * Utility functions related to Option handling. * + * @author Erich Schubert + * @since 0.2 + * * @apiviz.uses Parameter */ public final class OptionUtil { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/ParameterException.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/ParameterException.java index 2a456fed..9527b946 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/ParameterException.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/ParameterException.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.utilities.optionhandling; * Abstract super class for all exceptions thrown during parameterization. * * @author Elke Achtert + * @since 0.2 */ @SuppressWarnings("serial") public abstract class ParameterException extends Exception { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/Parameterizer.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/Parameterizer.java index 2931309f..c0134b40 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/Parameterizer.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/Parameterizer.java @@ -31,6 +31,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * To instantiate a class, use {@link Parameterization#tryInstantiate(Class)}! * * @author Erich Schubert + * @since 0.4.0 */ public interface Parameterizer { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/UnspecifiedParameterException.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/UnspecifiedParameterException.java index c7a9909c..5569a648 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/UnspecifiedParameterException.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/UnspecifiedParameterException.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * Exception when a required parameter was not given. * * @author Erich Schubert + * @since 0.2 */ public class UnspecifiedParameterException extends WrongParameterValueException { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/UnusedParameterException.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/UnusedParameterException.java index 016cdf76..7cd86f8c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/UnusedParameterException.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/UnusedParameterException.java @@ -23,9 +23,11 @@ package de.lmu.ifi.dbs.elki.utilities.optionhandling; along with this program. If not, see <http://www.gnu.org/licenses/>. */ - /** * Thrown by OptionHandler in case of request of an unused parameter. + * + * @author Arthur Zimek + * @since 0.2 */ @SuppressWarnings("serial") public class UnusedParameterException extends ParameterException { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/WrongParameterValueException.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/WrongParameterValueException.java index c0bd4b40..cd24cf66 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/WrongParameterValueException.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/WrongParameterValueException.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * Thrown by a Parameterizable object in case of wrong parameter format. * * @author Steffi Wanka + * @since 0.2 */ public class WrongParameterValueException extends ParameterException { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/AbstractNumberConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/AbstractNumberConstraint.java index b08da639..815ccdef 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/AbstractNumberConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/AbstractNumberConstraint.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.optionhandling.constraints; * Abstract super class for constraints dealing with a certain number value. * * @author Elke Achtert + * @since 0.2 * * @apiviz.uses * de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.NumberParameter diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/AllOrNoneMustBeSetGlobalConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/AllOrNoneMustBeSetGlobalConstraint.java index f468af92..3430fd81 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/AllOrNoneMustBeSetGlobalConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/AllOrNoneMustBeSetGlobalConstraint.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * parameters ({@link Parameter}) must be set, or none of them. * * @author Steffi Wanka + * @since 0.2 */ public class AllOrNoneMustBeSetGlobalConstraint implements GlobalParameterConstraint { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/CommonConstraints.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/CommonConstraints.java index 3507e946..09df14df 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/CommonConstraints.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/CommonConstraints.java @@ -27,6 +27,7 @@ package de.lmu.ifi.dbs.elki.utilities.optionhandling.constraints; * Class storing a number of very common constraints. * * @author Erich Schubert + * @since 0.6.0 * * @apiviz.landmark * @apiviz.composedOf ParameterConstraint diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/EqualSizeGlobalConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/EqualSizeGlobalConstraint.java index ae817a7a..e6257e47 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/EqualSizeGlobalConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/EqualSizeGlobalConstraint.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ListParameter; * ) must have equal list sizes. * * @author Steffi Wanka + * @since 0.2 */ public class EqualSizeGlobalConstraint implements GlobalParameterConstraint { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/EqualStringConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/EqualStringConstraint.java index 52ac3ff6..e7379b6a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/EqualStringConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/EqualStringConstraint.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException * ) to be tested is equal to the specified constraint-strings. * * @author Steffi Wanka + * @since 0.2 * * @apiviz.uses de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.StringParameter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GlobalListSizeConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GlobalListSizeConstraint.java index 05d391b3..21669a38 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GlobalListSizeConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GlobalListSizeConstraint.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ListParameter; * specified by the integer parameter ({@link IntParameter}) given. * * @author Steffi Wanka + * @since 0.2 */ public class GlobalListSizeConstraint implements GlobalParameterConstraint { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GlobalParameterConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GlobalParameterConstraint.java index c01802bc..ae1ea824 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GlobalParameterConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GlobalParameterConstraint.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; * The proper constraint test should be implemented in the method {@link #test()}. * </p> * @author Steffi Wanka + * @since 0.2 * */ public interface GlobalParameterConstraint { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GlobalVectorListElementSizeConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GlobalVectorListElementSizeConstraint.java index 79d67a2c..b162fc4a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GlobalVectorListElementSizeConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GlobalVectorListElementSizeConstraint.java @@ -23,24 +23,24 @@ package de.lmu.ifi.dbs.elki.utilities.optionhandling.constraints; along with this program. If not, see <http://www.gnu.org/licenses/>. */ -import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.VectorListParameter; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleArrayListParameter; /** * Global parameter constraint for testing if the dimensions of each vector - * specified by a given vector list parameter ({@link VectorListParameter}) + * specified by a given vector list parameter ({@link DoubleArrayListParameter}) * correspond to the value of a integer parameter ({@link IntParameter}) given. * * @author Steffi Wanka + * @since 0.2 */ public class GlobalVectorListElementSizeConstraint implements GlobalParameterConstraint { /** * Vector list parameter. */ - private VectorListParameter vector; + private DoubleArrayListParameter vector; /** * Integer parameter providing the size constraint. @@ -56,7 +56,7 @@ public class GlobalVectorListElementSizeConstraint implements GlobalParameterCon * @param vector the vector list parameter * @param sizeConstraint the integer parameter providing the size constraint */ - public GlobalVectorListElementSizeConstraint(VectorListParameter vector, IntParameter sizeConstraint) { + public GlobalVectorListElementSizeConstraint(DoubleArrayListParameter vector, IntParameter sizeConstraint) { this.vector = vector; this.size = sizeConstraint; } @@ -73,9 +73,12 @@ public class GlobalVectorListElementSizeConstraint implements GlobalParameterCon return; } - for(Vector vec : vector.getValue()) { - if(vec.getDimensionality() != size.intValue()) { - throw new WrongParameterValueException("Global Parameter Constraint Error.\n" + "The vectors of vector list parameter " + vector.getName() + " have not the required dimension of " + size.getValue() + " given by integer parameter " + size.getName() + "."); + for(double[] vec : vector.getValue()) { + if(vec.length != size.intValue()) { + throw new WrongParameterValueException("Global Parameter Constraint Error.\n" // + + "The vectors of vector list parameter " + vector.getName() // + + " have not the required dimension of " + size.getValue() // + + " given by integer parameter " + size.getName() + "."); } } } @@ -84,4 +87,4 @@ public class GlobalVectorListElementSizeConstraint implements GlobalParameterCon public String getDescription() { return "The dimensionality of the vectors of vector list parameter " + vector.getName() + " must have the value of integer parameter " + size.getName(); } -}
\ No newline at end of file +} diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GreaterConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GreaterConstraint.java index 002ff4f3..b9e445d1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GreaterConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GreaterConstraint.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.NumberParameter; * constraint value. * * @author Steffi Wanka + * @since 0.2 */ public class GreaterConstraint extends AbstractNumberConstraint<Number> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GreaterEqualConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GreaterEqualConstraint.java index fab416d4..a8791f97 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GreaterEqualConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/GreaterEqualConstraint.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.NumberParameter; * than the specified constraint value. * * @author Steffi Wanka + * @since 0.2 */ public class GreaterEqualConstraint extends AbstractNumberConstraint<Number> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/LessConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/LessConstraint.java index c63fa1ea..c2b73d1d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/LessConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/LessConstraint.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.NumberParameter; * constraint value. * * @author Steffi Wanka + * @since 0.2 */ public class LessConstraint extends AbstractNumberConstraint<Number> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/LessEqualConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/LessEqualConstraint.java index 8aef29b4..a8c210d4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/LessEqualConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/LessEqualConstraint.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.NumberParameter; * the specified constraint value. * * @author Steffi Wanka + * @since 0.2 */ public class LessEqualConstraint extends AbstractNumberConstraint<Number> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/LessEqualGlobalConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/LessEqualGlobalConstraint.java index c3f4ef09..10f12988 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/LessEqualGlobalConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/LessEqualGlobalConstraint.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.NumberParameter; * the value of the second number parameter ({@link NumberParameter}). * * @author Steffi Wanka + * @since 0.2 * @param <T> Number type */ public class LessEqualGlobalConstraint<T extends Number> implements GlobalParameterConstraint { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/LessGlobalConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/LessGlobalConstraint.java index 0ab9fbae..57b9d473 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/LessGlobalConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/LessGlobalConstraint.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.NumberParameter; * value of the second number parameter ({@link NumberParameter}) given. * * @author Steffi Wanka + * @since 0.2 * @param <T> Number type */ public class LessGlobalConstraint<T extends Number> implements GlobalParameterConstraint { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ListEachConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ListEachConstraint.java index 764b1773..ff1aba69 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ListEachConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ListEachConstraint.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; * Applies constraints to all elements of a list. * * @author Erich Schubert + * @since 0.5.5 * * @apiviz.composedOf ParameterConstraint oneway 1 n */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ListParameterNoDuplicateValueConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ListParameterNoDuplicateValueConstraint.java index e0dfe3e1..f5c052b6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ListParameterNoDuplicateValueConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ListParameterNoDuplicateValueConstraint.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException * is not allowed to have duplicate values. * * @author Arthur Zimek + * @since 0.5.5 */ public class ListParameterNoDuplicateValueConstraint<T extends Object> implements ParameterConstraint<List<T>> { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ListSizeConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ListSizeConstraint.java index 0969ac06..c9f273de 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ListSizeConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ListSizeConstraint.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ListParameter; * FIXME: Unfortunately, we cannot have good type safety anymore right now. * * @author Steffi Wanka + * @since 0.2 * * @apiviz.uses * de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ListParameter diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/NoDuplicateValueGlobalConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/NoDuplicateValueGlobalConstraint.java index 4efd6118..55ea5363 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/NoDuplicateValueGlobalConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/NoDuplicateValueGlobalConstraint.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * parameters ({@link NumberParameter}) are not allowed to have the same value. * * @author Steffi Wanka + * @since 0.2 */ public class NoDuplicateValueGlobalConstraint implements GlobalParameterConstraint { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/OneMustBeSetGlobalConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/OneMustBeSetGlobalConstraint.java index af35e3e9..9ed325f4 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/OneMustBeSetGlobalConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/OneMustBeSetGlobalConstraint.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * set. * * @author Steffi Wanka + * @since 0.2 */ public class OneMustBeSetGlobalConstraint implements GlobalParameterConstraint { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/OnlyOneIsAllowedToBeSetGlobalConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/OnlyOneIsAllowedToBeSetGlobalConstraint.java index c37a05f2..58c69dd9 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/OnlyOneIsAllowedToBeSetGlobalConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/OnlyOneIsAllowedToBeSetGlobalConstraint.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * parameters ({@link Parameter}) is allowed to be set. * * @author Steffi Wanka + * @since 0.2 */ public class OnlyOneIsAllowedToBeSetGlobalConstraint implements GlobalParameterConstraint { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ParameterConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ParameterConstraint.java index 99009941..9061533b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ParameterConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ParameterConstraint.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; * </p> * * @author Steffi Wanka + * @since 0.2 * @param <T> the type of the parameter the constraint applies to */ public interface ParameterConstraint<T> { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ParameterFlagGlobalConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ParameterFlagGlobalConstraint.java index 03e4b9e1..3de8ecb2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ParameterFlagGlobalConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/ParameterFlagGlobalConstraint.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * not. * * @author Steffi Wanka + * @since 0.2 * * @apiviz.uses de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag * @apiviz.uses diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/StringLengthConstraint.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/StringLengthConstraint.java index 50417b21..7a6acd32 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/StringLengthConstraint.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/constraints/StringLengthConstraint.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException * . * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.StringParameter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/AbstractParameterization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/AbstractParameterization.java index 4980af5f..67180790 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/AbstractParameterization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/AbstractParameterization.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * Abstract class with shared code for parameterization handling. * * @author Erich Schubert + * @since 0.3 */ public abstract class AbstractParameterization implements Parameterization { // TODO: refactor "tryInstantiate" even in a higher class? diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/ChainedParameterization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/ChainedParameterization.java index 98cfa5a9..f4f8ca3c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/ChainedParameterization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/ChainedParameterization.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * for examples. * * @author Erich Schubert + * @since 0.3 */ public class ChainedParameterization extends AbstractParameterization { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/EmptyParameterization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/EmptyParameterization.java index fe1de0be..c89a1420 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/EmptyParameterization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/EmptyParameterization.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * Parameterization handler that only allows the use of default values. * * @author Erich Schubert + * @since 0.3 */ public class EmptyParameterization extends AbstractParameterization { @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/ListParameterization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/ListParameterization.java index c67533a6..542c98ef 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/ListParameterization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/ListParameterization.java @@ -33,24 +33,25 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; -import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; /** * Parameterization handler using a List and OptionIDs, for programmatic use. * * @author Erich Schubert + * @since 0.3 */ public class ListParameterization extends AbstractParameterization { /** * The actual parameters, for storage */ - LinkedList<Pair<OptionID, Object>> parameters = new LinkedList<>(); + List<ParameterPair> parameters; /** * Default constructor. */ public ListParameterization() { super(); + this.parameters = new LinkedList<>(); } /** @@ -58,10 +59,11 @@ public class ListParameterization extends AbstractParameterization { * * @param dbParameters existing parameter collection */ - public ListParameterization(Collection<Pair<OptionID, Object>> dbParameters) { + public ListParameterization(Collection<ParameterPair> dbParameters) { this(); - for (Pair<OptionID, Object> pair : dbParameters) { - addParameter(pair.first, pair.second); + this.parameters = new LinkedList<>(); + for(ParameterPair pair : dbParameters) { + addParameter(pair.option, pair.value); } } @@ -71,7 +73,7 @@ public class ListParameterization extends AbstractParameterization { * @param optionid Option ID */ public void addFlag(OptionID optionid) { - parameters.add(new Pair<OptionID, Object>(optionid, Flag.SET)); + parameters.add(new ParameterPair(optionid, Flag.SET)); } /** @@ -81,7 +83,7 @@ public class ListParameterization extends AbstractParameterization { * @param value Value */ public void addParameter(OptionID optionid, Object value) { - parameters.add(new Pair<>(optionid, value)); + parameters.add(new ParameterPair(optionid, value)); } /** @@ -90,7 +92,7 @@ public class ListParameterization extends AbstractParameterization { * @param flag Flag to add, if set */ public void forwardOption(Flag flag) { - if (flag.isDefined() && flag.getValue().booleanValue()) { + if(flag.isDefined() && flag.getValue().booleanValue()) { addFlag(flag.getOptionID()); } } @@ -101,19 +103,19 @@ public class ListParameterization extends AbstractParameterization { * @param param Parameter to add */ public void forwardOption(Parameter<?> param) { - if (param.isDefined()) { + if(param.isDefined()) { addParameter(param.getOptionID(), param.getValue()); } } @Override public boolean setValueForOption(Parameter<?> opt) throws ParameterException { - Iterator<Pair<OptionID, Object>> iter = parameters.iterator(); - while (iter.hasNext()) { - Pair<OptionID, Object> pair = iter.next(); - if (pair.first == opt.getOptionID()) { + Iterator<ParameterPair> iter = parameters.iterator(); + while(iter.hasNext()) { + ParameterPair pair = iter.next(); + if(pair.option == opt.getOptionID()) { iter.remove(); - opt.setValue(pair.second); + opt.setValue(pair.value); return true; } } @@ -125,7 +127,7 @@ public class ListParameterization extends AbstractParameterization { * * @return Unused parameters. */ - public List<Pair<OptionID, Object>> getRemainingParameters() { + public List<ParameterPair> getRemainingParameters() { return parameters; } @@ -145,9 +147,9 @@ public class ListParameterization extends AbstractParameterization { @Override public String toString() { StringBuilder buf = new StringBuilder(); - for (Pair<OptionID, Object> pair : parameters) { - buf.append('-').append(pair.getFirst().toString()).append(' '); - buf.append(pair.getSecond().toString()).append(' '); + for(ParameterPair pair : parameters) { + buf.append('-').append(pair.option.toString()).append(' '); + buf.append(pair.value.toString()).append(' '); } return buf.toString(); } @@ -159,16 +161,53 @@ public class ListParameterization extends AbstractParameterization { */ public ArrayList<String> serialize() { ArrayList<String> params = new ArrayList<>(); - for (Pair<OptionID, Object> pair : parameters) { - params.add("-" + pair.getFirst().toString()); - if (pair.getSecond() instanceof String) { - params.add((String) pair.getSecond()); - } else if (pair.getSecond() instanceof Class) { - params.add(((Class<?>) pair.getSecond()).getCanonicalName()); - } else { // Fallback: - params.add(pair.getSecond().toString()); + for(ParameterPair pair : parameters) { + params.add("-" + pair.option.toString()); + if(pair.value instanceof String) { + params.add((String) pair.value); + } + else if(pair.value instanceof Class) { + params.add(((Class<?>) pair.value).getCanonicalName()); + } + else { // Fallback: + params.add(pair.value.toString()); } } return params; } + + /** + * Parameter pair, package-private. + * + * @author Erich Schubert + * + * @apiviz.exclude + */ + static final class ParameterPair { + /** + * Option key. + */ + public OptionID option; + + /** + * Option value. + */ + public Object value; + + /** + * Constructor. + * + * @param key Option key + * @param value Option value + */ + public ParameterPair(OptionID key, Object value) { + this.option = key; + this.value = value; + } + + @Override + public String toString() { + return "-" + option.getName() + " " + value; + } + } } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/MergedParameterization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/MergedParameterization.java index 4faa3c60..926e660f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/MergedParameterization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/MergedParameterization.java @@ -23,17 +23,16 @@ package de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization; along with this program. If not, see <http://www.gnu.org/licenses/>. */ -import java.util.Collection; import java.util.ArrayList; +import java.util.Collection; import java.util.List; import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; import de.lmu.ifi.dbs.elki.utilities.optionhandling.InternalParameterizationErrors; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; import de.lmu.ifi.dbs.elki.utilities.optionhandling.constraints.GlobalParameterConstraint; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.ListParameterization.ParameterPair; import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; -import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; /** * This configuration can be "rewound" to allow the same values to be consumed @@ -42,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.pairs.Pair; * e.g. in visualization classes. * * @author Erich Schubert + * @since 0.3 */ // TODO: Can we merge MergedParameterization and TrackParameters into one? public class MergedParameterization implements Parameterization { @@ -58,7 +58,7 @@ public class MergedParameterization implements Parameterization { /** * Parameters to rewind. */ - final private List<Pair<OptionID, Object>> used; + final private List<ParameterPair> used; /** * Constructor. @@ -79,7 +79,7 @@ public class MergedParameterization implements Parameterization { * @param current Current parameterization to re-used * @param used Used parameters list. */ - private MergedParameterization(Parameterization inner, ListParameterization current, List<Pair<OptionID, Object>> used) { + private MergedParameterization(Parameterization inner, ListParameterization current, List<ParameterPair> used) { super(); this.inner = inner; this.current = current; @@ -91,8 +91,8 @@ public class MergedParameterization implements Parameterization { */ public void rewind() { synchronized(used) { - for(Pair<OptionID, Object> pair : used) { - current.addParameter(pair.first, pair.second); + for(ParameterPair pair : used) { + current.addParameter(pair.option, pair.value); } used.clear(); } @@ -102,7 +102,7 @@ public class MergedParameterization implements Parameterization { public boolean setValueForOption(Parameter<?> opt) throws ParameterException { try { if(current.setValueForOption(opt)) { - used.add(new Pair<OptionID, Object>(opt.getOptionID(), opt.getValue())); + used.add(new ParameterPair(opt.getOptionID(), opt.getValue())); return true; } } @@ -110,10 +110,10 @@ public class MergedParameterization implements Parameterization { current.reportError(e); } if(inner.setValueForOption(opt)) { - used.add(new Pair<OptionID, Object>(opt.getOptionID(), opt.getValue())); + used.add(new ParameterPair(opt.getOptionID(), opt.getValue())); return true; } - used.add(new Pair<OptionID, Object>(opt.getOptionID(), opt.getDefaultValue())); + used.add(new ParameterPair(opt.getOptionID(), opt.getDefaultValue())); return false; } @@ -128,7 +128,7 @@ public class MergedParameterization implements Parameterization { public Collection<ParameterException> getErrors() { return current.getErrors(); } - + @Override public boolean hasErrors() { return current.hasErrors(); @@ -142,11 +142,11 @@ public class MergedParameterization implements Parameterization { @Override public boolean grab(Parameter<?> opt) { try { - if (setValueForOption(opt)) { + if(setValueForOption(opt)) { return true; } // Try default value instead. - if (opt.tryDefaultValue()) { + if(opt.tryDefaultValue()) { return true; } // No value available. @@ -175,7 +175,7 @@ public class MergedParameterization implements Parameterization { return ClassGenericsUtil.tryInstantiate(r, c, this); } catch(Exception e) { - reportError(new InternalParameterizationErrors("Error instantiating internal class: "+c.getName(), e)); + reportError(new InternalParameterizationErrors("Error instantiating internal class: " + c.getName(), e)); return null; } } @@ -186,7 +186,7 @@ public class MergedParameterization implements Parameterization { return ClassGenericsUtil.tryInstantiate(c, c, this); } catch(Exception e) { - reportError(new InternalParameterizationErrors("Error instantiating internal class: "+c.getName(), e)); + reportError(new InternalParameterizationErrors("Error instantiating internal class: " + c.getName(), e)); return null; } } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/Parameterization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/Parameterization.java index f165942e..29c22e27 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/Parameterization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/Parameterization.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * @apiviz.uses ParameterException * * @author Erich Schubert + * @since 0.3 */ public interface Parameterization { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/SerializedParameterization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/SerializedParameterization.java index b5ba3e58..2837983d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/SerializedParameterization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/SerializedParameterization.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * When building parameter lists, use {@link ListParameterization} where possible. * * @author Erich Schubert + * @since 0.3 */ public class SerializedParameterization extends AbstractParameterization { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/TrackParameters.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/TrackParameters.java index 5429ea8b..4b8ea073 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/TrackParameters.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/TrackParameters.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * All actual Parameterization operations are forwarded to the inner class. * * @author Erich Schubert + * @since 0.3 * * @apiviz.composedOf TrackedParameter */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/TrackedParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/TrackedParameter.java index caa87440..e039f492 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/TrackedParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/TrackedParameter.java @@ -28,6 +28,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * Class containing an object, and the associated value. * * @author Erich Schubert + * @since 0.3 */ public class TrackedParameter { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/UnParameterization.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/UnParameterization.java index a1d58676..ea48655c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/UnParameterization.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameterization/UnParameterization.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * in a non-recursive way. * * @author Erich Schubert + * @since 0.3 */ public class UnParameterization implements Parameterization { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/AbstractParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/AbstractParameter.java index d78d0dcc..17d17c6d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/AbstractParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/AbstractParameter.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.constraints.ParameterConstra * * @author Steffi Wanka * @author Erich Schubert + * @since 0.3 * * @apiviz.composedOf OptionID * @apiviz.uses ParameterConstraint diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ClassListParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ClassListParameter.java index d9d1a3a2..b0ce1bc7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ClassListParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ClassListParameter.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * * @author Steffi Wanka * @author Erich Schubert + * @since 0.3 * * @apiviz.uses ELKIServiceRegistry * @@ -96,6 +97,23 @@ public class ClassListParameter<C> extends ListParameter<ClassListParameter<C>, return buf.toString(); } + @Override + public String getDefaultValueAsString() { + StringBuilder buf = new StringBuilder(); + final String defPackage = restrictionClass.getPackage().getName() + "."; + for(Class<? extends C> c : getDefaultValue()) { + if(buf.length() > 0) { + buf.append(LIST_SEP); + } + String name = c.getName(); + if(name.startsWith(defPackage)) { + name = name.substring(defPackage.length()); + } + buf.append(name); + } + return buf.toString(); + } + @SuppressWarnings("unchecked") @Override protected List<Class<? extends C>> parseValue(Object obj) throws ParameterException { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ClassParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ClassParameter.java index 6f562838..39e0daae 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ClassParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ClassParameter.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * * @author Steffi Wanka * @author Erich Schubert + * @since 0.2 * * @apiviz.uses ELKIServiceRegistry * diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/VectorListParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/DoubleArrayListParameter.java index b6d999fb..696adbff 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/VectorListParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/DoubleArrayListParameter.java @@ -3,7 +3,7 @@ package de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters; This file is part of ELKI: Environment for Developing KDD-Applications Supported by Index-Structures - Copyright (C) 2015 + Copyright (C) 2016 Ludwig-Maximilians-Universität München Lehr- und Forschungseinheit für Datenbanksysteme ELKI Development Team @@ -23,12 +23,11 @@ package de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters; */ import java.util.ArrayList; +import java.util.Arrays; import java.util.Iterator; import java.util.List; -import de.lmu.ifi.dbs.elki.math.linearalgebra.Vector; import de.lmu.ifi.dbs.elki.utilities.FormatUtil; -import de.lmu.ifi.dbs.elki.utilities.datastructures.arraylike.DoubleArray; import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException; @@ -39,8 +38,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.constraints.ParameterConstra * * @author Steffi Wanka * @author Erich Schubert + * @since 0.3 */ -public class VectorListParameter extends ListParameter<VectorListParameter, List<Vector>> { +public class DoubleArrayListParameter extends ListParameter<DoubleArrayListParameter, List<double[]>> { /** * Constructs a vector list parameter with the given name and description. * @@ -48,7 +48,7 @@ public class VectorListParameter extends ListParameter<VectorListParameter, List * @param constraint Constraint * @param defaultValue Default value */ - public VectorListParameter(OptionID optionID, ParameterConstraint<List<Vector>> constraint, List<Vector> defaultValue) { + public DoubleArrayListParameter(OptionID optionID, ParameterConstraint<List<double[]>> constraint, List<double[]> defaultValue) { super(optionID, defaultValue); addConstraint(constraint); } @@ -60,7 +60,7 @@ public class VectorListParameter extends ListParameter<VectorListParameter, List * @param constraint Constraint * @param optional Optional flag */ - public VectorListParameter(OptionID optionID, ParameterConstraint<List<Vector>> constraint, boolean optional) { + public DoubleArrayListParameter(OptionID optionID, ParameterConstraint<List<double[]>> constraint, boolean optional) { super(optionID, optional); addConstraint(constraint); } @@ -71,7 +71,7 @@ public class VectorListParameter extends ListParameter<VectorListParameter, List * @param optionID Option ID * @param constraint Constraint */ - public VectorListParameter(OptionID optionID, ParameterConstraint<List<Vector>> constraint) { + public DoubleArrayListParameter(OptionID optionID, ParameterConstraint<List<double[]>> constraint) { super(optionID); addConstraint(constraint); } @@ -82,11 +82,9 @@ public class VectorListParameter extends ListParameter<VectorListParameter, List * @param optionID Option ID * @param defaultValue Default value */ - // Indiscernible from optionID, constraints - /* - * public VectorListParameter(OptionID optionID, List<Vector> defaultValue) { - * super(optionID, defaultValue); } - */ + public DoubleArrayListParameter(OptionID optionID, List<double[]> defaultValue) { + super(optionID, defaultValue); + } /** * Constructs a vector list parameter with the given name and description. @@ -94,7 +92,7 @@ public class VectorListParameter extends ListParameter<VectorListParameter, List * @param optionID Option ID * @param optional Optional flag */ - public VectorListParameter(OptionID optionID, boolean optional) { + public DoubleArrayListParameter(OptionID optionID, boolean optional) { super(optionID, optional); } @@ -103,17 +101,17 @@ public class VectorListParameter extends ListParameter<VectorListParameter, List * * @param optionID Option ID */ - public VectorListParameter(OptionID optionID) { + public DoubleArrayListParameter(OptionID optionID) { super(optionID); } @Override public String getValueAsString() { StringBuilder buf = new StringBuilder(); - List<Vector> val = getValue(); - Iterator<Vector> valiter = val.iterator(); + List<double[]> val = getValue(); + Iterator<double[]> valiter = val.iterator(); while(valiter.hasNext()) { - buf.append(FormatUtil.format(valiter.next().getArrayRef(), LIST_SEP)); + buf.append(FormatUtil.format(valiter.next(), LIST_SEP)); // Append separation character if(valiter.hasNext()) { buf.append(VECTOR_SEP); @@ -122,47 +120,47 @@ public class VectorListParameter extends ListParameter<VectorListParameter, List return buf.toString(); } - @SuppressWarnings("unchecked") @Override - protected List<Vector> parseValue(Object obj) throws ParameterException { - try { - List<?> l = List.class.cast(obj); - // do extra validation: - for(Object o : l) { - List<?> v = List.class.cast(o); - for(Object c : v) { - if(!(c instanceof Double)) { - throw new WrongParameterValueException("Wrong parameter format for parameter \"" + getName() + "\". Given list contains objects of different type!"); - } - } + public String getDefaultValueAsString() { + StringBuilder buf = new StringBuilder(); + List<double[]> val = getDefaultValue(); + Iterator<double[]> valiter = val.iterator(); + while(valiter.hasNext()) { + buf.append(FormatUtil.format(valiter.next(), LIST_SEP)); + // Append separation character + if(valiter.hasNext()) { + buf.append(VECTOR_SEP); } - // TODO: can we use reflection to get extra checks? - // TODO: Should we copy the list and vectors? - return (List<Vector>) l; - } - catch(ClassCastException e) { - // continue with other attempts. } + return buf.toString(); + } + + @Override + protected List<double[]> parseValue(Object obj) throws ParameterException { if(obj instanceof String) { String[] vectors = VECTOR_SPLIT.split((String) obj); if(vectors.length == 0) { throw new WrongParameterValueException("Wrong parameter format! Given list of vectors for parameter \"" + getName() + "\" is empty!"); } - ArrayList<Vector> vecs = new ArrayList<>(); + ArrayList<double[]> vecs = new ArrayList<>(); - DoubleArray vectorCoord = new DoubleArray(); + double[] buf = new double[11]; + int used = 0; for(String vector : vectors) { - vectorCoord.clear(); + used = 0; String[] coordinates = SPLIT.split(vector); for(String coordinate : coordinates) { try { - vectorCoord.add(FormatUtil.parseDouble(coordinate)); + if(used == buf.length) { + buf = Arrays.copyOf(buf, buf.length << 1); + } + buf[used++] = FormatUtil.parseDouble(coordinate); } catch(NumberFormatException e) { throw new WrongParameterValueException("Wrong parameter format! Coordinates of vector \"" + vector + "\" are not valid!"); } } - vecs.add(new Vector(vectorCoord.toArray())); + vecs.add(Arrays.copyOf(buf, used)); } return vecs; } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/DoubleListParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/DoubleListParameter.java index 074bb0ed..a9fe5471 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/DoubleListParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/DoubleListParameter.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException * * @author Steffi Wanka * @author Erich Schubert + * @since 0.3 */ public class DoubleListParameter extends ListParameter<DoubleListParameter, double[]> { /** @@ -60,6 +61,11 @@ public class DoubleListParameter extends ListParameter<DoubleListParameter, doub } @Override + public String getDefaultValueAsString() { + return FormatUtil.format(getDefaultValue(), LIST_SEP); + } + + @Override protected double[] parseValue(Object obj) throws ParameterException { if(obj instanceof double[]) { return double[].class.cast(obj); diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/DoubleParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/DoubleParameter.java index a28f8d38..ef7d4a88 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/DoubleParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/DoubleParameter.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException * * @author Steffi Wanka * @author Erich Schubert + * @since 0.2 */ public class DoubleParameter extends NumberParameter<DoubleParameter, Double> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/EnumParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/EnumParameter.java index 0cad6e11..d1fafa79 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/EnumParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/EnumParameter.java @@ -60,6 +60,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException * </p> * * @author Florian Nuecke + * @since 0.4.0 * * @param <E> Enum type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/FileListParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/FileListParameter.java index e5f1b021..cc6d885f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/FileListParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/FileListParameter.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException * * @author Steffi Wanka * @author Erich Schubert + * @since 0.3 */ public class FileListParameter extends ListParameter<FileListParameter, List<File>> { /** @@ -89,6 +90,20 @@ public class FileListParameter extends ListParameter<FileListParameter, List<Fil return buf.toString(); } + @Override + public String getDefaultValueAsString() { + StringBuilder buf = new StringBuilder(); + List<File> val = getDefaultValue(); + Iterator<File> veciter = val.iterator(); + while(veciter.hasNext()) { + buf.append(veciter.next()); + if (veciter.hasNext()) { + buf.append(LIST_SEP); + } + } + return buf.toString(); + } + @SuppressWarnings("unchecked") @Override protected List<File> parseValue(Object obj) throws ParameterException { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/FileParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/FileParameter.java index 0e865f2d..9571a018 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/FileParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/FileParameter.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException * * @author Steffi Wanka * @author Erich Schubert + * @since 0.3 */ // TODO: turn FileType into a Constraint? public class FileParameter extends AbstractParameter<FileParameter, File> { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/Flag.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/Flag.java index 8d83ed2c..d1e29eb7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/Flag.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/Flag.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException * * @author Steffi Wanka * @author Erich Schubert + * @since 0.3 */ public class Flag extends AbstractParameter<Flag, Boolean> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/IntListParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/IntListParameter.java index 756dbb90..59bfb3a5 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/IntListParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/IntListParameter.java @@ -23,7 +23,6 @@ package de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters; along with this program. If not, see <http://www.gnu.org/licenses/>. */ -import de.lmu.ifi.dbs.elki.utilities.BitsUtil; import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException; @@ -33,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException * * @author Elke Achtert * @author Erich Schubert + * @since 0.2 */ public class IntListParameter extends ListParameter<IntListParameter, int[]> { /** @@ -70,6 +70,21 @@ public class IntListParameter extends ListParameter<IntListParameter, int[]> { } @Override + public String getDefaultValueAsString() { + int[] val = getDefaultValue(); + if(val.length == 0) { + return ""; + } + StringBuilder buf = new StringBuilder(); + buf.append(val[0]); + for(int i = 1; i < val.length; i++) { + buf.append(LIST_SEP); + buf.append(val[i]); + } + return buf.toString(); + } + + @Override protected int[] parseValue(Object obj) throws ParameterException { if(obj instanceof int[]) { return (int[]) obj; @@ -95,7 +110,7 @@ public class IntListParameter extends ListParameter<IntListParameter, int[]> { /** * Returns a string representation of the parameter's type. - * + * * @return "<int_1,...,int_n>" */ @Override @@ -105,7 +120,9 @@ public class IntListParameter extends ListParameter<IntListParameter, int[]> { /** * Get the values as a bitmask. - * + * + * See also: {@link de.lmu.ifi.dbs.elki.utilities.BitsUtil} + * * @return Bitmask */ public long[] getValueAsBitSet() { @@ -114,9 +131,9 @@ public class IntListParameter extends ListParameter<IntListParameter, int[]> { for(int d : value) { maxd = (d > maxd) ? d : maxd; } - long[] dimensions = BitsUtil.zero(maxd); + long[] dimensions = new long[(maxd >>> 6) + 1]; for(int d : value) { - BitsUtil.setI(dimensions, d); + dimensions[d >>> 6] |= 1L << (d & 0x3F); } return dimensions; } diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/IntParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/IntParameter.java index d6adf273..9ed15e95 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/IntParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/IntParameter.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException * * @author Steffi Wanka * @author Erich Schubert + * @since 0.3 */ public class IntParameter extends NumberParameter<IntParameter, Integer> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ListParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ListParameter.java index 097475fb..82c4a46d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ListParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ListParameter.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; * * @author Steffi Wanka * @author Erich Schubert + * @since 0.2 * * @param <THIS> Type self-reference * @param <T> List type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/LongParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/LongParameter.java index 11aff3cb..f44f759d 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/LongParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/LongParameter.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException * * @author Steffi Wanka * @author Erich Schubert + * @since 0.2 */ public class LongParameter extends NumberParameter<LongParameter, Long> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/NumberParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/NumberParameter.java index c71db779..bb5c6864 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/NumberParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/NumberParameter.java @@ -30,6 +30,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; * * @author Steffi Wanka * @author Erich Schubert + * @since 0.2 * * @param <THIS> type self-reference * @param <T> the type of a possible value (i.e., the type of the option) diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ObjectListParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ObjectListParameter.java index baaa2765..d31c4117 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ObjectListParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ObjectListParameter.java @@ -37,6 +37,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * Parameter that represents a list of objects (in contrast to a class list parameter, they will be instanced at most once.) * * @author Erich Schubert + * @since 0.3 * * @param <C> Class type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ObjectParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ObjectParameter.java index 40d5b49a..aa0e4a17 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ObjectParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/ObjectParameter.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameterization.Parameteriz * * @author Steffi Wanka * @author Erich Schubert + * @since 0.3 * @param <C> Class type */ public class ObjectParameter<C> extends ClassParameter<C> { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/Parameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/Parameter.java index 9c2d7ea8..99751076 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/Parameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/Parameter.java @@ -1,10 +1,5 @@ package de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.UnspecifiedParameterException; -import de.lmu.ifi.dbs.elki.utilities.optionhandling.constraints.ParameterConstraint; - /* This file is part of ELKI: Environment for Developing KDD-Applications Supported by Index-Structures @@ -28,6 +23,11 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.constraints.ParameterConstra along with this program. If not, see <http://www.gnu.org/licenses/>. */ +import de.lmu.ifi.dbs.elki.utilities.optionhandling.OptionID; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.ParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.UnspecifiedParameterException; +import de.lmu.ifi.dbs.elki.utilities.optionhandling.constraints.ParameterConstraint; + /** * Interface for the parameter of a class. * @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.constraints.ParameterConstra * * @author Steffi Wanka * @author Erich Schubert + * @since 0.3 * * @apiviz.composedOf OptionID * @apiviz.uses ParameterConstraint diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/PatternParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/PatternParameter.java index 3c010db6..f2160d53 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/PatternParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/PatternParameter.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException * * @author Steffi Wanka * @author Erich Schubert + * @since 0.3 */ public class PatternParameter extends AbstractParameter<PatternParameter, Pattern> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/RandomParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/RandomParameter.java index 0d5f3741..5e7d6c66 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/RandomParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/RandomParameter.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException * Parameter for random generators and/or random seeds. * * @author Erich Schubert + * @since 0.5.5 */ public class RandomParameter extends AbstractParameter<RandomParameter, RandomFactory> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/StringParameter.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/StringParameter.java index 0f06beef..7882c9ee 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/StringParameter.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/optionhandling/parameters/StringParameter.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.WrongParameterValueException * * @author Steffi Wanka * @author Erich Schubert + * @since 0.3 */ public class StringParameter extends AbstractParameter<StringParameter, String> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/DoubleDoublePair.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/DoubleDoublePair.java index af10137b..bdfd2b1c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/DoubleDoublePair.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/DoubleDoublePair.java @@ -29,6 +29,7 @@ import java.util.Comparator; * Pair storing two doubles. * * @author Erich Schubert + * @since 0.2 * * @apiviz.has Comparator */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/DoubleIntPair.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/DoubleIntPair.java index 08d0fadd..8f8481b0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/DoubleIntPair.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/DoubleIntPair.java @@ -29,6 +29,7 @@ import java.util.Comparator; * Pair storing an integer and a double. * * @author Erich Schubert + * @since 0.2 * * @apiviz.has Comparator */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/DoubleObjPair.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/DoubleObjPair.java index 5fdd005e..ccbc38d0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/DoubleObjPair.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/DoubleObjPair.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.utilities.pairs; * Pair storing a native double value and an arbitrary object. * * @author Erich Schubert + * @since 0.4.0 * * @param <O> Object type */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/IntDoublePair.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/IntDoublePair.java index 2b8fd6cf..61993a15 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/IntDoublePair.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/IntDoublePair.java @@ -29,6 +29,7 @@ import java.util.Comparator; * Pair storing an integer and a double. * * @author Erich Schubert + * @since 0.2 * * @apiviz.has Comparator */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/IntIntPair.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/IntIntPair.java index e7fd6db8..10a458d0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/IntIntPair.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/IntIntPair.java @@ -29,6 +29,7 @@ import java.util.Comparator; * Pair storing two integers. * * @author Erich Schubert + * @since 0.2 * * @apiviz.has Comparator */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/Pair.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/Pair.java index 28f7fdaa..40b049f2 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/Pair.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/pairs/Pair.java @@ -36,6 +36,7 @@ import de.lmu.ifi.dbs.elki.utilities.ClassGenericsUtil; * meaningful field names and comparators. * * @author Erich Schubert + * @since 0.2 * * @param <FIRST> first type * @param <SECOND> second type diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/AxisBasedReferencePoints.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/AxisBasedReferencePoints.java index 026cf048..337197a3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/AxisBasedReferencePoints.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/AxisBasedReferencePoints.java @@ -43,6 +43,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * surrounding cube. * * @author Erich Schubert + * @since 0.3 */ public class AxisBasedReferencePoints implements ReferencePointsHeuristic { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/FullDatabaseReferencePoints.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/FullDatabaseReferencePoints.java index aed7845f..9e4b9c8f 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/FullDatabaseReferencePoints.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/FullDatabaseReferencePoints.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.database.relation.RelationUtil; * Strategy to use the complete database as reference points. * * @author Erich Schubert + * @since 0.3 */ public class FullDatabaseReferencePoints implements ReferencePointsHeuristic { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/GridBasedReferencePoints.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/GridBasedReferencePoints.java index 1d614bff..45e3c66b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/GridBasedReferencePoints.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/GridBasedReferencePoints.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * Grid-based strategy to pick reference points. * * @author Erich Schubert + * @since 0.3 */ public class GridBasedReferencePoints implements ReferencePointsHeuristic { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/RandomGeneratedReferencePoints.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/RandomGeneratedReferencePoints.java index 9de4e5e8..9b287443 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/RandomGeneratedReferencePoints.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/RandomGeneratedReferencePoints.java @@ -25,6 +25,7 @@ package de.lmu.ifi.dbs.elki.utilities.referencepoints; import java.util.ArrayList; import java.util.Collection; +import java.util.Random; import de.lmu.ifi.dbs.elki.data.NumberVector; import de.lmu.ifi.dbs.elki.database.relation.Relation; @@ -41,8 +42,9 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; /** * Reference points generated randomly within the used data space. - * + * * @author Erich Schubert + * @since 0.3 */ public class RandomGeneratedReferencePoints implements ReferencePointsHeuristic { /** @@ -62,7 +64,7 @@ public class RandomGeneratedReferencePoints implements ReferencePointsHeuristic /** * Constructor. - * + * * @param samplesize Size of desired sample set * @param scale Scaling factor * @param rnd Random generator @@ -86,14 +88,14 @@ public class RandomGeneratedReferencePoints implements ReferencePointsHeuristic mean[d] -= delta[d] * .5; } + Random rand = rnd.getSingleThreadedRandom(); ArrayList<Vector> result = new ArrayList<>(samplesize); double[] vec = new double[dim]; for(int i = 0; i < samplesize; i++) { for(int d = 0; d < dim; d++) { - vec[d] = mean[d] + (Math.random() - 0.5) * scale * delta[d]; + vec[d] = mean[d] + (rand.nextDouble() - 0.5) * scale * delta[d]; } Vector newp = new Vector(vec); - // logger.debug("New reference point: " + FormatUtil.format(vec)); result.add(newp); } @@ -102,9 +104,9 @@ public class RandomGeneratedReferencePoints implements ReferencePointsHeuristic /** * Parameterization class. - * + * * @author Erich Schubert - * + * * @apiviz.exclude */ public static class Parameterizer extends AbstractParameterizer { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/RandomSampleReferencePoints.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/RandomSampleReferencePoints.java index a8b17234..14d91a55 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/RandomSampleReferencePoints.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/RandomSampleReferencePoints.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.RandomParameter; * Random-Sampling strategy for picking reference points. * * @author Erich Schubert + * @since 0.3 */ public class RandomSampleReferencePoints implements ReferencePointsHeuristic { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/ReferencePointsHeuristic.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/ReferencePointsHeuristic.java index 2b417d84..00cef7dc 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/ReferencePointsHeuristic.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/ReferencePointsHeuristic.java @@ -32,6 +32,7 @@ import de.lmu.ifi.dbs.elki.database.relation.Relation; * Simple Interface for an heuristic to pick reference points. * * @author Erich Schubert + * @since 0.3 */ public interface ReferencePointsHeuristic { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/StarBasedReferencePoints.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/StarBasedReferencePoints.java index f1e1c1fb..2b35108b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/StarBasedReferencePoints.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/referencepoints/StarBasedReferencePoints.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag; * Star-based strategy to pick reference points. * * @author Erich Schubert + * @since 0.3 */ public class StarBasedReferencePoints implements ReferencePointsHeuristic { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/ClipScaling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/ClipScaling.java index 3917c550..74558293 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/ClipScaling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/ClipScaling.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * maximum. * * @author Erich Schubert + * @since 0.3 */ public class ClipScaling implements StaticScalingFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/GammaScaling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/GammaScaling.java index 36fc8eed..7efc5318 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/GammaScaling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/GammaScaling.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * * @author Erich Schubert * @author Remigius Wojdanowski + * @since 0.3 */ public class GammaScaling implements StaticScalingFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/IdentityScaling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/IdentityScaling.java index c66a2c7d..46832321 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/IdentityScaling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/IdentityScaling.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.utilities.scaling; * The trivial "identity" scaling function. * * @author Erich Schubert + * @since 0.3 */ public class IdentityScaling implements StaticScalingFunction { @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/LinearScaling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/LinearScaling.java index de0b5c02..4a65a49a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/LinearScaling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/LinearScaling.java @@ -29,6 +29,7 @@ import de.lmu.ifi.dbs.elki.math.DoubleMinMax; * Simple linear scaling function. * * @author Erich Schubert + * @since 0.3 */ public class LinearScaling implements StaticScalingFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/MinusLogScaling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/MinusLogScaling.java index 2c79d8bf..0c8262b0 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/MinusLogScaling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/MinusLogScaling.java @@ -28,6 +28,7 @@ package de.lmu.ifi.dbs.elki.utilities.scaling; * Scaling function to invert values by computing -1 * Math.log(x) * * @author Erich Schubert + * @since 0.3 */ public class MinusLogScaling implements StaticScalingFunction { @Override diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/ScalingFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/ScalingFunction.java index fce71ffc..9928dcc1 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/ScalingFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/ScalingFunction.java @@ -36,6 +36,7 @@ package de.lmu.ifi.dbs.elki.utilities.scaling; * {@code prepare} statement. * * @author Erich Schubert + * @since 0.3 */ public interface ScalingFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/StaticScalingFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/StaticScalingFunction.java index 72f8c6a7..34c44b88 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/StaticScalingFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/StaticScalingFunction.java @@ -29,6 +29,7 @@ package de.lmu.ifi.dbs.elki.utilities.scaling; * But will always map x to the same f(x) (given the same parameters). * * @author Erich Schubert + * @since 0.3 * */ public interface StaticScalingFunction extends ScalingFunction { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/COPOutlierScaling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/COPOutlierScaling.java index 122e93b2..ea4dc752 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/COPOutlierScaling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/COPOutlierScaling.java @@ -58,6 +58,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * </p> * * @author Erich Schubert + * @since 0.6.0 */ @Reference(authors = "H.-P. Kriegel, P. Kröger, E. Schubert, A. Zimek", title = "Interpreting and Unifying Outlier Scores", booktitle = "Proc. 11th SIAM International Conference on Data Mining (SDM), Mesa, AZ, 2011", url = "http://siam.omnibooksonline.com/2011datamining/data/papers/018.pdf") public class COPOutlierScaling implements OutlierScalingFunction { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/HeDESNormalizationOutlierScaling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/HeDESNormalizationOutlierScaling.java index 2e778500..be9012a8 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/HeDESNormalizationOutlierScaling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/HeDESNormalizationOutlierScaling.java @@ -35,6 +35,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * Normalization used by HeDES * * @author Erich Schubert + * @since 0.4.0 */ @Reference(authors = "H. V. Nguyen, H. H. Ang, V. Gopalkrishnan", title = "Mining Outliers with Ensemble of Heterogeneous Detectors on Random Subspaces", booktitle = "Proc. 15th International Conference on Database Systems for Advanced Applications (DASFAA 2010)", url = "http://dx.doi.org/10.1007/978-3-642-12026-8_29") public class HeDESNormalizationOutlierScaling implements OutlierScalingFunction { diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/LogRankingPseudoOutlierScaling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/LogRankingPseudoOutlierScaling.java index a2533119..ab63eabd 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/LogRankingPseudoOutlierScaling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/LogRankingPseudoOutlierScaling.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * a normal distribution. * * @author Erich Schubert + * @since 0.4.0 */ public class LogRankingPseudoOutlierScaling implements OutlierScalingFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/MinusLogGammaScaling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/MinusLogGammaScaling.java index 00c2a9f0..002ff917 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/MinusLogGammaScaling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/MinusLogGammaScaling.java @@ -44,6 +44,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.AbstractParameterizer; * </p> * * @author Erich Schubert + * @since 0.3 */ @Reference(authors = "H.-P. Kriegel, P. Kröger, E. Schubert, A. Zimek", // title = "Interpreting and Unifying Outlier Scores", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/MinusLogStandardDeviationScaling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/MinusLogStandardDeviationScaling.java index 2c01b2a1..b6645231 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/MinusLogStandardDeviationScaling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/MinusLogStandardDeviationScaling.java @@ -49,6 +49,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.3 */ @Reference(authors = "H.-P. Kriegel, P. Kröger, E. Schubert, A. Zimek", // title = "Interpreting and Unifying Outlier Scores", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/MixtureModelOutlierScalingFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/MixtureModelOutlierScalingFunction.java index 0271f3f3..dd915b7a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/MixtureModelOutlierScalingFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/MixtureModelOutlierScalingFunction.java @@ -49,6 +49,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.4.0 */ @Reference(authors = "J. Gao, P.-N. Tan", // title = "Converting Output Scores from Outlier Detection Algorithms into Probability Estimates", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/MultiplicativeInverseScaling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/MultiplicativeInverseScaling.java index adaf0659..c566d373 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/MultiplicativeInverseScaling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/MultiplicativeInverseScaling.java @@ -47,6 +47,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.3 */ @Reference(authors = "H.-P. Kriegel, P. Kröger, E. Schubert, A. Zimek", // title = "Interpreting and Unifying Outlier Scores", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierGammaScaling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierGammaScaling.java index 0ac8f6fe..732a54f3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierGammaScaling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierGammaScaling.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Flag; * </p> * * @author Erich Schubert + * @since 0.3 */ @Reference(authors = "H.-P. Kriegel, P. Kröger, E. Schubert, A. Zimek", // title = "Interpreting and Unifying Outlier Scores", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierLinearScaling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierLinearScaling.java index d7feb2b4..34480521 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierLinearScaling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierLinearScaling.java @@ -47,6 +47,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.Parameter; * maximum values. * * @author Erich Schubert + * @since 0.3 */ public class OutlierLinearScaling implements OutlierScalingFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierMinusLogScaling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierMinusLogScaling.java index 4ccbe77d..c3f7697e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierMinusLogScaling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierMinusLogScaling.java @@ -46,6 +46,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.3 */ @Reference(authors = "H.-P. Kriegel, P. Kröger, E. Schubert, A. Zimek", // title = "Interpreting and Unifying Outlier Scores", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierScalingFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierScalingFunction.java index 6e05d7c6..e6ae2491 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierScalingFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierScalingFunction.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.scaling.ScalingFunction; * scaling function. * * @author Erich Schubert + * @since 0.3 */ public interface OutlierScalingFunction extends ScalingFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierSqrtScaling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierSqrtScaling.java index 8da3bd35..4339e2aa 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierSqrtScaling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/OutlierSqrtScaling.java @@ -41,6 +41,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * mapping onto 0:1 using the minimum values seen. * * @author Erich Schubert + * @since 0.3 */ public class OutlierSqrtScaling implements OutlierScalingFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/RankingPseudoOutlierScaling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/RankingPseudoOutlierScaling.java index 75a532f7..0b12b0c7 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/RankingPseudoOutlierScaling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/RankingPseudoOutlierScaling.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.AbortException; * a normal distribution. * * @author Erich Schubert + * @since 0.4.0 */ public class RankingPseudoOutlierScaling implements OutlierScalingFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/SigmoidOutlierScalingFunction.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/SigmoidOutlierScalingFunction.java index 748fddd4..6855d879 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/SigmoidOutlierScalingFunction.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/SigmoidOutlierScalingFunction.java @@ -48,6 +48,7 @@ import de.lmu.ifi.dbs.elki.utilities.documentation.Reference; * </p> * * @author Erich Schubert + * @since 0.4.0 */ @Reference(authors = "J. Gao, P.-N. Tan", // title = "Converting Output Scores from Outlier Detection Algorithms into Probability Estimates", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/SqrtStandardDeviationScaling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/SqrtStandardDeviationScaling.java index 1387d69f..0fe9e86a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/SqrtStandardDeviationScaling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/SqrtStandardDeviationScaling.java @@ -57,6 +57,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * </p> * * @author Erich Schubert + * @since 0.3 */ @Reference(authors = "H.-P. Kriegel, P. Kröger, E. Schubert, A. Zimek", // title = "Interpreting and Unifying Outlier Scores", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/StandardDeviationScaling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/StandardDeviationScaling.java index b6ef5e3a..524c93f6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/StandardDeviationScaling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/StandardDeviationScaling.java @@ -54,6 +54,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.DoubleParameter; * </p> * * @author Erich Schubert + * @since 0.3 */ @Reference(authors = "H.-P. Kriegel, P. Kröger, E. Schubert, A. Zimek", // title = "Interpreting and Unifying Outlier Scores", // diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/TopKOutlierScaling.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/TopKOutlierScaling.java index 7ac19a1b..1f867e4a 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/TopKOutlierScaling.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/scaling/outlier/TopKOutlierScaling.java @@ -40,6 +40,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.IntParameter; * Outlier scaling function that only keeps the top k outliers. * * @author Erich Schubert + * @since 0.3 */ public class TopKOutlierScaling implements OutlierScalingFunction { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/xml/DOMCloner.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/xml/DOMCloner.java index 85f81561..6fecd67c 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/xml/DOMCloner.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/xml/DOMCloner.java @@ -33,6 +33,7 @@ import org.w3c.dom.Node; * Class for cloning XML document, with filter capabilites * * @author Erich Schubert + * @since 0.5.0 */ public class DOMCloner { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/xml/HTMLUtil.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/xml/HTMLUtil.java index 4522df6f..376f00cb 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/xml/HTMLUtil.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/xml/HTMLUtil.java @@ -40,6 +40,7 @@ import org.w3c.dom.Element; * Class with HTML related utility functions, in particular HTML generation. * * @author Erich Schubert + * @since 0.2 */ public final class HTMLUtil { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/xml/XMLNodeIterator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/xml/XMLNodeIterator.java index 10b14c8b..af272678 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/xml/XMLNodeIterator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/xml/XMLNodeIterator.java @@ -33,6 +33,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.ExceptionMessages; * Simple adapter class to iterate over a DOM tree nodes children. * * @author Erich Schubert + * @since 0.2 */ public final class XMLNodeIterator implements Iterator<Node> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/xml/XMLNodeListIterator.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/xml/XMLNodeListIterator.java index 7566ccb4..f1ada456 100755 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/xml/XMLNodeListIterator.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/utilities/xml/XMLNodeListIterator.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.exceptions.ExceptionMessages; * Simple adapter class to iterate over a DOM tree nodes children. * * @author Erich Schubert + * @since 0.2 */ public final class XMLNodeListIterator implements Iterator<Node> { /** diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/AlgorithmStep.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/AlgorithmStep.java index d3b8cc48..223ee5b3 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/AlgorithmStep.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/AlgorithmStep.java @@ -45,6 +45,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectListParamet * The "algorithms" step, where data is analyzed. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has Algorithm * @apiviz.has Result diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/EvaluationStep.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/EvaluationStep.java index 99f57fd1..fab93f05 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/EvaluationStep.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/EvaluationStep.java @@ -42,6 +42,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectListParamet * The "evaluation" step, where data is analyzed. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has Evaluator * @apiviz.uses Result diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/InputStep.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/InputStep.java index b7de345b..6680e2a6 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/InputStep.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/InputStep.java @@ -34,6 +34,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectParameter; * Data input step of the workflow. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.has Database */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/LoggingStep.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/LoggingStep.java index 167f8c8b..8641b69b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/LoggingStep.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/LoggingStep.java @@ -38,6 +38,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.StringParameter; * Pseudo-step to configure logging / verbose mode. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses LoggingConfiguration */ diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/OutputStep.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/OutputStep.java index 9d58129a..3448bf1b 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/OutputStep.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/OutputStep.java @@ -39,6 +39,7 @@ import de.lmu.ifi.dbs.elki.utilities.optionhandling.parameters.ObjectListParamet * The "output" step, where data is analyzed. * * @author Erich Schubert + * @since 0.4.0 * * @apiviz.uses ResultHierarchy * @apiviz.has ResultHandler @@ -90,7 +91,7 @@ public class OutputStep implements WorkflowStep { Class<? extends ResultHandler> clz; try { clz = (Class<? extends ResultHandler>) ClassLoader.getSystemClassLoader().loadClass(// - "de.lmu.ifi.dbs.elki.visualization.gui.ResultVisualizer"); + "de.lmu.ifi.dbs.elki.result.AutomaticVisualization"); } catch(ClassNotFoundException e) { clz = ResultWriter.class; diff --git a/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/WorkflowStep.java b/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/WorkflowStep.java index b001d8e3..9e305c4e 100644 --- a/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/WorkflowStep.java +++ b/elki/src/main/java/de/lmu/ifi/dbs/elki/workflow/WorkflowStep.java @@ -29,6 +29,7 @@ package de.lmu.ifi.dbs.elki.workflow; * A logical grouping of classes with no real functionality. * * @author Erich Schubert + * @since 0.4.0 */ public interface WorkflowStep { // Empty |