Class 
Description 
ABIDEstimator 
Angle based intrinsic dimensionality (ABID) estimator.

ABIDEstimator.Par 
Parameterization class.

ABOD<V extends NumberVector> 
AngleBased Outlier Detection / AngleBased Outlier Factor.

ABOD.Par<V extends NumberVector> 
Parameterization class.

AbortException 
Exception for aborting some process and transporting a message.

AbsolutePearsonCorrelationDistance 
Absolute Pearson correlation distance function for feature vectors.

AbsolutePearsonCorrelationDistance.Par 
Parameterization class.

AbsoluteUncenteredCorrelationDistance 
Absolute uncentered correlation distance function for feature vectors.

AbsoluteUncenteredCorrelationDistance.Par 
Parameterization class.

AbstractAggarwalYuOutlier 
Abstract base class for the sparsegridcell based outlier detection of
Aggarwal and Yu.

AbstractAggarwalYuOutlier.Par 
Parameterization class.

AbstractApplication 
AbstractApplication sets the values for flags verbose and help.

AbstractApplication.Par 
Parameterization class.

AbstractBiclustering<M extends BiclusterModel> 
Abstract class as a convenience for different biclustering approaches.

AbstractBulkSplit 
Encapsulates the required parameters for a bulk split of a spatial index.

AbstractCFKMeansInitialization 
Abstract base class for CF kmeans initializations.

AbstractCFKMeansInitialization.Par 
Parameterization class.

AbstractClassifier<O,R> 
Abstract base class for algorithms.

AbstractConversionFilter<I,O> 
Abstract base class for simple conversion filters such as normalizations and projections.

AbstractCoverTree<O> 
Abstract base class for cover tree variants.

AbstractCoverTree.Factory<O> 
Index factory.

AbstractCoverTree.Factory.Par<O> 
Parameterization class.

AbstractCutDendrogram 
Abstract base class for extracting clusters from dendrograms.

AbstractCutDendrogram.Par 
Parameterization class.

AbstractDatabase 
Abstract base class for database API implementations.

AbstractDatabase.Par 
Parameterization class.

AbstractDatabaseConnection 
Abstract super class for all database connections.

AbstractDatabaseConnection.Par 
Parameterization class.

AbstractDatabaseDistance<O> 
Abstract super class for distance functions needing a database context.

AbstractDatabaseDistance.Instance<O> 
The actual instance bound to a particular database.

AbstractDBIDRangeDistance 
Abstract base class for distance functions that rely on integer offsets
within a consecutive range.

AbstractDBIDSimilarity 
Abstract super class for distance functions needing a preprocessor.

AbstractDBOutlier<O> 
Simple distance based outlier detection algorithms.

AbstractDBOutlier.Par<O> 
Parameterization class.

AbstractDimensionsSelectingDistance<V extends FeatureVector<?>> 
Abstract base class for distances computed only in subspaces.

AbstractDimensionsSelectingDistance.Par 
Parameterization class.

AbstractDiscreteUncertainifier<UO extends UncertainObject> 
Factory class for discrete uncertain objects.

AbstractDiscreteUncertainifier.Par 
Parameterizer.

AbstractDistanceBasedApplication<O> 
Abstract base class for distancebased tasks and experiments.

AbstractDistanceBasedSpatialOutlier<N,O> 
Abstract base class for distancebased spatial outlier detection methods.

AbstractDoubleProcessor 
Abstract base class for processors that output double values.

AbstractDoubleProcessor.Instance 
Instance.

AbstractEarthModel 
Abstract base class for earth models with shared glue code.

AbstractEditDistance 
Edit Distance for FeatureVectors.

AbstractEditDistance.Par 
Parameterization class.

AbstractExternalizablePage 
Abstract superclass for pages.

AbstractFrequentItemsetAlgorithm 
Abstract base class for frequent itemset mining.

AbstractFrequentItemsetAlgorithm.Par 
Parameterization class.

AbstractFullProjection 
Abstract base class for full projections.

AbstractHDBSCAN<O> 
Abstract base class for HDBSCAN variations.

AbstractHDBSCAN.HDBSCANAdapter 
Class for processing the HDBSCAN G_mpts graph.

AbstractHDBSCAN.HeapMSTCollector 
Class for collecting the minimum spanning tree edges into a heap.

AbstractHistogramVisualization 
Onedimensional projected visualization.

AbstractHoldout 
Split a data set for holdout evaluation.

AbstractIndexBasedDistance<O,F extends IndexFactory<O>> 
Abstract super class for distance functions needing a database index.

AbstractIndexBasedDistance.Instance<O,I extends Index,F extends Distance<? super O>> 
The actual instance bound to a particular database.

AbstractIndexBasedSimilarity<O,F extends IndexFactory<O>> 
Abstract super class for distance functions needing a preprocessor.

AbstractIndexBasedSimilarity.Instance<O,I extends Index> 
The actual instance bound to a particular database.

AbstractIndexBasedSimilarity.Par<F extends IndexFactory<?>> 
Parameterization class.

AbstractIntegerDBIDFactory 
Abstract base class for DBID factories.

AbstractKMeans<V extends NumberVector,M extends Model> 
Abstract base class for kmeans implementations.

AbstractKMeans.Instance 
Inner instance for a run, for better encapsulation, that encapsulates the
standard flow of most (but not all) kmeans variations.

AbstractKMeans.Par<V extends NumberVector> 
Parameterization class.

AbstractKMeansInitialization 
Abstract base class for common kmeans initializations.

AbstractKMeansInitialization.Par 
Parameterization class.

AbstractKMeansQualityMeasure<O extends NumberVector> 
Base class for evaluating clusterings by information criteria (such as AIC or
BIC).

AbstractLayout3DPC<N extends Layout.Node> 
Abstract class for dimension similarity based layouters.

AbstractLayout3DPC.AbstractNode<N extends AbstractLayout3DPC.AbstractNode<N>> 
Abstract node implementation.

AbstractLayout3DPC.LowerTriangularAdapter 
Class to use a lowertriangular similarity matrix for distancebased Prim's
spanning tree.

AbstractLayout3DPC.Par 
Parameterization class.

AbstractMaterializeKNNPreprocessor<O> 
Abstract base class for KNN Preprocessors.

AbstractMaterializeKNNPreprocessor.Factory<O> 
The parameterizable factory.

AbstractMkTree<O,N extends AbstractMTreeNode<O,N,E>,E extends MTreeEntry,S extends MTreeSettings<O,N,E>> 
Abstract class for all MTree variants supporting processing of reverse
knearest neighbor queries by using the knn distances of the entries, where
k is less than or equal to the given parameter.

AbstractMkTreeUnified<O,N extends AbstractMTreeNode<O,N,E>,E extends MTreeEntry,S extends MkTreeSettings<O,N,E>> 
Abstract class for all MTree variants supporting processing of reverse
knearest neighbor queries by using the knn distances of the entries, where
k is less than or equal to the given parameter.

AbstractMkTreeUnifiedFactory<O,N extends AbstractMTreeNode<O,N,E>,E extends MTreeEntry,S extends MkTreeSettings<O,N,E>> 
Abstract factory for various MkTrees

AbstractMkTreeUnifiedFactory.Par<O,N extends AbstractMTreeNode<O,N,E>,E extends MTreeEntry,S extends MkTreeSettings<O,N,E>> 
Parameterization class.

AbstractMTree<O,N extends AbstractMTreeNode<O,N,E>,E extends MTreeEntry,S extends MTreeSettings<O,N,E>> 
Abstract super class for all MTree variants.

AbstractMTreeFactory<O,N extends AbstractMTreeNode<O,N,E>,E extends MTreeEntry,S extends MTreeSettings<O,N,E>> 
Abstract factory for various MTrees

AbstractMTreeFactory.Par<O,N extends AbstractMTreeNode<O,N,E>,E extends MTreeEntry,S extends MTreeSettings<O,N,E>> 
Parameterization class.

AbstractMTreeNode<O,N extends AbstractMTreeNode<O,N,E>,E extends MTreeEntry> 
Abstract super class for nodes in MTree variants.

AbstractMTreeSplit<E extends MTreeEntry,N extends AbstractMTreeNode<?,N,E>> 
Abstract super class for splitting a node in an MTree.

AbstractNeighborhoodOutlier<O> 
Abstract base class for spatial outlier detection methods using a spatial
neighborhood.

AbstractNode<E> 
Abstract superclass for nodes in an tree based index structure.

AbstractNumberConstraint 
Abstract super class for constraints dealing with a certain number value.

AbstractNumberVectorDistance 
Abstract base class for the most common family of distance functions: defined
on number vectors and returning double values.

AbstractObjDynamicHistogram<T> 
A dynamic histogram can dynamically adapt the number of bins to the data fed
into the histogram.

AbstractOPTICS<O> 
The OPTICS algorithm for densitybased hierarchical clustering.

AbstractOPTICSVisualization 
Abstract base class for OPTICS visualizer

AbstractPageFile<P extends Page> 
Abstract base class for the page file API for both caches and true page files
(inmemory and ondisk).

AbstractPageFileFactory<P extends Page> 
Abstract page file factory.

AbstractParallelVisualization<NV> 
Abstract base class for parallel visualizations.

AbstractParameter<P extends AbstractParameter<P,T>,T> 
Abstract class for specifying a parameter.

AbstractParameterConfigurator<T extends Parameter<?>> 
Abstract class to produce a configurator for a particular parameter.

AbstractParameterization 
Abstract class with shared code for parameterization handling.

AbstractPartialReinsert 
Abstract base class for reinsertion strategies that have a "relative amount"
parameter to partially reinsert entries.

AbstractPartialReinsert.Par 
Parameterization class.

AbstractPrecomputedNeighborhood 
Abstract base class for precomputed neighborhoods.

AbstractPrecomputedNeighborhood.Factory<O> 
Factory class.

AbstractProgress 
Abstract base class for FiniteProgress objects.

AbstractProjectedClustering<R extends Clustering<?>> 
Abstract superclass for projected clustering algorithms, like PROCLUS
and ORCLUS .

AbstractProjectedClustering.Par 
Parameterization class.

AbstractProjectedHashFunctionFamily 
Abstract base class for projection based hash functions.

AbstractProjectedHashFunctionFamily.Par 
Parameterization class.

AbstractProjection 
Abstract base projection class.

AbstractProjectionAlgorithm<R> 
Abstract base class for projection algorithms.

AbstractRandomProjectionFamily 
Abstract base class for random projection families.

AbstractRandomProjectionFamily.MatrixProjection 
Class to project using a matrix multiplication.

AbstractRandomProjectionFamily.Par 
Parameterization interface (with the shared parameters)

AbstractRangeQueryNeighborPredicate<O,M,N> 
Abstract local model neighborhood predicate.

AbstractRangeQueryNeighborPredicate.Instance<N,M> 
Instance for a particular data set.

AbstractRefiningIndex<O> 
Abstract base class for Filterrefinement indexes.

AbstractRStarTree<N extends AbstractRStarTreeNode<N,E>,E extends SpatialEntry,S extends RTreeSettings> 
Abstract superclass for index structures based on a R*Tree.

AbstractRStarTreeFactory<O extends NumberVector,N extends AbstractRStarTreeNode<N,E>,E extends SpatialEntry,S extends RTreeSettings> 
Abstract factory for R*Tree based trees.

AbstractRStarTreeNode<N extends AbstractRStarTreeNode<N,E>,E extends SpatialEntry> 
Abstract superclass for nodes in a R*Tree.

AbstractScatterplotVisualization 
Default class to handle 2D projected visualizations.

AbstractSetDistance<O> 
Abstract base class for set distance functions.

AbstractSilhouetteVisualization 
Abstract base class for silhouette visualizer

AbstractSimilarityAdapter<O> 
Adapter from a similarity function to a distance function.

AbstractSimilarityAdapter.Instance<O> 
Inner proxy class for SNN distance function.

AbstractSimilarityAdapter.Par<O,S extends Similarity<? super O>> 
Parameterization class.

AbstractSimpleOverlay 
Renderer for simple overlays.

AbstractSimpleProjection 
Abstract base class for "simple" projections.

AbstractSingleParameterConfigurator<T extends Parameter<?>> 
Base class for MiniGUI input helpers

AbstractSingleSVM 

AbstractStaticHistogram 
Abstract base class for histograms.

AbstractStatistic 
Abstract base class for statistics tracking.

AbstractStoringPageFile<P extends Page> 
Abstract class implementing general methods of a PageFile.

AbstractStreamConversionFilter<I,O> 
Abstract base class for simple conversion filters such as normalizations and
projections.

AbstractStreamFilter 
Abstract base class for streaming filters.

AbstractStreamingParser 
Base class for streaming parsers.

AbstractStreamingParser.Par 
Parameterization class.

AbstractSupervisedProjectionVectorFilter<V extends NumberVector> 
Base class for supervised projection methods.

AbstractSVC 

AbstractSVR 

AbstractTooltipVisualization 
General base class for a tooltip visualizer.

AbstractUncertainObject 
Abstract base implementation for UncertainObject s, providing shared
functionality such as bounding box access and random generation.

AbstractVectorConversionFilter<I,O extends NumberVector> 
Abstract class for filters that produce number vectors.

AbstractVectorIter 
Class to iterate over a number vector in decreasing order.

AbstractVectorSimilarity 
Abstract base class for doublevalued primitive similarity functions.

AbstractVectorStreamConversionFilter<I,O extends NumberVector> 
Abstract base class for streaming filters that produce vectors.

AbstractVisualization 
Abstract base class for visualizations.

AchlioptasRandomProjectionFamily 
Random projections as suggested by Dimitris Achlioptas.

AchlioptasRandomProjectionFamily.Par 
Parameterization class.

AdaptiveSortTileRecursiveBulkSplit 
This is variation of the original STR bulk load for nonrectangular data
spaces.

AdaptiveSortTileRecursiveBulkSplit.Par 
Parameterization class.

AddCSSClass 
Add a CSS class to the event target.

AddedValue 
Added value (AV) interestingness measure:
\( \text{confidence}(X \rightarrow Y)  \text{support}(Y) = P(YX)P(Y) \).

AddSingleScale 
Pseudo "algorithm" that computes the global min/max for a relation across all
attributes.

AddSingleScale.Par 
Parameterization class.

AddUniformScale 
Pseudo "algorithm" that computes the global min/max for a relation across all
attributes.

AffineProjection 
Affine projections are the most general class.

AffineTransformation 
Affine transformations implemented using homogeneous coordinates.

AffinityMatrix 
Abstraction interface for an affinity matrix.

AffinityMatrixBuilder<O> 
Interface for computing an affinity matrix.

AffinityPropagation<O> 
Cluster analysis by affinity propagation.

AffinityPropagationInitialization<O> 
Initialization methods for affinity propagation.

AFKMC2 
AFKMCÂ² initialization

AFKMC2.Instance 
Abstract instance implementing the weight handling.

AFKMC2.Par 
Parameterization class.

AggarwalYuEvolutionary 
Evolutionary variant (EAFOD) of the highdimensional outlier detection
algorithm by Aggarwal and Yu.

AggarwalYuEvolutionary.Individuum 
Individuum for the evolutionary search.

AggarwalYuEvolutionary.Par 
Parameterization class.

AggarwalYuNaive 
BruteForce variant of the highdimensional outlier detection algorithm by
Aggarwal and Yu.

AggarwalYuNaive.Par 
Parameterization class.

AggregatedHillEstimator 
Estimator using the weighted average of multiple hill estimators.

AggregatedHillEstimator.Par 
Parameterization class.

AGNES<O> 
Hierarchical Agglomerative Clustering (HAC) or Agglomerative Nesting (AGNES)
is a classic hierarchical clustering algorithm.

AGNES.Instance 
Main worker instance of AGNES.

AkaikeInformationCriterion 
Akaike Information Criterion (AIC).

AkaikeInformationCriterionXMeans 
Akaike Information Criterion (AIC).

Algorithm 
Specifies the requirements for any algorithm that is to be executable by the
main class.

Algorithm.Utils 
Shared functionality

AlgorithmStep 
The "algorithms" step, where data is analyzed.

AlgorithmStep.Par 
Parameterization class.

AlgorithmTabPanel 
Panel to handle data processing

Alias 
This interface defines alias names for classes.

ALIDEstimator 
ALID estimator of the intrinsic dimensionality (maximum likelihood estimator
for ID using auxiliary distances).

ALIDEstimator.Par 
Parameterization class.

ALOCI<V extends NumberVector> 
Fast Outlier Detection Using the "approximate Local Correlation Integral".

ALOCI.ALOCIQuadTree 
Simple quadtree for ALOCI.

ALOCI.Node 
Node of the ALOCI Quadtree

ALOCI.Par<O extends NumberVector> 
Parameterization class.

AlphaShape 
Compute the alphashape of a point set, using Delaunay triangulation.

AlternateRefinement<O> 
MetaInitialization for kmedoids by performing one (or many) kmeansstyle
iteration.

AlternateRefinement.Par<O> 
Parameterization class.

AlternatingKMedoids<O> 
A kmedoids clustering algorithm, implemented as EMstyle batch algorithm;
known in literature as the "alternate" method.

AlternatingKMedoids.Par<V> 
Parameterization class.

AlternativeTypeInformation 
Class that combines multiple type restrictions into one using the "or"
operator.

Anderberg<O> 
This is a modification of the classic AGNES algorithm for hierarchical
clustering using a nearestneighbor heuristic for acceleration.

Anderberg.Instance 
Main worker instance of Anderberg's algorithm.

AndersonDarlingTest 
Perform AndersonDarling test for a Gaussian distribution.

AngTanLinearSplit 
Linetime complexity split proposed by Ang and Tan.

AngTanLinearSplit.Par 
Parameterization class.

AnnulusKMeans<V extends NumberVector> 
Annulus kmeans algorithm.

AnnulusKMeans.Instance 
Inner instance, storing state for a single data set.

AnnulusKMeans.Par<V extends NumberVector> 
Parameterization class.

APIViolationException 
This class indicates an exception likely caused by an API not implemented
correctly.

ApproximationLine 
Provides an approximation for knndistances line consisting of incline m,
axes intercept t and a start value for k.

ApproximativeLeastOverlapInsertionStrategy 
The choose subtree method proposed by the R*Tree with slightly better
performance for large leaf sizes (linear approximation).

ApproximativeLeastOverlapInsertionStrategy.Par 
Parameterization class.

APRIORI 
The APRIORI algorithm for Mining Association Rules.

APRIORI.Par 
Parameterization class.

Arcball1DOFAdapter 
Arcball style helper.

ArcCosineDistance 
Arcus cosine distance function for feature vectors.

ArcCosineDistance.Par 
Parameterization class.

ArcCosineUnitlengthDistance 
Arcus cosine distance function for feature vectors.

ArcCosineUnitlengthDistance.Par 
Parameterization class.

ArccosSimilarityAdapter<O> 
Adapter from a normalized similarity function to a distance function using
arccos(sim) .

ArccosSimilarityAdapter.Instance<O> 
Distance function instance

ArccosSimilarityAdapter.Par<O> 
Parameterization class.

ArffParser 
Parser to load WEKA .arff files into ELKI.

ArffParser.Par 
Parameterization class.

ArrayAdapter<T,A> 
Adapter for arraylike things.

ArrayAdapterDatabaseConnection 
Import an existing data matrix (double[rows][cols] ) into an ELKI
database.

ArrayDBIDs 
Interface for array based DBIDs.

ArrayDBIDStore 
A class to answer representation queries using the stored Array.

ArrayDoubleStore 
A class to answer representation queries using the stored Array.

ArrayIntegerStore 
A class to answer representation queries using the stored Array.

ArrayIter 
Array iterators can also go backwards and seek.

ArrayLikeUtil 
Utility class that allows plugin use of various "arraylike" types such as
lists in APIs that can take any kind of array to safe the cost of
reorganizing the objects into a real array.

ArrayListIter<O> 
ELKI style Iterator for array lists.

ArrayModifiableDBIDs 
Arrayoriented implementation of a modifiable DBID collection.

ArrayModifiableIntegerDBIDs 
Class using a primitive int[] array as storage.

ArrayRecordStore 
A class to answer representation queries using the stored Array.

ArrayStaticDBIDs 
Unmodifiable, indexed DBIDs.

ArrayStaticIntegerDBIDs 
Static (no modifications allowed) set of Database Object IDs.

ArrayStore<T> 
A class to answer representation queries using the stored Array.

ArrayUtil 
Utility functions for manipulating arrays.

AsciiDistanceParser 
Parser for parsing one distance value per line.

AsciiDistanceParser.Par 
Parameterization class.

AsClusterFeature 
Get the clustering feature representation.

Assignment 
Point assignment.

Assignments<E extends MTreeEntry> 
Encapsulates the attributes of an assignment during a split.

AssociationRule 
Association Rule

AssociationRuleGeneration 
Association rule generation from frequent itemsets

AssociationRuleGeneration.ItemsetSearcher 
Class to find itemsets in a sorted list.

AssociationRuleGeneration.Par 
Parameterization class.

AssociationRuleGeneration.PartialItemset 
Mutable scatch itemset for finding itemsets, based on
SparseItemset .

AssociationRuleResult 
Result class for association rule mining

AtomicLongCounter 
Class to count events in a threadsafe counter.

AttributeModifier 
Runnable wrapper for modifying XMLAttributes.

AttributeWiseBetaNormalization<V extends NumberVector> 
Project the data using a Beta distribution.

AttributeWiseBetaNormalization.Par<V extends NumberVector> 
Parameterization class.

AttributeWiseCDFNormalization<V extends NumberVector> 
Class to perform and undo a normalization on real vectors by estimating the
distribution of values along each dimension independently, then rescaling
objects to the cumulative density function (CDF) value at the original
coordinate.

AttributeWiseCDFNormalization.Par<V extends NumberVector> 
Parameterization class.

AttributeWiseMADNormalization<V extends NumberVector> 
Median Absolute Deviation is used for scaling the data set as follows:

AttributeWiseMeanNormalization<V extends NumberVector> 
Normalization designed for data with a meaningful zero:
The 0 is retained, and the data is linearly scaled to have a mean of 1,
by projection with f(x) = x / mean(X).

AttributeWiseMinMaxNormalization<V extends NumberVector> 
Class to perform and undo a normalization on real vectors with respect to
a given minimum and maximum in each dimension.

AttributeWiseMinMaxNormalization.Par<V extends NumberVector> 
Parameterization class.

AttributeWiseVarianceNormalization<V extends NumberVector> 
Class to perform and undo a normalization on real vectors with respect to
given mean and standard deviation in each dimension.

AttributeWiseVarianceNormalization.Par<V extends NumberVector> 
Parameterization class.

AUPRCEvaluation 
Compute the area under the precisionrecall curve (AUPRC).

AUPRCEvaluation.Par 
Parameterization class.

AUPRCEvaluation.PRCurve 
ROC Curve

AutomaticEvaluation 
Evaluator that tries to autorun a number of evaluation methods.

AutomaticEvaluation.Par 
Parameterization class

AutomaticVisualization 
Handler to process and visualize a Result.

AutomaticVisualization.Par 
Parameterization class.

AutotuningPCA 
Performs a selftuning local PCA based on the covariance matrices of given
objects.

AutotuningPCA.Cand 
Candidate

AutotuningPCA.Par 
Parameterization class.

AverageInterclusterDistance 
Average intercluster distance.

AverageInterclusterDistance 
Average intercluster distance.

AverageInterclusterDistance.Par 
Parameterization class.

AverageInterclusterDistance.Par 
Parameterization class.

AverageIntraclusterDistance 
Average intracluster distance.

AverageIntraclusterDistance 
Average intracluster distance.

AverageIntraclusterDistance.Par 
Parameterization class.

AverageIntraclusterDistance.Par 
Parameterization class.

AveragePrecisionAtK<O> 
Evaluate a distance functions performance by computing the average precision
at k, when ranking the objects by distance.

AveragePrecisionEvaluation 
Evaluate using average precision.

AveragePrecisionEvaluation.Par 
Parameterization class.

AxisBasedReferencePoints 
Strategy to pick reference points by placing them on the axis ends.

AxisBasedReferencePoints.Par 
Parameterization class.

AxisReorderVisualization 
Interactive SVGElements for reordering the axes.

AxisVisibilityVisualization 
Layer for controlling axis visbility in parallel coordinates.

AxisVisualization 
Generates a SVGElement containing axes, including labeling.

AxisVisualization.Instance 
Instance.

BalancedDistribution 
Balanced entry distribution strategy of the Mtree.

BarnesHutTSNE<O> 
tSNE using BarnesHutApproximation.

BarnesHutTSNE.QuadTree 
Quad Tree for use in a BarnesHut approximation.

BasicOutlierScoreMeta 
Basic outlier score.

BatikUtil 
Batik helper class with static methods.

BayesianInformationCriterion 
Bayesian Information Criterion (BIC), also known as Schwarz criterion (SBC,
SBIC) for the use with evaluating kmeans results.

BayesianInformationCriterionXMeans 
Bayesian Information Criterion (BIC), also known as Schwarz criterion (SBC,
SBIC) for the use with evaluating kmeans results.

BayesianInformationCriterionZhao 
Different version of the BIC criterion.

BCubed 
BCubed measures for cluster evaluation.

BestFitEstimator 
A meta estimator that will try a number of (inexpensive) estimations, then
choose whichever works best.

BestFitEstimator.Par 
Parameterization class.

BestOfMultipleKMeans<V extends NumberVector,M extends MeanModel> 
Run KMeans multiple times, and keep the best run.

BetaDistribution 
Beta Distribution with implementation of the regularized incomplete beta
function

BetaDistribution.Par 
Parameterization class

BetulaClusterModel 
Models usable in Betula EM clustering.

BetulaClusterModelFactory<M extends BetulaClusterModel> 
Factory for initializing the EM models.

BetulaDiagonalGaussianModelFactory 
Factory for EM with multivariate gaussian models using diagonal matrixes.

BetulaDiagonalGaussianModelFactory.Par 
Parameterization class

BetulaGMM 
Clustering by expectation maximization (EMAlgorithm), also known as Gaussian
Mixture Modeling (GMM), with optional MAP regularization.

BetulaGMM.Par 
Parameterizer

BetulaGMMWeighted 
Clustering by expectation maximization (EMAlgorithm), also known as Gaussian
Mixture Modeling (GMM), with optional MAP regularization.

BetulaGMMWeighted.Par 
Parameterizer

BetulaLeafPreClustering 
BETULAbased clustering algorithm that simply treats the leafs of the CFTree
as clusters.

BetulaLeafPreClustering.Par 
Parameterization class.

BetulaLloydKMeans 
BIRCH/BETULAbased clustering algorithm that simply treats the leafs of the
CFTree as clusters.

BetulaLloydKMeans.Par 
Parameterization class.

BetulaMultivariateGaussianModelFactory 
Factory for EM with multivariate gaussian models using diagonal matrixes.

BetulaMultivariateGaussianModelFactory.Par 
Parameterization class

BetulaSphericalGaussianModelFactory 
Factory for EM with multivariate gaussian models using a single variance.

BetulaSphericalGaussianModelFactory.Par 
Parameterization class

BiclusterModel 
Wrapper class to provide the basic properties of a Bicluster.

BiclusterWithInversionsModel 
This code was factored out of the Bicluster class, since not all biclusters
have inverted rows.

BinarySplitSpatialSorter 
Spatially sort the data set by repetitive binary splitting, circulating
through the dimensions.

BinarySplitSpatialSorter.Par 
Parameterization class.

BinarySplitSpatialSorter.Sorter 
Comparator for sorting spatial objects by the mean value in a single
dimension.

BIRCHAbsorptionCriterion 
BIRCH absorption criterion.

BIRCHAverageInterclusterDistance 
Average intercluster distance.

BIRCHAverageInterclusterDistance.Par 
Parameterization class.

BIRCHAverageIntraclusterDistance 
Average intracluster distance.

BIRCHAverageIntraclusterDistance.Par 
Parameterization class.

BIRCHCF 
Clustering Feature of BIRCH, only for comparison

BIRCHCF.Factory 
Factory for making cluster features.

BIRCHCF.Factory.Par 
Parameterization class.

BIRCHDistance 
Distance function for BIRCH clustering.

BIRCHKMeansPlusPlus 
KMeans++like initialization for BIRCH kmeans; this cannot be used to
initialize regular kmeans, use KMeansPlusPlus instead.

BIRCHKMeansPlusPlus.Par 
Parameterization class.

BIRCHLeafClustering 
BIRCHbased clustering algorithm that simply treats the leafs of the CFTree
as clusters.

BIRCHLeafClustering.Par 
Parameterization class.

BIRCHLloydKMeans 
BIRCHbased clustering algorithm that simply treats the leafs of the CFTree
as clusters.

BIRCHLloydKMeans.Par 
Parameterization class.

BIRCHRadiusDistance 
Average Radius (R) criterion.

BIRCHRadiusDistance.Par 
Parameterization class

BIRCHVarianceIncreaseDistance 
Variance increase distance.

BIRCHVarianceIncreaseDistance.Par 
Parameterization class.

BisectingKMeans<V extends NumberVector,M extends MeanModel> 
The bisecting kmeans algorithm works by starting with an initial
partitioning into two clusters, then repeated splitting of the largest
cluster to get additional clusters.

Bit 
A boolean number type.

BitsUtil 
Utilities for bit operations.

BitVector 
Vector using a dense bit set encoding, based on long[] storage.

BitVector.Factory 
Factory for bit vectors.

BitVector.Factory.Par 
Parameterization class.

BitVector.ShortSerializer 
Serialization class for dense integer vectors with up to
Short.MAX_VALUE dimensions, by using a short for storing the
dimensionality.

BitVectorLabelParser 
Parser for parsing one BitVector per line, bits separated by whitespace.

BitVectorLabelParser.Par 
Parameterization class.

BiweightKernelDensityFunction 
Biweight (Quartic) kernel density estimator.

BiweightKernelDensityFunction.Par 
Parameterization stub.

Border 
Border point assignment.

BoundedMidpointSplit 
Bounded midpoint splitting.

BoundedMidpointSplit.Par 
Parameterizer

BoundingBoxVisualization 
Draw spatial objects (except vectors!)

BrayCurtisDistance 
BrayCurtis distance function / SÃ¸rensenâ€“Dice coefficient for continuous
vector spaces (not only binary data).

BrayCurtisDistance.Par 
Parameterization class.

BreadthFirstEnumeration<N extends Node<E>,E> 
Breadth first enumeration over the nodes of an index structure.

BubbleVisualization 
Generates a SVGElement containing bubbles.

BubbleVisualization.Par 
Parameterization class.

BufferedLineReader 
Class for buffered IO, avoiding some of the overheads of the Java API.

BUILD<O> 
PAM initialization for kmeans (and of course, for PAM).

BUILD.Par<V> 
Parameterization class.

BulkSplit 
Interface for a bulk split strategy.

BundleDatabaseConnection 
Class to load a database from a bundle file.

BundleDatabaseConnection.Par 
Parameterization class.

BundleMeta 
Store the package metadata in an array list.

BundleReader 
Read an ELKI bundle file into a data stream.

BundleStreamSource 
Soruce for a bundle stream

BundleStreamSource.Event 
Events

BundleWriter 
Write an object bundle stream to a file channel.

ByLabelClustering 
Pseudo clustering using labels.

ByLabelClustering.Par 
Parameterization class.

ByLabelFilter 
A filter to select data set by their label.

ByLabelFilter.Par 
Parameterization class.

ByLabelHierarchicalClustering 
Pseudo clustering using labels.

ByLabelOrAllInOneClustering 
Trivial class that will try to cluster by label, and fall back to an
"allinone" clustering.

ByLabelOutlier 
Trivial algorithm that marks outliers by their label.

ByLabelOutlier.Par 
Parameterization class.

ByModelClustering 
Pseudo clustering using annotated models.

ByModelClustering.Par 
Parameterization class.

ByteArrayUtil 
Class with various utilities for manipulating byte arrays.

ByteArrayUtil.ByteSerializer 
Serializer for byte objects.

ByteArrayUtil.DoubleSerializer 
Serializer for double objects.

ByteArrayUtil.FloatSerializer 
Serializer for float objects.

ByteArrayUtil.IntegerSerializer 
Serializer for integer objects.

ByteArrayUtil.LongSerializer 
Serializer for long objects.

ByteArrayUtil.ShortSerializer 
Serializer for short objects.

ByteArrayUtil.StringSerializer 
Serializer for String objects.

ByteArrayUtil.VarintSerializer 
Serializer for Integer objects using a variable size encoding.

ByteBufferInputStream 
Wrap an existing ByteBuffer as InputStream.

ByteBufferOutputStream 
Wrap an existing ByteBuffer as OutputStream.

ByteBufferSerializer<T> 
Class to convert from and to byte arrays (in index structures).

ByteVector 
Vector using byte[] storage.

ByteVector.Factory 
Factory for Byte vectors.

ByteVector.Factory.Par 
Parameterization class.

ByteVector.ShortSerializer 
Serialization class for dense Byte vectors with up to
Short.MAX_VALUE dimensions, by using a short for storing the
dimensionality.

ByteVector.SmallSerializer 
Serialization class for dense Byte vectors with up to 127 dimensions, by
using a byte for storing the dimensionality.

ByteWeightedArrayDataSet 
This is an efficient array based data set implementation.

CachedDoubleDistanceKNNPreprocessor<O> 
Preprocessor that loads an existing cached kNN result.

CachedDoubleDistanceKNNPreprocessor.Factory<O> 
The parameterizable factory.

CachedDoubleDistanceKNNPreprocessor.Factory.Par<O> 
Parameterization class.

CacheDoubleDistanceInOnDiskMatrix<O> 
Precompute an ondisk distance matrix, using double precision.

CacheDoubleDistanceInOnDiskMatrix.Par<O> 
Parameterization class.

CacheDoubleDistanceKNNLists<O> 
Precompute the k nearest neighbors in a disk cache.

CacheDoubleDistanceKNNLists.Par<O> 
Parameterization class.

CacheDoubleDistanceRangeQueries<O> 
Precompute the k nearest neighbors in a disk cache.

CacheDoubleDistanceRangeQueries.Par<O> 
Parameterization class.

CachedQMatrix 
This is the original cache from the libSVN implementation.

CacheFloatDistanceInOnDiskMatrix<O> 
Precompute an ondisk distance matrix, using float precision.

CacheFloatDistanceInOnDiskMatrix.Par<O> 
Parameterization class.

CanberraDistance 
Canberra distance function, a variation of Manhattan distance.

CanberraDistance.Par 
Parameterization class.

CanopyPreClustering<O> 
Canopy preclustering is a simple preprocessing step for clustering.

CanvasSize 
Size of a canvas.

CASH 
The CASH algorithm is a subspace clustering algorithm based on the Hough
transform.

CASH.Par 
Parameterization class.

CASHInterval 
Provides a unique interval represented by its id, a hyper bounding box
representing the alpha intervals, an interval of the corresponding distance,
and a set of objects ids associated with this interval.

CASHIntervalSplit 
Supports the splitting of CASH intervals.

CategorialDataAsNumberVectorParser<V extends NumberVector> 
A very simple parser for categorial data, which will then be encoded as
numbers.

CategorialDataAsNumberVectorParser.Par<V extends NumberVector> 
Parameterization class.

CauchyDistribution 
Cauchy distribution.

CauchyDistribution.Par 
Parameterization class

CauchyMADEstimator 
Estimate Cauchy distribution parameters using Median and MAD.

CauchyMADEstimator.Par 
Parameterization class.

CauchyRandomProjectionFamily 
Random projections using Cauchy distributions (1stable).

CauchyRandomProjectionFamily.Par 
Parameterization class.

CBLOF<O extends NumberVector> 
Clusterbased local outlier factor (CBLOF).

CenterOfMassMetaClustering<C extends Clustering<?>> 
Centerofmass meta clustering reduces uncertain objects to their center of
mass, then runs a vectororiented clustering algorithm on this data set.

CenterOfMassMetaClustering.Par<C extends Clustering<?>> 
Parameterization class.

Centroid 
Class to compute the centroid of some data.

CentroidEuclideanDistance 
Centroid Euclidean distance.

CentroidEuclideanDistance 
Centroid Euclidean distance.

CentroidEuclideanDistance.Par 
Parameterization class.

CentroidEuclideanDistance.Par 
Parameterization class.

CentroidLinkage 
Centroid linkage — Unweighted PairGroup Method using Centroids
(UPGMC).

CentroidLinkage.Par 
Class parameterizer.

CentroidManhattanDistance 
Centroid Manhattan Distance

CentroidManhattanDistance 
Centroid Manhattan Distance

CentroidManhattanDistance.Par 
Parameterization class.

CentroidManhattanDistance.Par 
Parameterization class.

CertaintyFactor 
Certainty factor (CF; Loevinger) interestingness measure.
\( \tfrac{\text{confidence}(X \rightarrow Y) 
\text{support}(Y)}{\text{support}(\neg Y)} \).

CFDistance 
Distance function for BIRCH clustering.

CFDistanceMatrix 
Cluster feature distance matrix, used for clustering.

CFInitWeight 
Initialization weight function for kmeans initialization with BETULA.

CFKPlusPlusLeaves 
KMeans++like initialization for BETULA kmeans, treating the leaf
clustering features as a flat list, and called "leaves" in the publication.

CFKPlusPlusLeaves.Par 
Parameterization class.

CFKPlusPlusTree 
Initialize Kmeans by following tree paths weighted by their variance
contribution.

CFKPlusPlusTree.Par 
Parameterization class.

CFKPlusPlusTrunk 
Trunk strategy for initializing kmeans with BETULA: only the nodes up to a
particular level are considered for kmeans++ style initialization.

CFKPlusPlusTrunk.Par 
Parameterization class.

CFNode<L extends ClusterFeature> 
Interface for TreeNode

CFRandomlyChosen 
Initialize Kmeans by randomly choosing k existing elements as initial
cluster centers for Clustering Features.

CFRandomlyChosen.Par 
Parameterization class.

CFSFDP<O> 
Clustering by fast search and find of density peaks (CFSFDP) is a
densitybased clustering method similar to meanshift clustering.

CFSFDP<O> 
Tutorial code for Clustering by fast search and find of density peaks.

CFSFDP.Par<O> 
Parameterizer

CFSFDP.Par<O> 
Class parameterizer.

CFTree 
Partial implementation of the CFTree as used by BIRCH.

CFTree<L extends ClusterFeature> 
Partial implementation of the CFTree as used by BIRCH and BETULA.

CFTree.Factory 
CFTree Factory.

CFTree.Factory<L extends ClusterFeature> 
CFTree Factory.

CFTree.Factory.Par 
Parameterization class for CFTrees.

CFTree.Factory.Par<L extends ClusterFeature> 
Parameterization class for CFTrees.

CFTree.LeafIterator 
Iterator over leaf nodes.

CFTree.LeafIterator<L extends ClusterFeature> 
Iterator over leaf nodes.

CFTree.Threshold 
Threshold update strategy.

CFWeightedRandomlyChosen 
Initialize Kmeans by randomly choosing k existing elements as initial
cluster centers for Clustering Features.

CFWeightedRandomlyChosen.Par 
Parameterization class.

ChainedParameterization 
Class that allows chaining multiple parameterizations.

ChangePoint 
Single Change Point

ChangePoints 
Change point detection result Used by change or trend detection algorithms
TODO: we need access to the data labels / timestamp information!

CheckELKIServices 
Helper application to test the ELKI service properties files for missing
implementation entries, for listing available implementations in the UIs.

CheckParameterizables 
Perform some consistency checks on classes that cannot be specified as Java
interface.

CheckParameterizables.State 
Current verification state.

ChengAndChurch 
Cheng and Church biclustering.

ChengAndChurch.BiclusterCandidate 
Bicluster candidate.

ChengAndChurch.CellVisitor 
Visitor pattern for processing cells.

ChiDistance 
Ï‡ distance function, symmetric version.

ChiDistance.Par 
Parameterization class, using the static instance.

ChiDistribution 
Chi distribution.

ChiDistribution.Par 
Parameterization class

ChiSquaredDistance 
Ï‡Â² distance function, symmetric version.

ChiSquaredDistance.Par 
Parameterization class, using the static instance.

ChiSquaredDistribution 
ChiSquared distribution (a specialization of the Gamma distribution).

ChiSquaredDistribution.Par 
Parameterization class

CholeskyDecomposition 
Cholesky Decomposition.

CIndex<O> 
Compute the Cindex of a data set.

CIndex.Par<O> 
Parameterization class.

CircleMarkers 
Simple marker library that just draws colored circles at the given
coordinates.

CircleSegmentsVisualizer 
Visualizer to draw circle segments of clusterings and enable interactive
selection of segments.

CircleSegmentsVisualizer.Instance 
Instance

CKMeans 
Run kmeans on the centers of each uncertain object.

CKMeans.Par 
Parameterization class, based on kmeans.

CLARA<V> 
Clustering Large Applications (CLARA) is a clustering method for large data
sets based on PAM, partitioning around medoids ( PAM ) based on
sampling.

CLARA.CachedDistanceQuery<V> 
Cached distance query.

CLARA.Par<V> 
Parameterization class.

CLARANS<O> 
CLARANS: a method for clustering objects for spatial data mining
is inspired by PAM (partitioning around medoids, PAM )
and CLARA and also based on sampling.

CLARANS.Assignment 
Assignment state.

CLARANS.Par<V> 
Parameterization class.

ClarkDistance 
Clark distance function for vector spaces.

ClarkDistance.Par 
Parameterization class.

Clarke1858SpheroidEarthModel 
The Clarke 1858 spheroid earth model.

Clarke1858SpheroidEarthModel.Par 
Parameterization class.

Clarke1880SpheroidEarthModel 
The Clarke 1880 spheroid earth model.

Clarke1880SpheroidEarthModel.Par 
Parameterization class.

ClassGenericsUtil 
Utilities for handling class instantiation, especially with respect to Java
generics.

ClassicMultidimensionalScalingTransform<I,O extends NumberVector> 
Rescale the data set using multidimensional scaling, MDS.

ClassificationModel 

Classifier<O> 
A Classifier is to hold a model that is built based on a database, and to
classify a new instance of the same type.

ClassifierHoldoutEvaluationTask<O> 
Evaluate a classifier.

ClassifierHoldoutEvaluationTask.Par<O> 
Parameterization class.

ClassInstantiationException 
Error thrown when a class cannot be instantiated.

ClassLabel 
A ClassLabel to identify a certain class of objects that is to discern from
other classes by a classifier.

ClassLabel.Factory<L extends ClassLabel> 
Class label factory.

ClassLabelFilter 
Class that turns a label column into a class label column.

ClassLabelFilter.Par 
Parameterization class.

ClassLabelFromPatternFilter 
Streaming filter to derive an outlier class label.

ClassLabelFromPatternFilter.Par 
Parameterization class.

ClassListParameter<C> 
Parameter class for a parameter specifying a list of class names.

ClassListParameterConfigurator 
Provide a configuration panel to choose classes with the help of a dropdown.

ClassParameter<C> 
Parameter class for a parameter specifying a class name.

ClassParameterConfigurator 
Provide a configuration panel to choose a class with the help of a dropdown.

ClassStylingPolicy 
Styling policy that is based on classes, for example clusters or
labels.

ClassTree 
Build a tree of available classes for use in Swing UIs.

ClassTree.ClassNode 
Tree node representing a single class.

ClassTree.PackageNode 
Tree node representing a single class.

CLINK<O> 
CLINK algorithm for complete linkage.

CLINK.Par<O> 
Parameterization class.

ClipScaling 
Scale implementing a simple clipping.

ClipScaling.Par 
Parameterization class.

CLIQUE 
Implementation of the CLIQUE algorithm, a gridbased algorithm to identify
dense clusters in subspaces of maximum dimensionality.

CLIQUE.Par 
Parameterization class.

CLIQUESubspace 
Represents a subspace of the original data space in the CLIQUE algorithm.

CLIQUEUnit 
Represents a unit in the CLIQUE algorithm.

CLISmartHandler 
Handler that handles output to the console with clever formatting.

CloneInlineImages 
Clone an SVG document, inlining temporary and inmemory linked images.

CloseReinsert 
Reinsert objects on page overflow, starting with close objects first (even
when they will likely be inserted into the same page again!)

CloseReinsert.Par 
Parameterization class.

Cluster<M extends Model> 
Generic cluster class, that may or not have hierarchical information.

ClusterAlphaHullVisualization 
Visualizer generating the alpha shape of each cluster.

ClusterAlphaHullVisualization.Par 
Parameterization class.

ClusterContingencyTable 
Class storing the contingency table and related data on two clusterings.

ClusterConvexHullVisualization 
Visualizer of the convex hull of each cluster.

ClusterConvexHullVisualization.Instance 
Instance.

ClusterConvexHullVisualization.Par 
Parameterization class.

ClusterDensityMergeHistory 
Hierarchical clustering merge list, with additional coredists information.

ClusterDistanceMatrix 
Shared code for algorithms that work on a pairwise cluster distance matrix.

ClusterFeature 
Interface for basic ClusteringFeature functions

ClusterFeature.Factory<F extends ClusterFeature> 
Cluster feature factory

Clustering<M extends Model> 
Result class for clusterings.

ClusteringAdjustedRandIndexSimilarity 
Measure the similarity of clusters via the Adjusted Rand Index.

ClusteringAdjustedRandIndexSimilarity.Par 
Parameterization class.

ClusteringAlgorithm<C extends Clustering<? extends Model>> 
Interface for Algorithms that are capable to provide a Clustering as Result. in general, clustering algorithms are supposed to
implement the Algorithm Interface.

ClusteringAlgorithmUtil 
Utility functionality for writing clustering algorithms.

ClusteringBCubedF1Similarity 
Measure the similarity of clusters via the BCubed F1 Index.

ClusteringBCubedF1Similarity.Par 
Parameterization class.

ClusteringDistanceSimilarity 
Distance and similarity measure for clusterings.

ClusteringFeature 
Clustering Feature of BIRCH

ClusteringFowlkesMallowsSimilarity 
Measure the similarity of clusters via the FowlkesMallows Index.

ClusteringFowlkesMallowsSimilarity.Par 
Parameterization class.

ClusteringRandIndexSimilarity 
Measure the similarity of clusters via the Rand Index.

ClusteringRandIndexSimilarity.Par 
Parameterization class.

ClusteringVectorDumper 
Output a clustering result in a simple and compact ascii format:
whitespace separated cluster indexes

ClusteringVectorDumper.Par 
Parameterization class.

ClusteringVectorParser 

ClusteringVectorParser.Par 
Parameterization class.

ClusterIntersectionSimilarity 
Measure the similarity of clusters via the intersection size.

ClusterIntersectionSimilarity.Par 
Parameterization class.

ClusterJaccardSimilarity 
Measure the similarity of clusters via the Jaccard coefficient.

ClusterJaccardSimilarity.Par 
Parameterization class.

ClusterMeanVisualization 
Visualize the mean of a KMeansClustering

ClusterMeanVisualization.Instance 
Instance.

ClusterMergeHistory 
Merge history representing a hierarchical clustering.

ClusterMergeHistoryBuilder 
Class to help building a pointer hierarchy.

ClusterModel 
Generic cluster model.

ClusterOrder 
Class to store the result of an ordering clustering algorithm such as OPTICS.

ClusterOrderVisualization 
Cluster order visualizer: connect objects via the spanning tree the cluster
order represents.

ClusterOrderVisualization.Instance 
Instance

ClusterOutlineVisualization 
Generates a SVGElement that visualizes the area covered by a cluster.

ClusterOutlineVisualization.Par 
Parameterization class.

ClusterPairSegmentAnalysis 
Evaluate clustering results by building segments for their pairs: shared
pairs and differences.

ClusterParallelMeanVisualization 
Generates a SVGElement that visualizes cluster means.

ClusterPrototypeMergeHistory 
Cluster merge history with additional cluster prototypes (for HACAM,
MedoidLinkage, and MiniMax clustering)

ClusterRadius 
Evaluate a clustering by the (weighted) cluster radius.

ClusterRadius.Par 
Parameterization class.

ClusterStarVisualization 
Visualize the mean of a KMeansClustering using stars.

ClusterStarVisualization.Instance 
Instance.

ClusterStyleAction 
Actions to use clusterings for styling.

ClusterStyleAction.SetStyleAction 

ClusterStylingPolicy 
Styling policy based on cluster membership.

ClusterStylingPolicy.IntensityTransform 
Intensity transformation functions

ClustersWithNoiseExtraction 
Extraction of a given number of clusters with a minimum size, and noise.

ClustersWithNoiseExtraction.Par 
Parameterization class.

COF<O> 
Connectivitybased Outlier Factor (COF).

CollectionResult<O> 
Simple 'collection' type of result.

ColoredHistogramVisualizer 
Generates a SVGElement containing a histogram representing the distribution
of the database's objects.

ColoredHistogramVisualizer.Par 
Parameterization class.

ColorInterpolation 
Color interpolation

ColorLibrary 
Color scheme interface

CombinedInsertionStrategy 
Use two different insertion strategies for directory and leaf nodes.

CombinedInsertionStrategy.Par 
Parameterization class.

CombinedIntGenerator 
Combine multiple ranges.

CombinedTypeInformation 
Class that combines multiple type restrictions into one using an "and" operator.

CommonConstraints 
Class storing a number of very common constraints.

CompactCircularMSTLayout3DPC 
Simple circular layout based on the minimum spanning tree.

CompactCircularMSTLayout3DPC.Node 
Node class for this layout.

CompactCircularMSTLayout3DPC.Par 
Parameteriation class.

ComparableMaxHeap<K extends java.lang.Comparable<? super K>> 
Binary heap for primitive types.

ComparableMinHeap<K extends java.lang.Comparable<? super K>> 
Binary heap for primitive types.

ComparatorMaxHeap<K> 
Binary heap for primitive types.

ComparatorMinHeap<K> 
Binary heap for primitive types.

CompareMeans<V extends NumberVector> 
CompareMeans: Accelerated kmeans by exploiting the triangle inequality and
pairwise distances of means to prune candidate means.

CompareMeans.Instance 
Inner instance, storing state for a single data set.

CompareMeans.Par<V extends NumberVector> 
Parameterization class.

CompleteLinkage 
Completelinkage ("maximum linkage") clustering method.

CompleteLinkage.Par 
Class parameterizer.

ComputeKNNOutlierScores<O extends NumberVector> 
Application that runs a series of kNNbased algorithms on a data set, for
building an ensemble in a second step.

ComputeKNNOutlierScores.Par<O extends NumberVector> 
Parameterization class.

ComputeKNNOutlierScores.TimeoutException 
Exception used in timeout logic.

ComputeOutlierHistogram 
Compute a Histogram to evaluate a ranking algorithm.

ComputeOutlierHistogram.Par 
Parameterization class.

ComputeSimilarityMatrixImage<O> 
Compute a similarity matrix for a distance function.

ComputeSimilarityMatrixImage.Par<O> 
Parameterization class.

ComputeSimilarityMatrixImage.SimilarityMatrix 
Similarity matrix image.

ConcatenateFilesDatabaseConnection 
Database that will loading multiple files, concatenating the results.

ConcatenateFilesDatabaseConnection.Par 
Parameterization class.

ConcatIt<O> 
Concatenate multiple iterators.

ConcordantPairsGammaTau 
Compute the Gamma Criterion of a data set.

ConcordantPairsGammaTau.Par 
Parameterization class.

Confidence 
Confidence interestingness measure,
\( \tfrac{\text{support}(X \cup Y)}{\text{support}(X)}
= \tfrac{P(X \cap Y)}{P(X)}=P(YX) \).

ConfiguratorPanel 
A panel that contains configurators for parameters.

ConfusionMatrix 
Provides a confusion matrix with some prediction performance measures that
can be derived from a confusion matrix.

ConfusionMatrixEvaluationResult 
Provides the prediction performance measures for a classifier based on the
confusion matrix.

ConstantDistribution 
Pseudo distribution, that has a unique constant value.

ConstantDistribution.Par 
Parameterization class

ConstantWeight 
Constant weight function.

ConstrainedQuadraticProblemSolver 
Solve a constrained quadratic equation in the form
\( \tfrac12 x^T A x + b^T x + c \)
constrained by a bounding box.

ConstrainedQuadraticProblemSolver.DimensionState 
Describes the calculation state of a Dimension

ConstrainedQuadraticProblemSolver.ProblemData 
Contains arrays for a specific size needed for the problem calculation
using this object saves the creation of all those arrays, because we can
just reuse them.

ConvertToBundleApplication 
Convert an input file to the more efficient ELKI bundle format.

ConvertToBundleApplication.Par 
Parameterization class.

ConvertToStringView 
Representation adapter that uses toString() to produce a string
representation.

ConvexHull 
Holds the lower and upper hull for some values.

Conviction 
Conviction interestingness measure:
\(\frac{P(X) P(\neg Y)}{P(X\cap\neg Y)}\).

COP<V extends NumberVector> 
Correlation outlier probability: Outlier Detection in Arbitrarily Oriented
Subspaces

COP.DistanceDist 
Score type.

COP.Par<V extends NumberVector> 
Parameterization class.

COPAC 
COPAC is an algorithm to partition a database according to the correlation
dimension of its objects and to then perform an arbitrary clustering
algorithm over the partitions.

COPAC.Par 
Parameterization class.

COPAC.Settings 
Class to wrap the COPAC settings.

COPACNeighborPredicate 
COPAC neighborhood predicate.

COPACNeighborPredicate.COPACModel 
Model used by COPAC for core point property.

COPACNeighborPredicate.Instance 
Instance for a particular data set.

COPACNeighborPredicate.Par 
Parameterization class.

COPOutlierScaling 
CDF based outlier score scaling.

COPOutlierScaling.Par 
Parameterization class.

COPVectorVisualization 
Visualize error vectors as produced by COP.

COPVectorVisualization.Instance 
Visualize error vectors as produced by COP.

Core 
Core point assignment.

CoreObjectsModel 
Cluster model using "core" objects.

CorePredicate<T> 
Predicate for GeneralizedDBSCAN to evaluate whether a point is a core point
or not.

CorePredicate.Instance<T> 
Instance for a particular data set.

CorrelationAnalysisSolution 
A solution of correlation analysis is a matrix of equations describing the
dependencies.

CorrelationClusterOrder 
Cluster order entry for correlationbased OPTICS variants.

CorrelationModel 
Cluster model using a filtered PCA result and an centroid.

Cosine 
Cosine interestingness measure,
\(\tfrac{\text{support}(A\cup B)}{\sqrt{\text{support}(A)\text{support}(B)}}
=\tfrac{P(A\cap B)}{\sqrt{P(A)P(B)}}\).

CosineDistance 
Cosine distance function for feature vectors.

CosineDistance.Par 
Parameterization class.

CosineHashFunctionFamily 
Hash function family to use with Cosine distance, using simplified hash
functions where the projection is only drawn from +1, instead of Gaussian
distributions.

CosineHashFunctionFamily.Par 
Parameterization class.

CosineKernelDensityFunction 
Cosine kernel density estimator.

CosineKernelDensityFunction.Par 
Parameterization stub.

CosineLocalitySensitiveHashFunction 
Random projection family to use with sparse vectors.

CosineUnitlengthDistance 
Cosine distance function for unit length feature vectors.

CosineUnitlengthDistance.Par 
Parameterization class.

Counter 
Simple statistic by counting.

CovarianceMatrix 
Class for computing covariance matrixes using stable mean and variance
computations.

CovarianceMatrixBuilder 
Interface for computing covariance matrixes on a data set.

CoverTree<O> 
Cover tree data structure (inmemory).

CoverTree.Factory<O> 
Index factory.

CoverTree.Factory.Par<O> 
Parameterization class.

CoverTree.Node 
Node object.

CSSClass 
Class representing a single CSS class.

CSSClass.InvalidCSS 
Exception class thrown when encountering invalid CSS.

CSSClassManager 
Manager class to track CSS classes used in a particular SVG document.

CSSClassManager.CSSNamingConflict 
Class to signal a CSS naming conflict.

CSSHoverClass 
Do a hover effect using a CSS class.

CSVC 
Regularized SVM based classification (CSVC, CSVM).

CSVReaderFormat 
Basic format factory for parsing CSVlike formats.

CSVReaderFormat.Par 
Parameterization class.

CTLuGLSBackwardSearchAlgorithm<V extends NumberVector> 
GLSBackward Search is a statistical approach to detecting spatial outliers.

CTLuMeanMultipleAttributes<N,O extends NumberVector> 
Mean Approach is used to discover spatial outliers with multiple attributes.

CTLuMedianAlgorithm<N> 
Median Algorithm of C.

CTLuMedianMultipleAttributes<N,O extends NumberVector> 
Median Approach is used to discover spatial outliers with multiple
attributes.

CTLuMoranScatterplotOutlier<N> 
Moran scatterplot outliers, based on the standardized deviation from the
local and global means.

CTLuRandomWalkEC<O> 
Spatial outlier detection based on random walks.

CTLuScatterplotOutlier<N> 
Scatterplotoutlier is a spatial outlier detection method that performs a
linear regression of object attributes and their neighbors average value.

CTLuZTestOutlier<N> 
Detect outliers by comparing their attribute value to the mean and standard
deviation of their neighborhood.

CutDendrogramByHeight 
Extract a flat clustering from a full hierarchy, represented in pointer form.

CutDendrogramByHeight.Par 
Parameterization class.

CutDendrogramByHeightExtractor 
Extract clusters from a hierarchical clustering, during the evaluation phase.

CutDendrogramByHeightExtractor.Par 
Parameterization class.

CutDendrogramByNumberOfClusters 
Extract a flat clustering from a full hierarchy, represented in pointer form.

CutDendrogramByNumberOfClusters.Par 
Parameterization class.

CutDendrogramByNumberOfClustersExtractor 
Extract clusters from a hierarchical clustering, during the evaluation phase.

CutDendrogramByNumberOfClustersExtractor.Par 
Parameterization class.

DAFile 
Dimension approximation file, a onedimensional part of the
PartialVAFile .

DashedLineStyleLibrary 
Line library using various dashed and dotted line styles.

Database 
Database specifies the requirements for any database implementation.

DatabaseConnection 
DatabaseConnection is used to load data into a database.

DatabaseDistanceQuery<O> 
Run a database query in a database context.

DatabaseEventManager 
Class to manage database events such as insertions and removals.

DatabaseEventManager.Type 
Types for aggregation.

DatabaseSimilarityQuery<O> 
Run a database query in a database context.

DatabaseUtil 
Class with Databaserelated utility functions such as centroid computation,
covariances etc.

DataSet 
API to plug in custom data representations into libSVM.

DataStore<T> 
Generic storage interface for objects indexed by DBID .

DataStoreEvent 
Encapsulates information describing changes, i.e. updates, insertions, and /
or deletions in a DataStore , and used to notify all subscribed
DataStoreListener of the change.

DataStoreFactory 
API for a storage factory used for producing larger storage maps.

DataStoreIDMap 
Interface to map DBIDs to integer record ids for use in storage.

DataStoreListener 
Defines the interface for an object that listens to changes in a
DataStore .

DataStoreUtil 
Storage utility class.

DataStoreUtil.AscendingByDoubleDataStore 
Sort objects by a double relation

DataStoreUtil.AscendingByDoubleDataStoreAndId 
Sort objects by a double relation

DataStoreUtil.AscendingByIntegerDataStore 
Sort objects by a integer relation

DataStoreUtil.DescendingByDoubleDataStore 
Sort objects by a double relation

DataStoreUtil.DescendingByDoubleDataStoreAndId 
Sort objects by a double relation

DataStoreUtil.DescendingByIntegerDataStore 
Sort objects by a integer relation

DaviesBouldinIndex 
Compute the DaviesBouldin index of a data set.

DaviesBouldinIndex.Par 
Parameterization class.

DBCV<O> 
Compute the DensityBased Clustering Validation Index.

DBCV.Par<O> 
Parameterization class.

DBID 
Database ID object.

DBIDArrayIter 
Array iterators that can also go backwards and seek.

DBIDArrayMIter 
Modifiable array iterator.

DBIDDataStore 
DBIDvalued data store (avoids boxing/unboxing).

DBIDDistance 
Distance functions valid in a database context only (i.e. for DBIDs)

DBIDDistanceQuery 
Run a distance query based on DBIDs

DBIDFactory 
Factory interface for generating DBIDs.

DBIDIter 
Iterator for DBIDs.

DBIDMIter 
Modifiable DBID iterator.

DBIDPair 
Immutable pair of two DBIDs, more memory efficient than two DBIDs.

DBIDRange 
Static DBID range.

DBIDRangeDatabaseConnection 
This is a fake datasource that produces a static DBID range only.

DBIDRangeDatabaseConnection.Par 
Parameterization class.

DBIDRangeDistance 
Distance functions valid in a static database context only
(i.e. for DBIDRanges)
For any "distance" that cannot be computed for arbitrary objects, only those
that exist in the database and referenced by their ID.

DBIDRangeDistanceQuery 
Run a distance query based on DBIDRanges

DBIDRef 
Some object referencing a DBID .

DBIDs 
Interface for a collection of database references (IDs).

DBIDSelection 
Class representing selected DatabaseIDs and/or a selection range.

DBIDSimilarity 
Interface DBIDSimilarity describes the requirements of any similarity
function defined over object IDs.

DBIDUtil 
DBID Utility functions.

DBIDVar 
(Persistent) variable storing a DBID reference.

DBIDView 
Pseudorepresentation that is the object ID itself.

DBOutlierDetection<O> 
Simple distanced based outlier detection algorithm.

DBOutlierDetection.Par<O> 
Parameterization class.

DBOutlierScore<O> 
Compute percentage of neighbors in the given neighborhood with size d.

DBOutlierScore.Par<O> 
Parameterization class.

DBSCAN<O> 
DensityBased Clustering of Applications with Noise (DBSCAN), an algorithm to
find densityconnected sets in a database.

DBSCAN.Par<O> 
Parameterization class.

DBSCANOutlierDetection 
Outlier detection algorithm using DBSCAN Clustering.

DBSCANOutlierDetection.Par 
Parameterizer.

DCGEvaluation 
Discounted Cumulative Gain.

DCGEvaluation.Par 
Parameterization class.

DCor 
Distance correlation.

DCor.Par 
Parameterization class

DecreasingVectorIter 
Class to iterate over a number vector in decreasing order.

DefaultPageHeader 
Default implementation of a page header.

DeLiClu<V extends NumberVector> 
DeliClu: DensityBased Hierarchical Clustering

DeLiClu.Par<V extends NumberVector> 
Parameterization class.

DeLiClu.SpatialObjectPair 
Encapsulates an entry in the cluster order.

DeLiCluDirectoryEntry 
Defines the requirements for a directory entry in an DeLiCluTree node.

DeLiCluEntry 
Defines the requirements for an entry in an DeLiCluTree node.

DeLiCluLeafEntry 
Defines the requirements for a leaf entry in an DeLiCluTree node.

DeLiCluNode 
Represents a node in a DeLiCluTree.

DeLiCluTree 
DeLiCluTree is a spatial index structure based on an RTree.

DeLiCluTreeFactory<O extends NumberVector> 
Factory for DeLiClu R*Trees.

DeLiCluTreeFactory.Par<O extends NumberVector> 
Parameterization class.

DeLiCluTreeIndex<O extends NumberVector> 
The common use of the DeLiClu tree: indexing number vectors.

DendrogramModel 
Model for dendrograms, provides the height of this subtree.

DendrogramVisualization 
Dendrogram visualizer.

DendrogramVisualization.DrawingStyle 
Drawing styles for dendrograms.

DendrogramVisualization.HalfPosPositions 
Compact position storage.

DendrogramVisualization.HalfWidthPositions 
Compact position storage.

DendrogramVisualization.Par 
Parameterization class.

DendrogramVisualization.Positions 
Compact position storage.

DendrogramVisualization.PositionStyle 
Positioning style

DenseAffinityMatrix 
Dense affinity matrix storage.

DenseItemset 
APRIORI itemset, dense representation.

DensityEstimationOverlay 
A simple density estimation visualization, based on a simple kerneldensity
in the projection, not the actual data!

DensityEstimationOverlay.Instance 
Instance for a particular data set.

Dependence 
Measure the dependence of two variables.

Dependence.Utils 
Utility functions that were previously in the abstract class.

DependencyDerivator<V extends NumberVector> 
Dependency derivator computes quantitatively linear dependencies among
attributes of a given dataset based on a linear correlation PCA.

DependencyDerivator.Par<V extends NumberVector> 
Parameterization class.

DerivativeDTWDistance 
Derivative Dynamic Time Warping distance for numerical vectors.

Description 
Class/algorithm description

DetailView 
Manages a detail view.

DetailViewSelectedEvent 
Event when a particular subplot was selected.

DiagonalGaussianModel 
Simpler model for a single Gaussian cluster, without covariances.

DiagonalGaussianModelFactory 
Factory for EM with multivariate gaussian models using diagonal matrixes.

DiameterCriterion 
Average Radius (R) criterion.

DiameterCriterion.Par 
Parameterization class

DimensionModel 
Cluster model additionally providing a cluster dimensionality.

DimensionSelectingLatLngDistance 
Distance function for 2D vectors in Latitude, Longitude form.

DimensionSelectingLatLngDistance.Par 
Parameterization class.

DimensionSelectingSubspaceDistance<O> 
Interface for dimension selecting subspace distance functions.

DirectoryEntry 
Directory entry of an index.

DisableQueryOptimizer 
Dummy implementation to disable automatic optimization.

DisableQueryOptimizer.Par 
Parameterization class.

DiscardResultHandler 
A dummy result handler that discards the actual result, for use in
benchmarks.

DiscreteUncertainObject 
Interface for discrete uncertain objects, that are represented by a finite
(possibly weighted) number of samples.

DiSH 
Algorithm for detecting subspace hierarchies.

DiSH.DiSHClusterOrder 
DiSH cluster order.

DiSH.Par 
Parameterization class.

DiSH.Strategy 
Available strategies for determination of the preference vector.

DisjointCrossValidation 
DisjointCrossValidation provides a set of partitions of a database to
perform crossvalidation.

DisjointCrossValidation.Par 
Parameterization class

DiskCacheBasedDoubleDistance 
Distance function that is based on double distances given by a distance
matrix of an external binary matrix file.

DiskCacheBasedDoubleDistance.Par 
Parameterization class.

DiskCacheBasedFloatDistance 
Distance function that is based on float distances given by a distance matrix
of an external binary matrix file.

DiskCacheBasedFloatDistance.Par 
Parameterization class.

Distance<O> 
Base interface for any kind of distances.

DistanceBasedInitializationWithMedian<O> 
Distance based initialization.

DistanceBasedIntrinsicDimensionalityEstimator 
Distancebased ID estimator.

DistanceEntry<E> 
Helper class: encapsulates an entry in an Index and a distance value
belonging to this entry.

DistanceFunctionVisualization 
Factory for visualizers to generate an SVGElement containing dots as markers
representing the kNN of the selected Database objects.

DistanceFunctionVisualization.Instance 
Instance, visualizing a particular set of kNNs

DistanceIndex<O> 
Index with support for distance queries
(e.g., precomputed distance matrixes, caches)

DistanceParser 
Parse distances from an input stream into a distance cache for storing.

DistanceParser.DistanceCacheWriter 
Interface to plug in the cache storage into the parser.

DistancePriorityIndex<O> 
Interface for incremental prioritybased search using distance functions.

DistanceQuantileSampler<O> 
Compute a quantile of a distance sample, useful for choosing parameters for
algorithms.

DistanceQuantileSampler.Par<O> 
Parameterization class

DistanceQuery<O> 
A distance query serves as adapter layer for database and primitive
distances.

DistanceResultAdapter 
This adapter is used to process a list of (double, DBID) objects.

DistanceSimilarityQuery<O> 
Interface that is a combination of distance and a similarity function.

DistanceStatisticsWithClasses<O> 
Algorithm to gather statistics over the distance distribution in the data
set.

DistanceStddevOutlier<O> 
A simple outlier detection algorithm that computes the standard deviation of
the kNN distances.

Distribution 
Statistical distributions, with their common functions.

Distribution.Parameterizer 
Common distributions parameters.

DistributionEstimator<D extends Distribution> 
Estimate distribution parameters from a sample.

DistributionStrategy 
Mtree entry distribution strategies.

DOC 
DOC is a sampling based subspace clustering algorithm.

DOC.Par 
Parameterization class.

DOMCloner 
Class for cloning XML document, with filter capabilites

DoubleArray 
Array of double values (primitive, avoiding the boxing overhead of ArrayList).

DoubleArrayAdapter 
Use a double[] in the ArrayAdapter API.

DoubleArrayListParameter 
Parameter class for a parameter specifying a list of vectors.

DoubleDataStore 
Doublevalued data store (avoids boxing/unboxing).

DoubleDBIDHeap 
Max heap for DBIDs.

DoubleDBIDIter 
Iterator over Double+DBID pairs results.

DoubleDBIDList 
Collection of double values associated with objects.

DoubleDBIDList.Consumer 
Consumer for (DBIDRef, double) pairs.

DoubleDBIDListIter 
Iterator over Double+DBID pairs results.

DoubleDBIDListMIter 
Modifiable DBIDList iterator.

DoubleDBIDPair 
Pair of a double value and a DBID.

DoubleDoublePair 
Pair storing two doubles.

DoubleDynamicHistogram 
A flexible histogram storing double, that can dynamically adapt the number of
bins to the data fed into the histogram.

DoubleHeap 
Basic inmemory heap for double values.

DoubleHeap.UnsortedIter 
Unsorted iterator  in heap order.

DoubleHistogram 
Histogram class storing double values.

DoubleIntegerArrayQuickSort 
Class to sort a double and an integer DBID array, using a quicksort with a
best of 5 heuristic.

DoubleIntegerDBIDArrayList 
Class to store double distance, integer DBID results.

DoubleIntegerDBIDHeap 
Wrapper around a primitive heap to handle DBIDs.

DoubleIntegerDBIDKNNHeap 
Class to efficiently manage a kNN heap.

DoubleIntegerDBIDKNNList 
kNN list, but without automatic sorting.

DoubleIntegerDBIDList 
Interface to store double distance, integer DBID results.

DoubleIntegerDBIDListIter 
Combination interface of the DoubleDBIDListIter with IntegerDBIDIter.

DoubleIntegerDBIDListMIter 
Combination interface for modifiable iterators.

DoubleIntegerDBIDPair 
Pair containing a double value and an integer DBID.

DoubleIntegerDBIDSubList 
Sublist of an existing result to contain only some of the elements.

DoubleIntegerHeap 
Basic inmemory heap interface, for double keys and int values.

DoubleIntegerHeap.UnsortedIter 
Unsorted iterator  in heap order.

DoubleIntegerMaxHeap 
Binary heap for double keys and int values.

DoubleIntegerMinHeap 
Binary heap for double keys and int values.

DoubleIntPair 
Pair storing an integer and a double.

DoubleListParameter 
Parameter class for a parameter specifying a list of double values.

DoubleLongHeap 
Basic inmemory heap interface, for double keys and long values.

DoubleLongHeap.UnsortedIter 
Unsorted iterator  in heap order.

DoubleLongMaxHeap 
Binary heap for double keys and long values.

DoubleLongMinHeap 
Binary heap for double keys and long values.

DoubleMaxHeap 
Binary heap for primitive types.

DoubleMinHeap 
Binary heap for primitive types.

DoubleMinMax 
Class to find the minimum and maximum double values in data.

DoubleMinMaxProcessor 
Sink collecting minimum and maximum values.

DoubleMinMaxProcessor.Instance 
Instance for a particular subchannel / part of the data set.

DoubleObjectHeap<V> 
Basic inmemory heap interface, for double keys and Object values.

DoubleObjectHeap.UnsortedIter<V> 
Unsorted iterator  in heap order.

DoubleObjectMaxHeap<V> 
Binary heap for double keys and Object values.

DoubleObjectMinHeap<V> 
Binary heap for double keys and Object values.

DoubleObjPair<O> 
Pair storing a native double value and an arbitrary object.

DoubleParameter 
Parameter class for a parameter specifying a double value.

DoubleRelation 
Interface for doublevalued relations.

DoubleRelation.Consumer 
Consumer for (DBIDRef, double) pairs.

DoubleStatistic 
Trivial doublevalued statistic.

DoubleVector 
Vector type using double[] storage for real numbers.

DoubleVector.Factory 
Factory for Double vectors.

DoubleVector.Factory.Par 
Parameterization class.

DoubleVector.ShortSerializer 
Serialization class for dense double vectors with up to
Short.MAX_VALUE dimensions, by using a short for storing the
dimensionality.

DoubleVector.SmallSerializer 
Serialization class for dense double vectors with up to 127 dimensions, by
using a byte for storing the dimensionality.

DoubleVector.VariableSerializer 
Serialization class for variable dimensionality by using VarInt encoding.

DoubleWeightedDataSet 
This is an efficient array based data set implementation.

DragableArea 
A simple dragable area for Batik.

DragableArea.DragListener 
Listener interface for drag events.

DropEigenPairFilter 
The "drop" filter looks for the largest drop in normalized relative
eigenvalues.

DropEigenPairFilter.Par 
Parameterization class.

DropNaNFilter 
A filter to drop all records that contain NaN values.

DropNaNFilter.Par 
Parameterization class.

DTWDistance 
Dynamic Time Warping distance (DTW) for numerical vectors.

DTWDistance.Par 
Parameterization class.

Duration 
Class that tracks the duration of a task.

DWOF<O> 
Algorithm to compute dynamicwindow outlier factors in a database based on a
specified parameter k, which specifies the number of the neighbors to be
considered during the calculation of the DWOF score.

DynamicIndex 
Index that supports dynamic insertions and removals.

DynamicParameters 
Wrapper around a set of parameters for ELKI, that may not yet be complete or
correct.

DynamicParameters.Node 
Node in the option tree (well, actually list)

DynamicParameters.RemainingOptions 
Dummy option class that represents unhandled options

EagerPAM<O> 
Variation of PAM that eagerly performs all swaps that yield an improvement
during an iteration.

EagerPAM.Instance 
Instance for a single dataset.

EagerPAM.Par<O> 
Parameterization class.

EarthModel 
API for handling different earth models.

Eclat 
Eclat is a depthfirst discovery algorithm for mining frequent itemsets.

Eclat.Par 
Parameterization class.

EditDistance 
Edit distance measures.

EDRDistance 
Edit Distance on Real Sequence distance for numerical vectors.

EDRDistance.Par 
Parameterization class.

EigenPair 
Helper class which encapsulates an eigenvector and its corresponding
eigenvalue.

EigenPairFilter 
The eigenpair filter is used to filter eigenpairs (i.e. eigenvectors and
their corresponding eigenvalues) which are a result of a Variance Analysis
Algorithm, e.g., Principal Component Analysis.

EigenvalueDecomposition 
Eigenvalues and eigenvectors of a real matrix.

ElkanKMeans<V extends NumberVector> 
Elkan's fast kmeans by exploiting the triangle inequality.

ElkanKMeans.Instance 
Inner instance, storing state for a single data set.

ElkanKMeans.Par<V extends NumberVector> 
Parameterization class.

ELKIBuilder<T> 
Builder utility class.

ELKILauncher 
Class to launch ELKI.

ELKILogRecord 
Base LogRecord class used in ELKI.

ELKIServiceLoader 
Class that emulates the behavior of an java ServiceLoader, except that the
classes are not automatically instantiated.

ELKIServiceRegistry 
Registry of available implementations in ELKI.

ELKIServiceRegistry.Entry 
Entry in the service registry.

ELKIServiceScanner 
A collection of inspectionrelated utility functions.

ELKIServiceScanner.DirClassIterator 
Class to iterate over a directory tree.

EM<O,M extends MeanModel> 
Clustering by expectation maximization (EMAlgorithm), also known as Gaussian
Mixture Modeling (GMM), with optional MAP regularization.

EM.Par<O,M extends MeanModel> 
Parameterization class.

EMClusterModel<O,M extends Model> 
Models usable in EM clustering.

EMClusterModelFactory<O,M extends Model> 
Factory for initializing the EM models.

EMClusterVisualization 
Visualizer for generating SVGElements containing ellipses for first, second
and third standard deviation.

EMClusterVisualization.Instance 
Instance.

EMGOlivierNorbergEstimator 
Naive distribution estimation using mean and sample variance.

EMGOlivierNorbergEstimator.Par 
Parameterization class.

EMModel 
Cluster model of an EM cluster, providing a mean and a full covariance
Matrix.

EMOutlier<V extends NumberVector> 
Outlier detection algorithm using EM Clustering.

EMOutlier.Par<V extends NumberVector> 
Parameterization class.

EmpiricalQueryOptimizer 
Class to automatically add indexes to a database.

EmptyDatabaseConnection 
Pseudo database that is empty.

EmptyDataException 
Exception thrown when a database / relation is empty.

EmptyDBIDs 
Empty DBID collection.

EmptyDBIDs.EmptyDBIDIterator 
Iterator for empty DBIDs

EmptyIterator<O> 
Empty object iterator.

EmptyParameterization 
Parameterization handler that only allows the use of default values.

EnsembleEstimator 
Ensemble estimator taking the median of three of our best estimators.

EnsembleVoting 
Interface for ensemble voting rules

EnsembleVotingInverseMultiplicative 
Inverse multiplicative voting:
\( 1\prod_i(1s_i) \)

EnsembleVotingInverseMultiplicative.Par 
Parameterization class.

EnsembleVotingMax 
Simple combination rule, by taking the maximum.

EnsembleVotingMean 
Simple combination rule, by taking the mean

EnsembleVotingMedian 
Simple combination rule, by taking the median.

EnsembleVotingMedian.Par 
Parameterization class.

EnsembleVotingMin 
Simple combination rule, by taking the minimum.

EnsembleVotingMultiplicative 
Inverse multiplicative voting:
\( \prod_i s_i \)

EnsembleVotingMultiplicative.Par 
Parameterization class.

Entropy 
Entropy based measures, implemented using natural logarithms.

EnumParameter<E extends java.lang.Enum<E>> 
Parameter class for a parameter specifying an enum type.

EnumParameterConfigurator 
Panel to configure EnumParameters by offering a dropdown to choose from.

EpanechnikovKernelDensityFunction 
Epanechnikov kernel density estimator.

EpanechnikovKernelDensityFunction.Par 
Parameterization stub.

EpsilonNeighborPredicate<O> 
The default DBSCAN and OPTICS neighbor predicate, using an
epsilonneighborhood.

EpsilonNeighborPredicate.Instance 
Instance for a particular data set.

EpsilonSVR 

ErfcStddevWeight 
Gaussian Error Function Weight function, scaled using stddev using:
\( \text{erfc}(\frac{1}{\sqrt{2}} \frac{\text{distance}}{\sigma}) \).

ErfcWeight 
Gaussian Error Function Weight function, scaled such that the result it 0.1
when the distance is the maximum using:
\( \text{erfc}(1.1630871536766736 \frac{\text{distance}}{\max}) \).

ERiC 
Performs correlation clustering on the data partitioned according to local
correlation dimensionality and builds a hierarchy of correlation clusters
that allows multiple inheritance from the clustering result.

ERiC.Par 
Parameterization class.

ERiC.Settings 
Class to wrap the ERiC settings.

ERiCNeighborPredicate 
ERiC neighborhood predicate.

ERiCNeighborPredicate.Par 
Parameterization class.

ERPDistance 
Edit Distance With Real Penalty distance for numerical vectors.

ERPDistance.Par 
Parameterization class.

ErrorFormatter 
Format a log record for error output, including a stack trace if available.

EstimateIntrinsicDimensionality<O> 
Estimate global average intrinsic dimensionality of a data set.

EuclideanDistance 

EuclideanDistance.Par 
Parameterization class.

EuclideanDistanceCriterion 
Distance criterion.

EuclideanHashFunctionFamily 
2stable hash function family for Euclidean distances.

EuclideanHashFunctionFamily.Par 
Parameterization class.

EuclideanRStarTreeDistancePrioritySearcher<O extends SpatialComparable> 
Instance of priority search for a particular spatial index.

EuclideanRStarTreeKNNQuery<O extends NumberVector> 
Instance of a KNN query for a particular spatial index.

EuclideanRStarTreeRangeQuery<O extends NumberVector> 
Instance of a range query for a particular spatial index.

EuclideanSphericalElkanKMeans<V extends NumberVector> 
Elkan's fast kmeans by exploiting the triangle inequality in the
corresponding Euclidean space.

EuclideanSphericalElkanKMeans.Instance 
Inner instance, storing state for a single data set.

EuclideanSphericalElkanKMeans.Par<V extends NumberVector> 
Parameterization class.

EuclideanSphericalHamerlyKMeans<V extends NumberVector> 
A spherical kMeans algorithm based on Hamerly's fast kmeans by exploiting
the triangle inequality in the corresponding Euclidean space.

EuclideanSphericalHamerlyKMeans.Instance 
Inner instance, storing state for a single data set.

EuclideanSphericalHamerlyKMeans.Par<V extends NumberVector> 
Parameterization class.

EuclideanSphericalSimplifiedElkanKMeans<V extends NumberVector> 
A spherical kMeans algorithm based on Hamerly's fast kmeans by exploiting
the triangle inequality in the corresponding Euclidean space.

EuclideanSphericalSimplifiedElkanKMeans.Instance 
Inner instance, storing state for a single data set.

EuclideanSphericalSimplifiedElkanKMeans.Par<V extends NumberVector> 
Parameterization class.

EvaluateClustering 
Evaluate a clustering result by comparing it to an existing cluster label.

EvaluateClustering.Par 
Parameterization class.

EvaluateClustering.ScoreResult 
Result object for outlier score judgements.

EvaluateIntrinsicDimensionalityEstimators 
Class for testing the estimation quality of intrinsic dimensionality
estimators.

EvaluateIntrinsicDimensionalityEstimators.Aggregate 
Aggregation methods.

EvaluateIntrinsicDimensionalityEstimators.OutputFormat 
Output format

EvaluateIntrinsicDimensionalityEstimators.Par 
Parameterization class.

EvaluatePrecomputedOutlierScores 
Class to load an outlier detection summary file, as produced by
ComputeKNNOutlierScores , and compute popular evaluation metrics.

EvaluatePrecomputedOutlierScores.Par 
Parameterization class.

EvaluateRankingQuality<V extends NumberVector> 
Evaluate a distance function with respect to kNN queries.

EvaluateRetrievalPerformance<O> 
Evaluate a distance functions performance by computing the mean average
precision, ROC, and NN classification performance when ranking the objects by
distance.

EvaluateRetrievalPerformance.KNNEvaluator 
Evaluate kNN retrieval performance.

EvaluateRetrievalPerformance.RetrievalPerformanceResult 
Result object for MAP scores.

EvaluationResult 
Abstract evaluation result.

EvaluationResult.Measurement 
Class representing a single measurement.

EvaluationResult.MeasurementGroup 
A group of evaluation measurements.

EvaluationStep 
The "evaluation" step, where data is analyzed.

EvaluationStep.Evaluation 
Class to handle running the evaluators on a database instance.

EvaluationStep.Par 
Parameterization class.

EvaluationTabPanel 
Panel to handle result evaluation

EvaluationVisualization 
PseudoVisualizer, that lists the cluster evaluation results found.

Evaluator 
Interface for postalgorithm evaluations, such as histograms, outlier score
evaluations, ...

ExactPrioritySearcher<O> 
Priority searcher that refines all objects to their exact distances,
using another priority searcher inside to provide candidates.

Executor 
Processor executor.

ExpGammaDistribution 
ExpGamma Distribution, with random generation and density functions.

ExpGammaDistribution.Par 
Parameterization class

ExpGammaExpMOMEstimator 
Simple parameter estimation for the ExpGamma distribution.

ExpGammaExpMOMEstimator.Par 
Parameterization class.

ExponentialDistribution 
Exponential distribution.

ExponentialDistribution.Par 
Parameterization class

ExponentialIntGenerator 
Generate an exponential range.

ExponentialLMMEstimator 
Estimate the parameters of a Gamma Distribution, using the methods of
LMoments (LMM).

ExponentialLMMEstimator.Par 
Parameterization class.

ExponentiallyModifiedGaussianDistribution 
Exponentially modified Gaussian (EMG) distribution (ExGaussian distribution)
is a combination of a normal distribution and an exponential distribution.

ExponentiallyModifiedGaussianDistribution.Par 
Parameterization class

ExponentialMADEstimator 
Estimate Exponential distribution parameters using Median and MAD.

ExponentialMADEstimator.Par 
Parameterization class.

ExponentialMedianEstimator 
Estimate Exponential distribution parameters using Median and MAD.

ExponentialMedianEstimator.Par 
Parameterization class.

ExponentialMOMEstimator 
Estimate Exponential distribution parameters using the mean, which is the
maximumlikelihood estimate (MLE), but not very robust.

ExponentialMOMEstimator.Par 
Parameterization class.

ExponentialStddevWeight 
Exponential Weight function, scaled using the standard deviation using:
\( \sigma \exp(\frac{1}{2} \frac{\text{distance}}{\sigma}) \).

ExponentialWeight 
Exponential Weight function, scaled such that the result it 0.1 at distance
equal max, so it does not completely disappear using:
\( \exp(2.3025850929940455 \frac{\text{distance}}{\max}) \)

ExponionKMeans<V extends NumberVector> 
Newlings's Exponion kmeans algorithm, exploiting the triangle inequality.

ExponionKMeans.Instance 
Inner instance, storing state for a single data set.

ExponionKMeans.Par<V extends NumberVector> 
Parameterization class.

ExportVisualizations 
Class that automatically generates all visualizations and exports them into
SVG files.

ExportVisualizations.Format 
File format

ExportVisualizations.Par 
Parameterization class

ExtendedArray<T> 
Class to extend an array with a single element virtually.

ExtendedNeighborhood 
Neighborhood obtained by computing the kfold closure of an existing
neighborhood.

ExtendedNeighborhood.Factory<O> 
Factory class.

ExtendedNeighborhood.Factory.Par<O> 
Parameterization class.

ExternalClustering 

ExternalClustering.Par 
Parameterization class

ExternalDoubleOutlierScore 
External outlier detection scores, loading outlier scores from an external
file.

ExternalDoubleOutlierScore.Par 
Parameterization class

ExternalID 
External ID objects.

ExternalIDFilter 
Class that turns a label column into an external ID column.

ExternalIDFilter.Par 
Parameterization class.

ExternalIDJoinDatabaseConnection 
Joins multiple data sources by their label

ExternalIDJoinDatabaseConnection.Par 
Parameterization class.

ExternalizablePage 
Base interface for externalizable pages.

ExternalNeighborhood 
A precomputed neighborhood, loaded from an external file.

ExternalNeighborhood.Factory 
Factory class.

ExternalNeighborhood.Factory.Par 
Parameterization class.

FarReinsert 
Reinsert objects on page overflow, starting with farther objects first (even
when they will likely be inserted into the same page again!)

FarReinsert.Par 
Parameterization class.

FarthestBalancedDistribution 
Balanced entry distribution strategy of the Mtree, beginning with the most
difficult points first.

FarthestPoints<O> 
KMeans initialization by repeatedly choosing the farthest point (by the
minimum distance to earlier points).

FarthestPoints.Par<O> 
Parameterization class.

FarthestPointsSplit<E extends MTreeEntry,N extends AbstractMTreeNode<?,N,E>> 
Farthest points split.

FarthestSumPoints<O> 
KMeans initialization by repeatedly choosing the farthest point (by the
sum of distances to previous objects).

FarthestSumPoints.Par<V> 
Parameterization class.

FastABOD<V extends NumberVector> 
FastABOD (approximateABOF) version of
AngleBased Outlier Detection / AngleBased Outlier Factor.

FastABOD.Par<V extends NumberVector> 
Parameterization class.

FastCLARA<V> 
Clustering Large Applications (CLARA) with the FastPAM
improvements, to increase scalability in the number of clusters.

FastCLARA.Par<V> 
Parameterization class.

FastCLARANS<V> 
A faster variation of CLARANS, that can explore O(k) as many swaps at a
similar cost by considering all medoids for each candidate nonmedoid.

FastCLARANS.Assignment 
Assignment state.

FastCLARANS.Par<V> 
Parameterization class.

FastDOC 
The heuristic variant of the DOC algorithm, FastDOC

FastDOC.Par 
Parameterization class.

FasterCLARA<O> 
Clustering Large Applications (CLARA) with the FastPAM
improvements, to increase scalability in the number of clusters.

FasterCLARA.Par<V> 
Parameterization class.

FasterMSC<O> 
Fast and Eager Medoid Silhouette Clustering.

FasterMSC.Par<O> 
Parameterization class.

FasterPAM<O> 
Variation of FastPAM that eagerly performs any swap that yields an
improvement during an iteration.

FasterPAM.Instance 
Instance for a single dataset.

FasterPAM.Par<O> 
Parameterization class.

FastMSC<O> 
Fast Medoid Silhouette Clustering.

FastMSC.Par<O> 
Parameterization class.

FastMSC.Record 
Data stored per point.

FastMultidimensionalScalingTransform<I,O extends NumberVector> 
Rescale the data set using multidimensional scaling, MDS.

FastMultidimensionalScalingTransform.Par<I,O extends NumberVector> 
Parameterization class.

FastNonThreadsafeRandom 
Dropin replacement for Random , but not using atomic long
seeds.

FastOPTICS<V extends NumberVector> 
FastOPTICS algorithm (Fast approximation of OPTICS)

FastPAM<O> 
FastPAM: An improved version of PAM, that is usually O(k) times faster.

FastPAM.Instance 
Instance for a single dataset.

FastPAM.Par<V> 
Parameterization class.

FastPAM1<O> 
FastPAM1: A version of PAM that is O(k) times faster, i.e., now in O((nk)Â²).

FastPAM1.Instance 
Instance for a single dataset.

FastPAM1.Par<V> 
Parameterization class.

FastutilIntOpenHashSetModifiableDBIDs 
Implementation using Fastutil IntSet.

FastutilIntOpenHashSetModifiableDBIDs.IntOpenHashSet 
Customized table.

FastutilIntOpenHashSetModifiableDBIDs.Itr 
Iterator over Fastutil hashs.

FDBSCAN 
FDBSCAN is an adaption of DBSCAN for fuzzy (uncertain) objects.

FDBSCAN.Par 
Parameterizer class.

FDBSCANNeighborPredicate 
Densitybased Clustering of Applications with Noise and Fuzzy objects
(FDBSCAN) is an Algorithm to find sets in a fuzzy database that are
densityconnected with minimum probability.

FDBSCANNeighborPredicate.Instance 
Instance of the neighbor predicate.

FDBSCANNeighborPredicate.Par 
Parameterizer class.

FeatureBagging 
A simple ensemble method called "Feature bagging" for outlier detection.

FeatureBagging.Par 
Parameterization class.

FeatureSelection<V extends FeatureVector<F>,F> 
Projection class for number vectors.

FeatureSelection.Par<V extends FeatureVector<F>,F> 
Parameterization class.

FeatureVector<D> 
Generic FeatureVector class that can contain any type of data (i.e. numerical
or categorical attributes).

FeatureVector.Factory<V extends FeatureVector<? extends D>,D> 
Factory API for this feature vector.

FeatureVectorAdapter<F> 
Adapter to use a feature vector as an array of features.

FieldTypeInformation 
Types with a fixed dimensionality (e.g., vector fields, but also e.g.,
polygon types).

FileBasedDatabaseConnection 
File based database connection based on the parser to be set.

FileBasedDatabaseConnection.Par 
Parameterization class.

FileBasedSparseDoubleDistance 
Distance function that is based on double distances given by a distance
matrix of an external ASCII file.

FileBasedSparseDoubleDistance.Par 
Parameterization class.

FileBasedSparseFloatDistance 
Distance function that is based on float distances given by a distance matrix
of an external ASCII file.

FileBasedSparseFloatDistance.Par 
Parameterization class.

FileListParameter 
Parameter class for a parameter specifying a list of files.

FileListParameter.FilesType 

FileOrderBulkSplit 
Trivial bulk loading  assumes that the file has been appropriately sorted
before.

FileOrderBulkSplit.Par 
Parameterization class.

FileParameter 
Parameter class for a parameter specifying a file.

FileParameter.FileType 

FileParameterConfigurator 
Provide a configuration panel to choose a file with a file selector button.

FileUtil 
Various static helper methods to deal with files and file names.

FilteredConvexHull2D 
Accelerate computing the convex hull with a simple filter.

FilteredDistanceResultAdapter 
This adapter is used to process a list of (double, DBID) objects, but allows
skipping one object in the ranking.

FilteredIt<O> 
Filtered iterator.

FilterUtil 
Utilities for implementing filters.

FiniteProgress 
A progress object for a given overall number of items to process.

FirstK<O> 
Initialize Kmeans by using the first k objects as initial means.

FirstK.Par<V extends NumberVector> 
Parameterization class.

FirstNEigenPairFilter 
The FirstNEigenPairFilter marks the n highest eigenpairs as strong
eigenpairs, where n is a user specified number.

FirstNEigenPairFilter.Par 
Parameterization class.

FirstNStreamFilter 
Keep only the first N elements of the data source.

FirstNStreamFilter.Par 
Parameterization class

FisherRaoDistance 
FisherRao riemannian metric for (discrete) probability distributions.

FisherRaoDistance.Par 
Parameterization class.

FittingFunction 
Interface for a function used in LevenbergMarquardFitting

FittingFunctionResult 
Result returned by a fitting function.

FixedDBIDsFilter 
This filter assigns static DBIDs, based on the sequence the objects appear in
the bundle by adding a column of DBID type to the bundle.

FixedDBIDsFilter.Par 
Parameterization class.

FixedSizeByteBufferSerializer<T> 
Serializers with a fixed length serialization.

Flag 
Option class specifying a flag object.

Flag.BooleanConsumer 
Represents an operation that accepts a single boolean valued
argument and returns no result.

FlagParameterConfigurator 
Provide a configuration panel to modify a boolean via a checkbox.

FlatRStarTree 
FlatRTree is a spatial index structure based on a R*Tree but with a flat
directory.

FlatRStarTreeFactory<O extends NumberVector> 
Factory for flat R*Trees.

FlatRStarTreeFactory.Par<O extends NumberVector> 
Parameterization class.

FlatRStarTreeIndex<O extends NumberVector> 
The common use of the flat rstar tree: indexing number vectors.

FlatRStarTreeNode 
Represents a node in a flat R*Tree.

FlexibleBetaLinkage 
Flexiblebeta linkage as proposed by Lance and Williams.

FlexibleBetaLinkage.Par 
Parameterization class.

FlexibleLOF<O> 
Flexible variant of the "Local Outlier Factor" algorithm.

FlexibleLOF.LOFResult<O> 
Encapsulates information like the neighborhood, the LRD and LOF values of
the objects during a run of the FlexibleLOF algorithm.

FlexibleLOF.Par<O> 
Parameterization class.

FloatArrayAdapter 
Use a float[] in the ArrayAdapter API.

FloatVector 
Vector type using float[] storage, thus needing approximately half as
much memory as DoubleVector .

FloatVector.Factory 
Factory for float vectors.

FloatVector.Factory.Par 
Parameterization class.

FloatVector.ShortSerializer 
Serialization class for dense float vectors with up to
Short.MAX_VALUE dimensions, by using a short for storing the
dimensionality.

FloatVector.SmallSerializer 
Serialization class for dense float vectors with up to 127 dimensions, by
using a byte for storing the dimensionality.

FloatVector.VariableSerializer 
Serialization class for variable dimensionality by using VarInt encoding.

FormatUtil 
Utility methods for output formatting of various number objects

FourC 
4C identifies local subgroups of data objects sharing a uniform correlation.

FourC.Par 
Parameterization class.

FourC.Settings 
Class wrapping the 4C parameter settings.

FourC.Settings.Par 
Parameterization class for 4C settings.

FourCCorePredicate 
The 4C core point predicate.

FourCCorePredicate.Instance 
Instance for a particular data set.

FourCCorePredicate.Par 
Parameterization class

FourCNeighborPredicate 
4C identifies local subgroups of data objects sharing a uniform correlation.

FourCNeighborPredicate.Instance 
Instance for a particular data set.

FourCNeighborPredicate.Par 
Parameterization class.

FPGrowth 
FPGrowth is an algorithm for mining the frequent itemsets by using a
compressed representation of the database called FPGrowth.FPTree .

FPGrowth.FPNode 
A single node of the FP tree.

FPGrowth.FPNode.Translator 
Translator class for tree printing.

FPGrowth.FPTree 
FPTree data structure

FPGrowth.FPTree.Collector 
Interface for collecting frequent itemsets found.

FPGrowth.Par 
Parameterization class.

FractionalSharedNearestNeighborSimilarity<O> 
SharedNearestNeighborSimilarity with a pattern defined to accept
Strings that define a nonnegative Integer.

FractionalSharedNearestNeighborSimilarity.Instance<T> 
Actual instance for a dataset.

FrequentItemsetsResult 
Result class for frequent itemset mining algorithms.

FullDatabaseReferencePoints 
Strategy to use the complete database as reference points.

FullProjection 
Full vector space projections.

FuzzyCMeans<V extends NumberVector> 
Fuzzy Clustering developed by Dunn and revisited by Bezdek

FuzzyCMeans.Par 
Parameterization class.

GammaChoiWetteEstimator 
Estimate distribution parameters using the method by Choi and Wette.

GammaChoiWetteEstimator.Par 
Parameterization class.

GammaDistribution 
Gamma Distribution, with random generation and density functions.

GammaDistribution.Par 
Parameterization class

GammaLMMEstimator 
Estimate the parameters of a Gamma Distribution, using the methods of
LMoments (LMM).

GammaLMMEstimator.Par 
Parameterization class.

GammaMOMEstimator 
Simple parameter estimation for the Gamma distribution.

GammaMOMEstimator.Par 
Parameterization class.

GammaScaling 
Nonlinear scaling function using a Gamma curve.

GammaScaling.Par 
Parameterization class.

GaussianAffinityMatrixBuilder<O> 
Compute the affinity matrix for SNE and tSNE using a Gaussian distribution
with a constant sigma.

GaussianAffinityMatrixBuilder.Par<O> 
Parameterization class.

GaussianFittingFunction 
Gaussian function for parameter fitting

GaussianKernelDensityFunction 
Gaussian kernel density estimator.

GaussianKernelDensityFunction.Par 
Parameterization stub.

GaussianModel 
Outlier detection based on the probability density of the single normal
distribution.

GaussianModel.Par 
Parameterization class.

GaussianRandomProjectionFamily 
Random projections using Cauchy distributions (1stable).

GaussianRandomProjectionFamily.Par 
Parameterization class.

GaussianUniformMixture 
Outlier detection algorithm using a mixture model approach.

GaussianUniformMixture.Par 
Parameterization class.

GaussStddevWeight 
Gaussian weight function, scaled using standard deviation
\( \frac{1}{\sqrt{2\pi}} \exp(\frac{\text{dist}^2}{2\sigma^2}) \)

GaussWeight 
Gaussian weight function, scaled such that the result it 0.1 when distance
equals the maximum, using
\( \exp(2.3025850929940455 \frac{\text{dist}^2}{\max^2}) \).

GEDEstimator 
Generalized Expansion Dimension for estimating the intrinsic dimensionality.

GEDEstimator.Par 
Parameterization class.

GeneralizedDBSCAN 
Generalized DBSCAN, densitybased clustering with noise.

GeneralizedDBSCAN.Instance<T> 
Instance for a particular data set.

GeneralizedDBSCAN.Par 
Parameterization class

GeneralizedExtremeValueDistribution 
Generalized Extreme Value (GEV) distribution, also known as Fisherâ€“Tippett
distribution.

GeneralizedExtremeValueDistribution.Par 
Parameterization class

GeneralizedExtremeValueLMMEstimator 
Estimate the parameters of a Generalized Extreme Value Distribution, using
the methods of LMoments (LMM).

GeneralizedExtremeValueLMMEstimator.Par 
Parameterization class.

GeneralizedHyperplaneDistribution 
Generalized hyperplane entry distribution strategy of the Mtree.

GeneralizedLogisticAlternateDistribution 
Generalized logistic distribution.

GeneralizedLogisticAlternateDistribution.Par 
Parameterization class

GeneralizedLogisticAlternateLMMEstimator 
Estimate the parameters of a Generalized Logistic Distribution, using the
methods of LMoments (LMM).

GeneralizedLogisticAlternateLMMEstimator.Par 
Parameterization class.

GeneralizedLogisticDistribution 
Generalized logistic distribution.

GeneralizedLogisticDistribution.Par 
Parameterization class

GeneralizedOPTICS 
A trivial generalization of OPTICS that is not restricted to numerical
distances, and serves as a base for several other algorithms (HiCO, HiSC).

GeneralizedOPTICS.Instance<R> 
Instance for processing a single data set.

GeneralizedParetoDistribution 
Generalized Pareto Distribution (GPD), popular for modeling long tail
distributions.

GeneralizedParetoDistribution.Par 
Parameterization class

GeneralizedParetoLMMEstimator 
Estimate the parameters of a Generalized Pareto Distribution (GPD), using the
methods of LMoments (LMM).

GeneralizedParetoLMMEstimator.Par 
Parameterization class.

GeneratorInterface 
Interface for cluster generators

GeneratorInterfaceDynamic 
Interface for a dynamic cluster generator.

GeneratorMain 
Generate a data set according to a given model.

GeneratorModel 
Cluster model for synthetically generated data.

GeneratorSingleCluster 
Class to generate a single cluster according to a model as well as getting
the density of a given model at that point (to evaluate generated points
according to the same model)

GeneratorStatic 
Class for static clusters, that is an implementation of GeneratorInterface
that will return only a given set of points.

GeneratorXMLDatabaseConnection 
Data source from an XML specification.

GeneratorXMLDatabaseConnection.Par 
Parameterization class.

GeneratorXMLSpec 
Generate a data set based on a specified model (using an XML specification)

GeneratorXMLSpec.Par 
Parameterization class.

GeoIndexing 
Example code for using the Rtree index of ELKI, with Haversine distance.

GeometricLinkage 
Geometric linkages, in addition to the combination with
LanceWilliamsEquations, these linkages can also be computed by aggregating
data points (for vector data only).

GiniIndex 
Giniindex based interestingness measure, using the weighted squared
conditional probabilities compared to the nonconditional priors.

GlobalPrincipalComponentAnalysisTransform<O extends NumberVector> 
Apply Principal Component Analysis (PCA) to the data set.

GlobalPrincipalComponentAnalysisTransform.Mode 
Transformation mode.

GlobalPrincipalComponentAnalysisTransform.Par<O extends NumberVector> 
Parameterization class.

GLOSH 
GlobalLocal Outlier Scores from Hierarchies.

GLOSH.Par 
Parameterization class.

GMeans<V extends NumberVector,M extends MeanModel> 
GMeans extends KMeans and estimates the number of centers with Anderson
Darling Test.
Implemented as specialization of XMeans.

GMeans.Par<V extends NumberVector,M extends MeanModel> 
Parameterization class.

GNAT<O> 
Geometric Nearneighbor Access Tree (GNAT), also known as Multi Vantage Point
Tree or MVPTree.

GNAT.Factory<O extends NumberVector> 
Index Factory

GNAT.Factory.Par<O extends NumberVector> 
Parameterization class.

GNAT.GNATKNNSearcher 
kNN query for the mvptree.

GNAT.GNATRangeSearcher 
range query for the mvptree

GNAT.Node 
The Node class saves the important information for the each node

GNAT.PrioritySearchBranch 
Search position for priority search.

GoodnessOfFitTest 
Interface for the statistical test used by HiCS.

GrahamScanConvexHull2D 
Classes to compute the convex hull of a set of points in 2D, using the
classic Grahams scan.

GreaterConstraint 
Represents a parameter constraint for testing if the value of the number
parameter ( NumberParameter ) tested is greater than the specified
constraint value.

GreaterEqualConstraint 
Represents a GreaterEqualThanNumber parameter constraint.

GreedyEnsembleExperiment 
Class to load an outlier detection summary file, as produced by
ComputeKNNOutlierScores , and compute a naive ensemble for it.

GreedyEnsembleExperiment.Distance 
Distance modes.

GreedyEnsembleExperiment.Par 
Parameterization class.

GreedyG<O> 
Initialization method for kmedoids that combines the Greedy (PAM
BUILD ) with "alternate" refinement steps.

GreedyG.Par<V> 
Parameterization class.

GreedyKCenter<O> 
Greedy algorithm for kcenter algorithm also known as Gonzalez clustering,
or farthestfirst traversal.

GreedyKCenter.Par<O> 
Parameterization class

GreeneSplit 
Quadratictime complexity split as used by Diane Greene for the RTree.

GreeneSplit.Par 
Parameterization class.

GridBasedReferencePoints 
Gridbased strategy to pick reference points.

GridBasedReferencePoints.Par 
Parameterization class.

GriDBSCAN<V extends NumberVector> 
Using Grid for Accelerating DensityBased Clustering.

GriDBSCAN.Instance<V extends NumberVector> 
Instance, for a single run.

GroupAverageLinkage 
Groupaverage linkage clustering method (UPGMA).

GroupAverageLinkage.Par 
Class parameterizer.

GRS67SpheroidEarthModel 
The GRS 67 spheroid earth model.

GRS67SpheroidEarthModel.Par 
Parameterization class.

GRS80SpheroidEarthModel 
The GRS 80 spheroid earth model, without height model (so not a geoid, just a
spheroid!)

GRS80SpheroidEarthModel.Par 
Parameterization class.

GUIUtil 
GUI utilities.

GumbelDistribution 
Gumbel distribution, also known as LogWeibull distribution.

GumbelDistribution.Par 
Parameterization class

GumbelLMMEstimator 
Estimate the parameters of a Gumbel Distribution, using the methods of
LMoments (LMM).

GumbelLMMEstimator.Par 
Parameterization class.

GumbelMADEstimator 
Parameter estimation via median and median absolute deviation from median
(MAD).

GumbelMADEstimator.Par 
Parameterization class.

HACAM<O> 
Hierarchical Agglomerative Clustering Around Medoids (HACAM) is a
hierarchical clustering method that merges the clusters with the smallest
distance to the medoid of the union.

HACAM.Instance 
Main worker instance of AGNES.

HACAM.Variant 
Variants of the HACAM method.

HaltonUniformDistribution 
Halton sequences are a pseudouniform distribution.

HaltonUniformDistribution.Par 
Parameterization class

HamerlyKMeans<V extends NumberVector> 
Hamerly's fast kmeans by exploiting the triangle inequality.

HamerlyKMeans.Instance 
Inner instance, storing state for a single data set.

HamerlyKMeans.Par<V extends NumberVector> 
Parameterization class.

HammingDistance 
Computes the Hamming distance of arbitrary vectors  i.e. counting, on how
many places they differ.

HammingDistance.Par 
Parameterization class.

HandlerList<H> 
Manages a list of handlers for objects.

HartiganWongKMeans<V extends NumberVector> 
Hartigan and Wong kmeans clustering.

HartiganWongKMeans.Instance 
Instance for a particular data set.

HartiganWongKMeans.Parameterizer<V extends NumberVector> 
Parameterization class.

HashmapDatabase 
Database storing data using hashtable storage, and thus allowing additional
and removal of objects.

HashmapDatabase.Par 
Parameterization class.

HashMapHierarchy<O> 
Centralized hierarchy implementation, using a HashMap of Lists.

HashSetDBIDs 
Hashorganized DBIDs

HashSetModifiableDBIDs 
Setoriented implementation of a modifiable DBID collection.

HDBSCANHierarchyExtraction 
Extraction of simplified cluster hierarchies, as proposed in HDBSCAN,
and additionally also compute the GLOSH outlier scores.

HDBSCANHierarchyExtraction.Par 
Parameterization class.

HDBSCANHierarchyExtraction.TempCluster 
Temporary cluster.

HDBSCANHierarchyExtractionEvaluator 
Extract clusters from a hierarchical clustering, during the evaluation phase.

HDBSCANHierarchyExtractionEvaluator.Par 
Parameterization class.

HDBSCANLinearMemory<O> 
Linear memory implementation of HDBSCAN clustering.

Heap<E> 
Basic inmemory heap structure.

HeapUtil 
Next power of 2, for heaps.

HeDESNormalizationOutlierScaling 
Normalization used by HeDES

HellingerDistance 
Hellinger metric / affinity / kernel, Bhattacharyya coefficient, fidelity
similarity, Matusita distance, HellingerKakutani metric on a probability
distribution.

HellingerDistance.Par 
Parameterization class.

HellingerHistogramNormalization<V extends NumberVector> 
Normalize histograms by scaling them to unit absolute sum, then taking the
square root of the absolute value in each attribute, times the normalization
constant \(1/\sqrt{2}\).

HellingerHistogramNormalization.Par 
Parameterization class.

HiCO 
Implementation of the HiCO algorithm, an algorithm for detecting hierarchies
of correlation clusters.

HiCO.Par 
Parameterization class.

HiCS 
Algorithm to compute High Contrast Subspaces for DensityBased Outlier
Ranking.

HiCS.HiCSSubspace 
BitSet that holds a contrast value as field.

HiCSDependence 
Use the statistical tests as used by HiCS to measure dependence of variables.

HiCSDependence.Par 
Parameterization class.

HierarchicalClassLabel 
A HierarchicalClassLabel is a ClassLabel to reflect a hierarchical structure
of classes.

HierarchicalClassLabel.Factory 
Factory class.

HierarchicalClusteringAlgorithm 
Interface for hierarchical clustering algorithms.

Hierarchy<O> 
This interface represents an (external) hierarchy of objects.

HilbertSpatialSorter 
Sort object along the Hilbert Space Filling curve by mapping them to their
Hilbert numbers and sorting them.

HilbertSpatialSorter.HilbertRef 
Object used in spatial sorting, combining the spatial object and the object
ID.

HilbertSpatialSorter.Par 
Parameterization class.

HillEstimator 
Hill estimator of the intrinsic dimensionality (maximum likelihood estimator
for ID).

HillEstimator.Par 
Parameterization class.

HilOut<O extends NumberVector> 
Fast Outlier Detection in High Dimensional Spaces

HilOut.HilFeature 
Hilbert representation of a single object.

HilOut.ScoreType 
Type of output: all scores (upper bounds) or top n only

HiSC 
Implementation of the HiSC algorithm, an algorithm for detecting hierarchies
of subspace clusters.

HiSC.Par 
Parameterization class.

Histogram 
Abstract API for histograms.

Histogram.Iter 
Array iterator.

HistogramFactory 
Produce onedimensional projections.

HistogramFactory.Par 
Parameterization class.

HistogramIntersectionDistance 
Intersection distance for color histograms.

HistogramIntersectionDistance.Par 
Parameterization class.

HistogramJitterFilter<V extends NumberVector> 
Add jitter, preserving the histogram properties (same sum, nonnegative).

HistogramJitterFilter.Par 
Parameterization class.

HistogramMatchDistance 
Distance function based on histogram matching, i.e., Manhattan distance on
the cumulative density function.

HistogramMatchDistance.Par 
Parameterization class, using the static instance.

HistogramProjector<V extends NumberVector> 
ScatterPlotProjector is responsible for producing a set of scatterplot
visualizations.

HistogramResult 
Histogram result.

HistogramVisualization 
Visualizer to draw histograms.

HoeffdingsD 
Calculate Hoeffding's D as a measure of dependence.

HoeffdingsD.Par 
Parameterization class.

Holdout 
A holdout procedure is to provide a range of partitions of a database to
pairs of training and test data sets.

HopkinsStatisticClusteringTendency 
The Hopkins Statistic of Clustering Tendency measures the probability that a
data set is generated by a uniform data distribution.

HopkinsStatisticClusteringTendency.Par 
Parameterization class.

HoughSpaceMeasure 
HSM: Compute the "interestingness" of dimension connections using the Hough
transformation.

HoughSpaceMeasure.Par 
Parameterization class.

HSBHistogramQuadraticDistance 
Distance function for HSB color histograms based on a quadratic form and
color similarity.

HSBHistogramQuadraticDistance.Par 
Parameterization class.

HyperBoundingBox 
HyperBoundingBox represents a hyperrectangle in the multidimensional space.

HySortOD 
HypercubeBased Outlier Detection.

HySortOD.DensityStrategy 
Strategy for compute density.

HySortOD.Hypercube 
Bounded regions of the space where at least one instance exists.

HySortOD.NaiveStrategy 
Naive strategy for computing density.

HySortOD.TreeStrategy 
Tree strategy for computing density.

HySortOD.TreeStrategy.Node 
Tree node.

IdentityScaling 
The trivial "identity" scaling function.

IDOS<O> 
Intrinsic Dimensional Outlier Detection in HighDimensional Data.

IDOS.Par<O> 
Parameterization class.

IncompatibleDataException 
Exception thrown when no compatible data was found.

InconsistentDataException 
Data inconsistency exception.

IncreasingVectorIter 
Class to iterate over a number vector in decreasing order.

IndefiniteProgress 
Progress class without a fixed destination value.

Index 
Interface defining the minimum requirements for all index classes.

IndexBasedDistance<O> 
Distance function relying on an index (such as preprocessed neighborhoods).

IndexBasedDistance.Instance<T,I extends Index> 
Instance interface for Index based distance functions.

IndexBasedSimilarity<O> 
Interface for preprocessor/index based similarity functions.

IndexBasedSimilarity.Instance<T,I extends Index> 
Instance interface for index/preprocessor based distance functions.

IndexFactory<V> 
Factory interface for indexes.

IndexPurity 
Compute the purity of index pages as a naive measure for performance
capabilities using the Gini index.

IndexStatistics 
Simple index analytics, which includes the toString() dump of index
information.

IndexStatistics.IndexMetaResult 
Result class.

IndexTree<N extends Node<E>,E> 
Abstract super class for all tree based index classes.

IndexTreePath<E> 
Represents a path to a node in an index structure.

INFLO<O> 
Influence Outliers using Symmetric Relationship (INFLO) using twoway search,
is an outlier detection method based on LOF; but also using the reverse kNN.

INFLO.Par<O> 
Parameterization class.

InMemoryIDistanceIndex<O> 
Inmemory iDistance index, a metric indexing method using a reference point
embedding.

InMemoryIDistanceIndex.Factory<V> 
Index factory for iDistance indexes.

InMemoryInvertedIndex<V extends NumberVector> 
Simple index using inverted lists, for cosine distance only.

InMemoryInvertedIndex.Factory<V extends NumberVector> 
Index factory

InMemoryLSHIndex<V> 
Locality Sensitive Hashing.

InMemoryLSHIndex.Par<V> 
Parameterization class.

InputStep 
Data input step of the workflow.

InputStep.Par 
Parameterization class.

InputStreamDatabaseConnection 
Database connection expecting input from an input stream such as stdin.

InputStreamDatabaseConnection.Par 
Parameterization class.

InputTabPanel 
Panel to handle data input.

InsertionStrategy 
RTree insertion strategy interface.

InstanceLogRankNormalization<V extends NumberVector> 
Normalize vectors such that the smallest value of each instance is 0, the
largest is 1, but using \( \log_2(1+x) \).

InstanceLogRankNormalization.Par 
Parameterization class.

InstanceMeanVarianceNormalization<V extends NumberVector> 
Normalize vectors such that they have zero mean and unit variance.

InstanceMeanVarianceNormalization.Par<V extends NumberVector> 
Parameterization class.

InstanceMinMaxNormalization<V extends NumberVector> 
Normalize vectors with respect to a given minimum and maximum in each
dimension.

InstanceMinMaxNormalization.Par<V extends NumberVector> 
Parameterization class.

InstanceRankNormalization<V extends NumberVector> 
Normalize vectors such that the smallest value of each instance is 0, the
largest is 1.

InstanceRankNormalization.Par 
Parameterization class.

IntDoublePair 
Pair storing an integer and a double.

IntegerArray 
Array of int values (primitive, avoiding the boxing overhead of ArrayList).

IntegerArrayDBIDs 
Trivial combination interface.

IntegerArrayQuickSort 
Class to sort an int array, using a modified quicksort.

IntegerArrayStaticDBIDs 

IntegerDataStore 
Integervalued data store (avoids boxing/unboxing).

IntegerDBID 
Database ID object.

IntegerDBID.DynamicSerializer 
Dynamic sized serializer, using varint.

IntegerDBID.StaticSerializer 
Static sized serializer, using regular integers.

IntegerDBIDArrayIter 
Modifiable integer array iterator.

IntegerDBIDArrayMIter 
Modifiable integer array iterator.

IntegerDBIDArrayQuickSort 
Class to sort an integer DBID array, using a modified quicksort.

IntegerDBIDIter 
Iterator for integer DBIDs.

IntegerDBIDKNNSubList 
Sublist of an existing result to contain only the first k elements.

IntegerDBIDMIter 
Modifiable iterator interface for integer DBIDs.

IntegerDBIDPair 
DBID pair using two ints for storage.

IntegerDBIDPair.Itr 
Iterator.

IntegerDBIDRange 
Representing a DBID range allocation.

IntegerDBIDRange.Itr 
Iterator in ELKI/C++ style.

IntegerDBIDRef 
DBID reference that references an integer value.

IntegerDBIDs 
Integer DBID collection.

IntegerDBIDVar 
Variable for storing a single DBID reference.

IntegerHeap 
Basic inmemory heap for int values.

IntegerHeap.UnsortedIter 
Unsorted iterator  in heap order.

IntegerMaxHeap 
Binary heap for primitive types.

IntegerMinHeap 
Binary heap for primitive types.

IntegerMinMax 
Class to find the minimum and maximum int values in data.

IntegerObjectHeap<V> 
Basic inmemory heap interface, for int keys and Object values.

IntegerObjectHeap.UnsortedIter<V> 
Unsorted iterator  in heap order.

IntegerObjectMaxHeap<V> 
Binary heap for int keys and Object values.

IntegerObjectMinHeap<V> 
Binary heap for int keys and Object values.

IntegerRankTieNormalization 
Normalize vectors according to their rank in the attributes.

IntegerRankTieNormalization.Sorter 
Class to sort an index array by a particular dimension.

IntegerVector 
Vector type using int[] storage.

IntegerVector.Factory 
Factory for integer vectors.

IntegerVector.Factory.Par 
Parameterization class.

IntegerVector.ShortSerializer 
Serialization class for dense integer vectors with up to
Short.MAX_VALUE dimensions, by using a short for storing the
dimensionality.

IntegerVector.SmallSerializer 
Serialization class for dense integer vectors with up to 127 dimensions, by
using a byte for storing the dimensionality.

IntegerVector.VariableSerializer 
Serialization class for variable dimensionality by using VarInt encoding.

InterclusterWeight 
Initialization via n2 * D2Â²(cf1, cf2), which supposedly is closes to the idea
of kmeans++ initialization.

InterestingnessMeasure 
Interface for interestingness measures.

IntGenerator 
Generators of integer ranges.

IntGeneratorParameter 
Parameter class for a parameter specifying ranges of integer values.

IntIntPair 
Pair storing two integers.

IntListParameter 
Parameter class for a parameter specifying a list of integer values.

IntParameter 
Parameter class for a parameter specifying an integer value.

IntrinsicDimensionalityEstimator<O> 
Estimate the intrinsic dimensionality from a distance list.

IntrinsicNearestNeighborAffinityMatrixBuilder<O> 
Build sparse affinity matrix using the nearest neighbors only, adjusting for
intrinsic dimensionality.

IntrinsicNearestNeighborAffinityMatrixBuilder.Par<O> 
Parameterization class.

InverseDocumentFrequencyNormalization<V extends SparseNumberVector> 
Normalization for text frequency (TF) vectors, using the inverse document
frequency (IDF).

InverseGaussianDistribution 
Inverse Gaussian distribution aka Wald distribution.

InverseGaussianDistribution.Par 
Parameterization class

InverseGaussianMLEstimator 
Estimate parameter of the inverse Gaussian (Wald) distribution.

InverseGaussianMLEstimator.Par 
Parameterization class.

InverseGaussianMOMEstimator 
Estimate parameter of the inverse Gaussian (Wald) distribution.

InverseGaussianMOMEstimator.Par 
Parameterization class.

InverseLinearWeight 
Inverse linear weight function using \(.1+0.9\frac{\text{distance}}{\max}\).

InverseProportionalStddevWeight 
Inverse proportional weight function, scaled using the standard deviation
using: \( 1 / (1 + \frac{distance}{\sigma}) \)

InverseProportionalWeight 
Inverse proportional weight function, scaled using the maximum using:
\( 1 / (1 + \frac{\text{distance}}{\max} ) \)

InvertedDistanceSimilarity<O> 
Adapter to use a primitive numberdistance as similarity measure, by
computing 1/distance.

InvertedOutlierScoreMeta 
Class to signal a valueinverted outlier score, i.e. low values are outliers.

IsolationForest 
IsolationBased Anomaly Detection.

IsolationForest.ForestBuilder 
Class to build the forest

IsolationForest.Node 
Minimalistic tree node for the isolation forest.

IsolationForest.Par 
Parameterization class

ISOS<O> 
Intrinsic Stochastic Outlier Selection.

It<O> 
Object iterator interface.

Itemset 
Frequent itemset.

Iter 
Iterator interface for more than one return value.

IterableIt<O> 
ELKI style Iterator wrapper for collections.

IterableResult<O> 
Interface of an "iterable" result (e.g., a list, table) that can be printed onebyone.

Jaccard 
Jaccard interestingness measure:

JaccardSimilarityDistance 
A flexible extension of Jaccard similarity to nonbinary vectors.

JeffreyDivergenceDistance 

JeffreyDivergenceDistance.Par 
Parameterization class, using the static instance.

JensenShannonDivergenceDistance 

JensenShannonDivergenceDistance.Par 
Parameterization class, using the static instance.

JensenShannonEquiwidthDependence 
JensenShannon Divergence is closely related to mutual information.

JensenShannonEquiwidthDependence.Par 
Parameterization class.

JMeasure 
JMeasure interestingness measure.

JSVGSynchronizedCanvas 
An JSVGCanvas that allows easier synchronization of Updates for SVGPlot
objects.

JSVGUpdateSynchronizer 
This class is used to synchronize SVG updates with an JSVG canvas.

JudgeOutlierScores 
Compute a Histogram to evaluate a ranking algorithm.

JudgeOutlierScores.Par 
Parameterization class.

JudgeOutlierScores.ScoreResult 
Result object for outlier score judgements.

KappaDistribution 
Kappa distribution, by Hosking.

KappaDistribution.Par 
Parameterization class

KDDCLIApplication 
Basic command line application for Knowledge Discovery in Databases use
cases.

KDDCLIApplication.Par 
Parameterization class.

KDDTask 
KDDTask encapsulates the common workflow of an unsupervised knowledge
discovery task.

KDDTask.Par 
Parameterization class.

KDEOS<O> 
Generalized Outlier Detection with Flexible Kernel Density Estimates.

KDistanceProcessor 
Compute the kNN distance for each object.

KDistanceProcessor.Instance 
Instance for precomputing the kNN.

KDTreeEM 
Clustering by expectation maximization (EMAlgorithm), also known as Gaussian
Mixture Modeling (GMM), calculated on a kdtree.

KDTreeEM.KDTree 
KDTree class with the statistics needed for EM clustering.

KDTreeEM.Par 
Parameterization class.

KDTreeFilteringKMeans<V extends NumberVector> 
Filtering or "blacklisting" Kmeans with kdtree acceleration.

KDTreeFilteringKMeans.Par<V extends NumberVector> 
Parameterization class.

KDTreePruningKMeans<V extends NumberVector> 
Pruning Kmeans with kdtree acceleration.

KDTreePruningKMeans.KDNode 
Node of the kdtree used internally.

KDTreePruningKMeans.Par<V extends NumberVector> 
Parameterization class.

KDTreePruningKMeans.Split 
Splitting strategies for constructing the kdtree.

Kernel 

KernelDensityEstimator 
Estimate density given an array of points.

KernelDensityFunction 
Inner function of a kernel density estimator.

KernelMatrix 
Kernel matrix representation.

KeyVisualization 
Visualizer, displaying the key for a clustering.

KeyVisualization.Instance 
Instance

Klosgen 
KlÃ¶sgen interestingness measure.

KMC2 
KMCÂ² initialization

KMC2.Instance 
Abstract instance implementing the weight handling.

KMC2.Par 
Parameterization class.

KMeans<V extends NumberVector,M extends Model> 
Some constants and options shared among kmeans family algorithms.

KMeansInitialization 
Interface for initializing KMeans

KMeansMinusMinus<V extends NumberVector> 
kmeans: A Unified Approach to Clustering and Outlier Detection.

KMeansMinusMinus.Par<V extends NumberVector> 
Parameterization class.

KMeansMinusMinusOutlierDetection 
kmeans: A Unified Approach to Clustering and Outlier Detection.

KMeansMinusMinusOutlierDetection.Par 
Parameterizer.

KMeansModel 
Trivial subclass of the MeanModel that indicates the clustering to be
produced by kmeans (so the Voronoi cell visualization is sensible).

KMeansOutlierDetection<O extends NumberVector> 
Outlier detection by using kmeans clustering.

KMeansOutlierDetection.Rule 
Outlier scoring rule

KMeansPlusPlus<O> 
KMeans++ initialization for kmeans.

KMeansPlusPlus.Instance<T> 
Abstract instance implementing the weight handling.

KMeansPlusPlus.MedoidsInstance 
Instance for kmedoids.

KMeansPlusPlus.NumberVectorInstance 
Instance for kmeans, number vector based.

KMeansPlusPlus.Par<V> 
Parameterization class.

KMeansProcessor<V extends NumberVector> 
Parallel kmeans implementation.

KMeansProcessor.Instance<V extends NumberVector> 
Instance to process part of the data set, for a single iteration.

KMeansQualityMeasure<O extends NumberVector> 
Interface for computing the quality of a KMeans clustering.

KMediansLloyd<V extends NumberVector> 
kmedians clustering algorithm, but using Lloydstyle bulk iterations instead
of the more complicated approach suggested by Kaufman and Rousseeuw (see
PAM instead).

KMediansLloyd.Instance 
Inner instance, storing state for a single data set.

KMediansLloyd.Par<V extends NumberVector> 
Parameterization class.

KMedoidsClustering<O> 
Interface for clustering algorithms that produce medoids.

KMedoidsInitialization<O> 
Interface for initializing KMedoids.

KMedoidsKMedoidsInitialization<O> 
Initialize kmedoids with kmedoids, for methods such as PAMSIL.
This could also be used to initialize, e.g., PAM with CLARA.

KMedoidsKMedoidsInitialization.Par<O> 
Parameterization class.

KMLOutputHandler 
Class to handle KML output.

KMLOutputHandler.Par 
Parameterization class

KNNBenchmark<O> 
Benchmarking experiment that computes the k nearest neighbors for each query
point.

KNNChangeEvent 
Encapsulates information describing changes of the k nearest neighbors (kNNs)
of some objects due to insertion or removal of objects.

KNNChangeEvent.Type 
Available event types.

KNNClassifier<O> 
KNNClassifier classifies instances based on the class distribution among the
k nearest neighbors in a database.

KNNDD<O> 
Nearest Neighbor Data Description.

KNNDD.Par<O> 
Parameterization class.

KNNDistancesSampler<O> 
Provides an order of the kNNdistances for all objects within the database.

KNNDistancesSampler.KNNDistanceOrderResult 
Curve result for a list containing the knn distances.

KNNDistancesSampler.Par<O> 
Parameterization class.

KNNHeap 
Interface for kNN heaps.

KNNIndex<O> 
Index with support for kNN queries.

KNNJoin 
Joins in a given spatial database to each object its knearest neighbors.

KNNJoin.Par 
Parameterization class.

KNNJoin.Task 
Task in the processing queue.

KNNJoinMaterializeKNNPreprocessor<V extends SpatialComparable> 
Class to materialize the kNN using a spatial join on an Rtree.

KNNJoinMaterializeKNNPreprocessor.Factory<O extends SpatialComparable> 
The parameterizable factory.

KNNKernelDensityMinimaClustering 
Cluster onedimensional data by splitting the data set on local minima after
performing kernel density estimation.

KNNKernelDensityMinimaClustering.Mode 
Estimation mode.

KNNKernelDensityMinimaClustering.Par 
Parameterization class.

KNNList 
Interface for kNN results.

KNNListener 
Listener interface invoked when the k nearest neighbors (kNNs) of some
objects have been changed due to insertion or removals of objects.

KNNOutlier<O> 
Outlier Detection based on the distance of an object to its k nearest
neighbor.

KNNOutlier.Par<O> 
Parameterization class.

KNNProcessor 
Processor to compute the kNN of each object.

KNNProcessor.Instance 
Instance for precomputing the kNN.

KNNSearcher<O> 
The interface of an actual instance.

KNNSOS<O> 
kNNbased adaption of Stochastic Outlier Selection.

KNNWeightOutlier<O> 
Outlier Detection based on the accumulated distances of a point to its k
nearest neighbors.

KNNWeightOutlier.Par<O> 
Parameterization class.

KNNWeightProcessor 

KNNWeightProcessor.Instance 
Instance for precomputing the kNN.

KolmogorovSmirnovDistance 
Distance function based on the KolmogorovSmirnov goodness of fit test.

KolmogorovSmirnovDistance.Par 
Parameterization class, using the static instance.

KolmogorovSmirnovTest 
KolmogorovSmirnov test.

KolmogorovSmirnovTest.Par 
Parameterizer, to use the static instance.

KuhnMunkres 
KuhnMunkres optimal matching (aka the Hungarian algorithm).

KuhnMunkresStern 
A version of KuhnMunkres inspired by the implementation of Kevin L.

KuhnMunkresWong 
KuhnMunkres optimal matching (aka the Hungarian algorithm), supposedly in a
modern variant.

Kulczynski1Similarity 
Kulczynski similarity 1.

Kulczynski1Similarity.Par 
Parameterization class.

Kulczynski2Similarity 
Kulczynski similarity 2.

Kulczynski2Similarity.Par 
Parameterization class.

KullbackLeiblerDivergenceAsymmetricDistance 
KullbackLeibler divergence, also known as relative entropy,
information deviation, or just KLdistance (albeit asymmetric).

KullbackLeiblerDivergenceAsymmetricDistance.Par 
Parameterization class, using the static instance.

KullbackLeiblerDivergenceReverseAsymmetricDistance 
KullbackLeibler divergence, also known as relative entropy, information
deviation or just KLdistance (albeit asymmetric).

KullbackLeiblerDivergenceReverseAsymmetricDistance.Par 
Parameterization class, using the static instance.

LAB<O> 
Linear approximative BUILD (LAB) initialization for FastPAM (and kmeans).

LAB.Par<V> 
Parameterization class.

LabelJoinDatabaseConnection 
Joins multiple data sources by their label

LabelJoinDatabaseConnection.Par 
Parameterization class.

LabelList 
A list of string labels.

LabelList.Serializer 
Serialization class.

LabelVisualization 
Trivial "visualizer" that displays a static label.

LAESA<O> 
Linear Approximating and Eliminating Search Algorithm

LAESA.Factory<O> 
Index factory.

LAESA.Factory.Par<O> 
Parameterization class.

LaplaceCorrectedConfidence 
Laplace Corrected Confidence interestingness measure.

LaplaceDistribution 
Laplace distribution also known as double exponential distribution

LaplaceDistribution.Par 
Parameterization class

LaplaceKernel 
Laplace / exponential radial basis function kernel.

LaplaceKernel.Par 
Parameterization class.

LaplaceLMMEstimator 
Estimate Laplace distribution parameters using the method of LMoments (LMM).

LaplaceLMMEstimator.Par 
Parameterization class.

LaplaceMADEstimator 
Estimate Laplace distribution parameters using Median and MAD.

LaplaceMADEstimator.Par 
Parameterization class.

LaplaceMLEEstimator 
Estimate Laplace distribution parameters using Median and mean deviation from
median.

LaplaceMLEEstimator.Par 
Parameterization class.

LatLngAsECEFIndex<O extends NumberVector> 
Index a 2d data set (consisting of Lat/Lng pairs) by using a projection to 3D
coordinates (WGS86 to ECEF).

LatLngAsECEFIndex.Factory<O extends NumberVector> 
Index factory.

LatLngDistance 
Distance function for 2D vectors in Latitude, Longitude form.

LatLngDistance.Par 
Parameterization class.

LatLngToECEFFilter<V extends NumberVector> 
Project a 2D data set (latitude, longitude) to a 3D coordinate system (X, Y,
Z), such that Euclidean distance is lineofsight.

LatLngToECEFProjection<V extends NumberVector> 
Project (Latitude, Longitude) vectors to (X, Y, Z), from spherical
coordinates to ECEF (earthcentered earthfixed).

LayerMap 
Class to help keeping track of the materialized layers of the different
visualizations.

Layout 
Layout class.

Layout.Edge 
Edge class

Layout.Node 
Node of the layout tree.

Layouter3DPC<V> 
Arrange parallel coordinates on a 2D plane, for 3D parallel coordinates.

LazyCanvasResizer 
Class to lazily process canvas resize events by applying a threshold.

LBABOD<V extends NumberVector> 
LBABOD (lowerbound) version of
AngleBased Outlier Detection / AngleBased Outlier Factor.

LBABOD.Par<V extends NumberVector> 
Parameterization class.

LCSSDistance 
Longest Common Subsequence distance for numerical vectors.

LCSSDistance.Par 
Parameterization class.

LDF<O extends NumberVector> 
Outlier Detection with Kernel Density Functions.

LDOF<O> 
Computes the LDOF (Local DistanceBased Outlier Factor) for all objects of a
Database.

LDOF.Par<O> 
Parameterization class.

Leader<O> 
Leader clustering algorithm.

LeafEntry 
Leaf entry of an index.

LeastEnlargementInsertionStrategy 
The default RTree insertion strategy: find rectangle with least volume
enlargement.

LeastEnlargementInsertionStrategy.Par 
Parameterization class.

LeastEnlargementWithAreaInsertionStrategy 
A slight modification of the default RTree insertion strategy: find
rectangle with least volume enlargement, but choose least area on ties.

LeastEnlargementWithAreaInsertionStrategy.Par 
Parameterization class.

LeastOneDimSSQSplit 
Split by the best reduction in sumofsquares, but only considering one
dimension at a time.

LeastOneDimSSQSplit.Par 
Parameterizer

LeastOverlapInsertionStrategy 
The choose subtree method proposed by the R*Tree for leaf nodes.

LeastOverlapInsertionStrategy.Par 
Parameterization class.

LeastSSQSplit 
Split by the best reduction in sumofsquares.

LeastSSQSplit.Par 
Parameterizer

LeaveOneOut 
A leaveoneoutholdout is to provide a set of partitions of a database where
each instances once hold out as a test instance while the respectively
remaining instances are training instances.

LengthNormalization<V extends NumberVector> 
Class to perform a normalization on vectors to norm 1.

LengthNormalization.Par<V extends NumberVector> 
Parameterization class.

LessConstraint 
Represents a LessThanNumber parameter constraint.

LessEqualConstraint 
Represents a LessEqualThanNumber parameter constraint.

LevenbergMarquardtMethod 
Function parameter fitting using LevenbergMarquardt method.

LevenshteinDistance 
Classic Levenshtein distance on strings.

LevenshteinDistance.Par 
Parameterization class.

Leverage 
Leverage interestingness measure.

LibSVMFormatParser<V extends SparseNumberVector> 
Parser to read libSVM format files.

LibSVMFormatParser.Par<V extends SparseNumberVector> 
Parameterization class.

LibSVMOneClassOutlierDetection<V extends NumberVector> 
Outlierdetection using oneclass support vector machines.

LibSVMOneClassOutlierDetection.SVMKernel 
Kernel functions.

LID<O> 
Use intrinsic dimensionality for outlier detection.

LID.Par<O> 
Parameterization class.

Lift 
Lift interestingness measure.

LimitedReinsertOverflowTreatment 
Limited reinsertions, as proposed by the R*Tree: For each real insert, allow
reinsertions to happen only once per level.

LimitedReinsertOverflowTreatment.Par 
Parameterization class.

LimitEigenPairFilter 
The LimitEigenPairFilter marks all eigenpairs having an (absolute) eigenvalue
below the specified threshold (relative or absolute) as weak eigenpairs, the
others are marked as strong eigenpairs.

LimitEigenPairFilter.Par 
Parameterization class.

LinearDiscriminantAnalysisFilter<V extends NumberVector> 
Linear Discriminant Analysis (LDA) / Fisher's linear discriminant.

LinearDiscriminantAnalysisFilter.Par<V extends NumberVector> 
Parameterization class.

LinearEquationModel 
Cluster model containing a linear equation system for the cluster.

LinearEquationSystem 
Class for systems of linear equations.

LinearIntGenerator 
Generate a linear range.

LinearKernel 
Linear Kernel function that computes a similarity between the two feature
vectors x and y defined by \(x^T\cdot y\).

LinearKernel.Par 
Parameterization class.

LinearMemoryNNChain<O extends NumberVector> 
NNchain clustering algorithm with linear memory, for particular linkages
(that can be aggregated) and numerical vector data only.

LinearMemoryNNChain.Instance<O extends NumberVector> 
Main worker instance of NNChain.

LinearRegression 

LinearScale 
Class to handle a linear scale for an axis.

LinearScaling 
Simple linear scaling function.

LinearScanDistanceRangeByDBID<O> 
Default linear scan range query class.

LinearScanDistanceRangeByObject<O> 
Default linear scan range query class.

LinearScanEuclideanKNNByObject<O extends NumberVector> 
Instance of this query for a particular database.

LinearScanEuclideanPrioritySearcher<Q,O extends NumberVector> 
Default linear scan search class, for Euclidean distance.

LinearScanEuclideanPrioritySearcher.ByDBID<O extends NumberVector> 
Search by DBID.

LinearScanEuclideanPrioritySearcher.ByObject<O extends NumberVector> 
Search by Object.

LinearScanEuclideanRangeByObject<O extends NumberVector> 
Optimized linear scan for Euclidean distance range queries.

LinearScanKNNByDBID<O> 
Instance of this query for a particular database.

LinearScanKNNByObject<O> 
Instance of this query for a particular database.

LinearScanPrimitiveDistanceRangeByObject<O> 
Default linear scan range query class.

LinearScanPrimitiveKNNByObject<O> 
Instance of this query for a particular database.

LinearScanPrimitiveSimilarityRangeByObject<O> 
Default linear scan range query class.

LinearScanPrioritySearcher<Q,O> 
Default linear scan search class.

LinearScanPrioritySearcher.ByDBID<O> 
Search by DBID.

LinearScanPrioritySearcher.ByObject<O> 
Search by Object.

LinearScanQuery 
Marker interface for linear scan (slow, nonaccelerated) queries.

LinearScanRKNNByDBID<O> 
Default linear scan RKNN query class.

LinearScanRKNNByObject<O> 
Default linear scan RKNN query class.

LinearScanSimilarityRangeByDBID<O> 
Default linear scan range query class.

LinearScanSimilarityRangeByObject<O> 
Default linear scan range query class.

LinearSimilarityAdapter<O> 
Adapter from a normalized similarity function to a distance function using
1  sim .

LinearSimilarityAdapter.Instance<O> 
Distance function instance

LinearSimilarityAdapter.Par<O> 
Parameterization class.

LinearWeight 
Linear weight function, scaled using the maximum such that it goes from 1.0
to 0.1 using: \( 1  0.9 \frac{\text{distance}}{\max} \)

LinearWeightedExtendedNeighborhood 
Neighborhood obtained by computing the kfold closure of an existing
neighborhood.

LinearWeightedExtendedNeighborhood.Factory<O> 
Factory class.

LinearWeightedExtendedNeighborhood.Factory.Par<O> 
Parameterization class.

LineReader 
Fast class to read a file, line per line.

LineStyleLibrary 
Interface to obtain CSS classes for plot lines.

LineVisualization 
Generates data lines.

Linkage 
Abstract interface for implementing a new linkage method into hierarchical
clustering.

ListBasedColorLibrary 
Color library using the color names from a list.

ListEachNumberConstraint<T> 
Applies numeric constraints to all elements of a list.

ListParameter<P extends ListParameter<P,T>,T> 
Abstract parameter class defining a parameter for a list of objects.

ListParameterization 
Parameterization handler using a List and OptionIDs, for programmatic use.

ListParameterization.ParameterPair 
Parameter pair, packageprivate.

ListSizeConstraint 
Represents a listsize parameter constraint.

LloydKMeans<V extends NumberVector> 
The standard kmeans algorithm, using bulk iterations and commonly attributed
to Lloyd and Forgy (independently).

LloydKMeans.Instance 
Inner instance, storing state for a single data set.

LloydKMeans.Par<V extends NumberVector> 
Parameterization class.

LMCLUS 
Linear manifold clustering in high dimensional spaces by stochastic search.

LMCLUS.Par 
Parameterization class

LMCLUS.Separation 
Class to represent a linear manifold separation

LMMDistributionEstimator<D extends Distribution> 
Interface for distribution estimators based on the methods of LMoments
(LMM).

LMomentsEstimator 
Probability weighted moments based estimator using LMoments.

LMomentsEstimator.Par 
Parameterization class.

LngLatAsECEFIndex<O extends NumberVector> 
Index a 2d data set (consisting of Lng/Lat pairs) by using a projection to 3D
coordinates (WGS86 to ECEF).

LngLatAsECEFIndex.Factory<O extends NumberVector> 
Index factory.

LngLatDistance 
Distance function for 2D vectors in Longitude, Latitude form.

LngLatDistance.Par 
Parameterization class.

LngLatToECEFFilter<V extends NumberVector> 
Project a 2D data set (longitude, latitude) to a 3D coordinate system (X, Y,
Z), such that Euclidean distance is lineofsight.

LngLatToECEFProjection<V extends NumberVector> 
Project (Longitude, Latitude) vectors to (X, Y, Z), from spherical
coordinates to ECEF (earthcentered earthfixed).

LnSimilarityAdapter<O> 
Adapter from a normalized similarity function to a distance function using
log(sim) .

LnSimilarityAdapter.Instance<O> 
Distance function instance

LnSimilarityAdapter.Par<O> 
Parameterization class.

LocalIsolationCoefficient<O> 
The Local Isolation Coefficient is the sum of the kNN distance and the
average distance to its k nearest neighbors.

LocalIsolationCoefficient.Par<O> 
Parameterization class.

LocalitySensitiveHashFunction<V> 
Hash functions as used by locality sensitive hashing.

LocalitySensitiveHashFunctionFamily<V> 
LSH family of hash functions.

LOCI<O> 
Fast Outlier Detection Using the "Local Correlation Integral".

LOCI.DoubleIntArrayList 
Array of doubleint values.

LOF<O> 
Algorithm to compute densitybased local outlier factors in a database based
on a specified parameter lof.k .

LOFProcessor 
Processor for computing the LOF.

Log1PlusNormalization<V extends NumberVector> 
Normalize the data set by applying \( \frac{\log(1+xb)}{\log 1+b} \) to any
value.

Log1PlusNormalization.Par<V extends NumberVector> 
Parameterization class.

LogClusterSizes 
This class will log simple statistics on the clusters detected, such as the
cluster sizes and the number of clusters.

LogGammaDistribution 
LogGamma Distribution, with random generation and density functions.

LogGammaDistribution.Par 
Parameterization class

LogGammaLogMOMEstimator 
Simple parameter estimation for the LogGamma distribution.

LogGammaLogMOMEstimator.Par 
Parameterization class.

Logging 
This class is a wrapper around Logger and
LogManager offering additional convenience
functions.

Logging.Level 
Logging Level class.

LoggingConfiguration 
Facility for configuration of logging.

LoggingStep 
Pseudostep to configure logging / verbose mode.

LoggingStep.Par 
Parameterization class.

LoggingTabPanel 
Panel to handle logging

LoggingUtil 
This final class contains some static convenience methods for logging.

LogisticDistribution 
Logistic distribution.

LogisticDistribution.Par 
Parameterization class

LogisticLMMEstimator 
Estimate the parameters of a Logistic Distribution, using the methods of
LMoments (LMM).

LogisticLMMEstimator.Par 
Parameterization class.

LogisticMADEstimator 
Estimate Logistic distribution parameters using Median and MAD.

LogisticMADEstimator.Par 
Parameterization class.

LogLogisticDistribution 
LogLogistic distribution also known as Fisk distribution.

LogLogisticDistribution.Par 
Parameterization class

LogLogisticMADEstimator 
Estimate Logistic distribution parameters using Median and MAD.

LogLogisticMADEstimator.Par 
Parameterization class.

LogMADDistributionEstimator<D extends Distribution> 
Distribuition estimators that use the method of moments (MOM) in logspace.

LogMeanVarianceEstimator<D extends Distribution> 
Estimators that work on Mean and Variance only (i.e. the first two moments
only).

LogMOMDistributionEstimator<D extends Distribution> 
Distribution estimators that use the method of moments (MOM) in logspace,
i.e. that only need the statistical moments of a data set after logarithms.

LogNormalBilkovaLMMEstimator 
Alternate estimate the parameters of a log Gamma Distribution, using the
methods of LMoments (LMM) for the Generalized Normal Distribution.

LogNormalBilkovaLMMEstimator.Par 
Parameterization class.

LogNormalDistribution 
LogNormal distribution.

LogNormalDistribution.Par 
Parameterization class

LogNormalLevenbergMarquardtKDEEstimator 
Distribution parameter estimation using LevenbergMarquardt iterative
optimization and a kernel density estimation.

LogNormalLevenbergMarquardtKDEEstimator.Par 
Parameterization class.

LogNormalLMMEstimator 
Estimate the parameters of a log Normal Distribution, using the methods of
LMoments (LMM) for the Generalized Normal Distribution.

LogNormalLMMEstimator.Par 
Parameterization class.

LogNormalLogMADEstimator 
Estimator using Medians.

LogNormalLogMADEstimator.Par 
Parameterization class.

LogNormalLogMOMEstimator 
Naive distribution estimation using mean and sample variance.

LogNormalLogMOMEstimator.Par 
Parameterization class.

LogPane 
A Swing object to receive ELKI logging output.

LogPanel 
Panel that contains a text logging pane ( LogPane ) and progress bars.

LogRankingPseudoOutlierScaling 
This is a pseudo outlier scoring obtained by only considering the ranks of
the objects.

LogResultStructureResultHandler 
A result handler to help with ELKI development that will just show the
structure of the result object.

LongParameter 
Parameter class for a parameter specifying a long value.

LongStatistic 
Trivial longvalued statistic.

LoOP<O> 
LoOP: Local Outlier Probabilities

LPCAEstimator 
Local PCA based ID estimator.

LPCAEstimator.Par 
Parameterization class.

LPIntegerNormDistance 
L _{p}Norm for NumberVector s, optimized version for integer
values of p.

LPIntegerNormDistance.Par 
Parameterization class.

LPNormDistance 
L _{p}Norm (Minkowski norms) are a family of distances for
NumberVector s.

LPNormDistance.Par 
Parameterization class.

LRDProcessor 
Processor for the "local reachability density" of LOF.

LRUCache<P extends Page> 
An LRU cache, based on LinkedHashMap .
This cache has a fixed maximum number of objects (cacheSize ).

LRUCachePageFileFactory<P extends Page> 
Page file factory for memory page files.

LRUCachePageFileFactory.Par 
Parameterization class.

LSDBC<O extends NumberVector> 
Locally Scaled Density Based Clustering.

LSDBC.Par<O extends NumberVector> 
Parameterization class

LUDecomposition 
LU Decomposition.

MacQueenKMeans<V extends NumberVector> 
The original kmeans algorithm, using MacQueen style incremental updates;
making this effectively an "online" (streaming) algorithm.

MacQueenKMeans.Instance 
Inner instance, storing state for a single data set.

MacQueenKMeans.Par<V extends NumberVector> 
Parameterization class.

MADDistributionEstimator<D extends Distribution> 
Distribuition estimators that use the method of moments (MOM), i.e. that only
need the statistical moments of a data set.

MahalanobisDistance 
Mahalanobis quadratic form distance for feature vectors.

ManhattanDistance 

ManhattanDistance.Par 
Parameterization class.

ManhattanHashFunctionFamily 
2stable hash function family for Euclidean distances.

ManhattanHashFunctionFamily.Par 
Parameterization class.

MapIntegerDBIDDBIDStore 
Writable data store for double values.

MapIntegerDBIDDoubleStore 
Writable data store for double values.

MapIntegerDBIDIntegerStore 
Writable data store for double values.

MapIntegerDBIDRecordStore 
A class to answer representation queries using a map and an index within the
record.

MapIntegerDBIDStore<T> 
A class to answer representation queries using a map.

MapRecordStore 
A class to answer representation queries using a map and an index within the
record.

MapStore<T> 
A class to answer representation queries using a map.

MarkerLibrary 
A marker library is a class that can generate and draw various styles of
markers.

MarkerVisualization 
Visualize a clustering using different markers for different clusters.

MarkerVisualization.Instance 
Instance.

MaterializedDoubleRelation 
Represents a single representation.

MaterializedRelation<O> 
Represents a single representation.

MaterializeKNNAndRKNNPreprocessor<O> 
A preprocessor for annotation of the k nearest neighbors and the reverse k
nearest neighbors (and their distances) to each database object.

MaterializeKNNAndRKNNPreprocessor.Factory<O> 
The parameterizable factory.

MaterializeKNNAndRKNNPreprocessor.Factory.Par<O> 
Parameterization class.

MaterializeKNNPreprocessor<O> 
A preprocessor for annotation of the k nearest neighbors (and their
distances) to each database object.

MaterializeKNNPreprocessor.Factory<O> 
The parameterizable factory.

MaterializeKNNPreprocessor.Factory.Par<O> 
Parameterization class.

MathUtil 
A collection of math related utility functions.

MatrixWeightedQuadraticDistance 

MaxExtensionBulkSplit 
Split strategy for bulkloading a spatial tree where the split axes are the
dimensions with maximum extension.

MaxExtensionBulkSplit.Par 
Parameterization class.

MaxExtensionSortTileRecursiveBulkSplit 

MaxExtensionSortTileRecursiveBulkSplit.Par 
Parameterization class.

MaximumConditionalEntropy 
Compute a mutual information based dependence measure using a nested means
discretization, originally proposed for ordering axes in parallel coordinate
plots.

MaximumConditionalEntropy.Par 
Parameterization class.

MaximumDistance 

MaximumDistance.Par 
Parameterization class.

MaximumF1Evaluation 
Evaluate using the maximum F1 score.

MaximumF1Evaluation.Par 
Parameterization class.

MaximumMatchingAccuracy 
Calculates the accuracy of a clustering based on the maximum set matching
found by the Hungarian algorithm.

MCDEDependence 
Implementation of bivariate Monte Carlo Density Estimation as described in

MCDEDependence.Par 
Parameterizer

MCDETest<R extends MCDETest.RankStruct> 

MCDETest.RankStruct 
Structure to hold return values in index creation for MCDEDependence

Mean 
Compute the mean using a numerically stable online algorithm.

MeanModel 
Cluster model that stores a mean for the cluster.

MeanVariance 
Do some simple statistics (mean, variance) using a numerically stable online
algorithm.

MeanVarianceDistributionEstimator<D extends Distribution> 
Interface for estimators that only need mean and variance.

MeanVarianceMinMax 
Class collecting mean, variance, minimum and maximum statistics.

MeanVarianceSplit 
Split on the median of the axis with the largest variance.

MeanVarianceSplit.Par 
Parameterizer

MedianLinkage 
Medianlinkage — weighted pair group method using centroids (WPGMC).

MedianLinkage.Par 
Class parameterizer.

MedianSplit 
Split on the median of the axis with the largest length.

MedianSplit.Par 
Parameterizer

MedianVarianceSplit 
Split on the median of the axis with the largest variance.

MedianVarianceSplit.Par 
Parameterizer

MedoidLinkage<O> 
Medoid linkage uses the distance of medoids as criterion.

MedoidLinkage.Instance 
Main worker instance of AGNES.

MedoidModel 
Cluster model that stores a mean for the cluster.

MemoryDataStoreFactory 
Simple factory class that will store all data in memory using object arrays
or hashmaps.

MemoryKDTree<O extends NumberVector> 
Implementation of a static inmemory KDtree.

MemoryKDTree.Factory<O extends NumberVector> 
Factory class

MemoryKDTree.Factory.Par<O extends NumberVector> 
Parameterization class.

MemoryKDTree.KDNode 
KD tree node.

MemoryKDTree.PrioritySearchBranch 
Search position for priority search.

MemoryPageFile<P extends Page> 
A memory based implementation of a PageFile that simulates I/Oaccess.

MemoryPageFileFactory<P extends Page> 
Page file factory for memory page files.

MemoryPageFileFactory.Par 
Parameterization class.

MergedParameterization 
This configuration can be "rewound" to allow the same values to be consumed
multiple times, by different classes.

MessageFormatter 
A formatter to simply retrieve the message of an LogRecord without printing
origin information.

Metadata 
Metadata management class.

Metadata.CleanerThread 
Cleanup thread.

Metadata.EagerIt<O> 
Base class for iterators that need to look ahead, e.g., to check
conditions on the next element.

MetricalIndexApproximationMaterializeKNNPreprocessor<O extends NumberVector,N extends Node<E>,E extends MTreeEntry> 
A preprocessor for annotation of the k nearest neighbors (and their
distances) to each database object.

MetricalIndexApproximationMaterializeKNNPreprocessor.Factory<O extends NumberVector,N extends Node<E>,E extends MTreeEntry> 
The parameterizable factory.

MetricalIndexApproximationMaterializeKNNPreprocessor.Factory.Par<O extends NumberVector,N extends Node<E>,E extends MTreeEntry> 
Parameterization class.

MetricalIndexTree<O,N extends Node<E>,E> 
Abstract super class for all metrical index classes.

MidpointSplit 
Classic midpoint split, halfway on the axis of largest extend.

MidpointSplit.Par 
Parameterizer

MillisTimeDuration 
Class that tracks the runtime of a task with System.nanoTime()

MiniGUI 
Minimal GUI built around a tablebased parameter editor.

MiniGUI.SettingsComboboxModel 
Class to interface between the saved settings list and a JComboBox.

MinimalisticMemoryKDTree<O extends NumberVector> 
Simple implementation of a static inmemory KDtree.

MinimalisticMemoryKDTree.CountSortAccesses 
Class to count object accesses during construction.

MinimalisticMemoryKDTree.Factory<O extends NumberVector> 
Factory class

MinimalisticMemoryKDTree.Factory.Par<O extends NumberVector> 
Parameterization class.

MinimalisticMemoryKDTree.PrioritySearchBranch 
Search position for priority search.

MinimalMarkers 
Simple marker library that just draws colored rectangles at the given
coordinates.

MiniMax<O> 
Minimax Linkage clustering.

MiniMax.Instance 
Main worker instance of MiniMax.

MiniMaxAnderberg<O> 
This is a modification of the classic MiniMax algorithm for hierarchical
clustering using a nearestneighbor heuristic for acceleration.

MiniMaxAnderberg.Instance 
Main worker instance of MiniMax.

MiniMaxNNChain<O> 
MiniMax hierarchical clustering using the NNchain algorithm.

MiniMaxNNChain.Instance 
Main worker instance of MiniMaxNNChain.

MinimumDistance 

MinimumDistance.Par 
Parameterization class.

MinimumEnlargementInsert<N extends AbstractMTreeNode<?,N,E>,E extends MTreeEntry> 
Minimum enlargement insert  default insertion strategy for the Mtree.

MinimumVarianceLinkage 
Minimum increase in variance (MIVAR) linkage.

MinimumVarianceLinkage.Par 
Class parameterizer.

MinPtsCorePredicate 

MinPtsCorePredicate.Instance 
Instance for a particular data set.

MinPtsCorePredicate.Par 
Parameterization class

MinusLogGammaScaling 
Scaling that can map arbitrary values to a probability in the range of [0:1],
by assuming a Gamma distribution on the data and evaluating the Gamma CDF.

MinusLogGammaScaling.Par 
Parameterization class.

MinusLogScaling 
Scaling function to invert values by computing 1 * Math.log(x)

MinusLogStandardDeviationScaling 
Scaling that can map arbitrary values to a probability in the range of [0:1].

MinusLogStandardDeviationScaling.Par 
Parameterization class.

MissingPrerequisitesException 
Exception thrown when prerequisites are not satisfied.

MIter 
Modifiable iterator, that also supports removal.

MixtureModelOutlierScaling 
Tries to fit a mixture model (exponential for inliers and gaussian for
outliers) to the outlier score distribution.

MkAppDirectoryEntry 
Represents an entry in a directory node of a MkAppTree.

MkAppEntry 
Defines the requirements for an entry in an MkCopTree node.

MkAppLeafEntry 
Represents an entry in a leaf node of a MkAppTree.

MkAppTree<O> 
MkAppTree is a metrical index structure based on the concepts of the MTree
supporting efficient processing of reverse k nearest neighbor queries for
parameter k < kmax.

MkAppTreeFactory<O> 
Factory for a MkAppTree

MkAppTreeIndex<O> 
MkAppTree used as database index.

MkAppTreeNode<O> 
Represents a node in an MkAppTree.

MkAppTreeSettings<O> 
Settings class for the MkApp Tree.

MkCoPDirectoryEntry 
Represents an entry in a directory node of an MkCopTree.

MkCoPEntry 
Defines the requirements for an entry in an MkCopTree node.

MkCoPLeafEntry 
Represents an entry in a leaf node of a MkCoPTree.

MkCoPTree<O> 
MkCopTree is a metrical index structure based on the concepts of the MTree
supporting efficient processing of reverse k nearest neighbor queries for
parameter k < kmax.

MkCopTreeFactory<O> 
Factory for a MkCoPTreeTree

MkCoPTreeIndex<O> 
MkCoPTree used as database index.

MkCoPTreeNode<O> 
Represents a node in an MkCopTree.

MkMaxDirectoryEntry 
Represents an entry in a directory node of an MkMaxTree .

MkMaxEntry 

MkMaxLeafEntry 
Represents an entry in a leaf node of an MkMaxTree .

MkMaxTree<O> 
MkMaxTree is a metrical index structure based on the concepts of the MTree
supporting efficient processing of reverse k nearest neighbor queries for
parameter k <= k_max.

MkMaxTreeFactory<O> 
Factory for MkMaxTrees

MkMaxTreeIndex<O> 
MkMax tree

MkMaxTreeNode<O> 

MkTabDirectoryEntry 
Represents an entry in a directory node of a MkTabTree.

MkTabEntry 
Defines the requirements for an entry in an MkCopTree node.

MkTabLeafEntry 
Represents an entry in a leaf node of a MkTabTree.

MkTabTree<O> 
MkTabTree is a metrical index structure based on the concepts of the MTree
supporting efficient processing of reverse k nearest neighbor queries for
parameter k < kmax.

MkTabTreeFactory<O> 
Factory for MkTabTrees

MkTabTreeFactory.Par<O> 
Parameterization class.

MkTabTreeIndex<O> 
MkTabTree used as database index.

MkTabTreeNode<O> 
Represents a node in a MkMaxTree.

MkTreeHeader 

MkTreeRKNNQuery<O> 
Instance of a rKNN query for a particular spatial index.

MkTreeSettings<O,N extends AbstractMTreeNode<O,N,E>,E extends MTreeEntry> 
Class with settings for MkTrees.

MLBDistSplit<E extends MTreeEntry,N extends AbstractMTreeNode<?,N,E>> 
Encapsulates the required methods for a split of a node in an MTree.

MMRadSplit<E extends MTreeEntry,N extends AbstractMTreeNode<?,N,E>> 
Encapsulates the required methods for a split of a node in an MTree.

Model 
Base interface for Model classes.

Model 

ModelUtil 
Utility classes for dealing with cluster models.

ModifiableDBIDs 
Interface for a generic modifiable DBID collection.

ModifiableDoubleDBIDList 
Modifiable API for DistanceDBID results

ModifiableHierarchy<O> 
Modifiable Hierarchy.

ModifiableHyperBoundingBox 

ModifiableRelation<O> 
Relations that allow modification.

MOMDistributionEstimator<D extends Distribution> 
Distribution estimators that use the method of moments (MOM), i.e. that only
need the statistical moments of a data set.

MOMEstimator 
Methods of moments estimator, using the first moment (i.e. average).

MOMEstimator.Par 
Parameterization class.

MoveObjectsToolVisualization 
Tool to move the currently selected objects.

MoveObjectsToolVisualization.Instance 
Instance.

MRadSplit<E extends MTreeEntry,N extends AbstractMTreeNode<?,N,E>> 
Encapsulates the required methods for a split of a node in an MTree.

MSTSplit<E extends MTreeEntry,N extends AbstractMTreeNode<?,N,E>> 
Splitting algorithm using the minimum spanning tree (MST), as proposed by the
SlimTree variant.

MTree<O> 
MTree is a metrical index structure based on the concepts of the MTree.

MTreeDirectoryEntry 
Represents an entry in a directory node of an MTree.

MTreeEntry 
Defines the requirements for an entry in an MTree node.

MTreeFactory<O> 
Factory for a MTree

MTreeIndex<O> 
Class for using an mtree as database index.

MTreeInsert<E extends MTreeEntry,N extends AbstractMTreeNode<?,N,E>> 
Default insertion strategy for the Mtree.

MTreeKNNByDBID<O> 
Instance of a KNN query for a particular spatial index.

MTreeKNNByObject<O> 
Instance of a KNN query for a particular spatial index.

MTreeLeafEntry 
Represents an entry in a leaf node of an MTree.

MTreeNode<O> 
Represents a node in an MTree.

MTreeRangeByDBID<O> 
Instance of a range query for a particular spatial index.

MTreeRangeByObject<O> 
Instance of a range query for a particular spatial index.

MTreeSearchCandidate 
Encapsulates the attributes for a object that can be stored in a heap.

MTreeSettings<O,N extends AbstractMTreeNode<O,N,E>,E extends MTreeEntry> 
Class to store the MTree settings.

MTreeSplit<E extends MTreeEntry,N extends AbstractMTreeNode<?,N,E>> 
Interface for Mtree splitting strategies.

MultiBorder 
Multiple border point assignment.

MultidimensionalScalingMSTLayout3DPC 
Layout the axes by multidimensional scaling.

MultidimensionalScalingMSTLayout3DPC.Node 
Node class for this layout.

MultidimensionalScalingMSTLayout3DPC.Par 
Parameteriation class.

MultiLPNorm 
Tutorial example Minowskidistance variation with different exponents for
different dimensions for ELKI.

MultiLPNorm.Par 
Parameterization class example

MultipleFilesOutput 
Manage output to multiple files.

MultipleLinearRegression 
Multiple linear regression attempts to model the relationship between two or
more explanatory variables and a response variable by fitting a linear
equation to observed data.

MultipleObjectsBundle 
This class represents a set of "packaged" objects, which is a transfer
container for objects, e.g., from parsers to a database.

MultipleObjectsBundleDatabaseConnection 

MultipleProjectionsLocalitySensitiveHashFunction 
LSH hash function for vector space data.

MultiplicativeInverseScaling 
Scaling function to invert values by computing 1/x, but in a variation that
maps the values to the [0:1] interval and avoiding division by 0.

MultiStepGUI 
Experimenterstyle multi step GUI.

MultivariateGaussianModel 
Model for a single multivariate Gaussian cluster with arbitrary rotation.

MultivariateGaussianModelFactory 
Factory for EM with multivariate Gaussian models (with covariance; also known
as Gaussian Mixture Modeling, GMM).

MultivariateSeriesTypeInformation<V extends FeatureVector<?>> 
Type information for multivariate time series.

MultivariateTimeSeriesFilter<V extends FeatureVector<?>> 
Class to "fold" a flat number vector into a multivariate time series.

MutableProgress 
Progress class with a moving target.

MutualInformationEquiwidthDependence 
Mutual Information (MI) dependence measure by dividing each attribute into
equalwidth bins.

MutualInformationEquiwidthDependence.Par 
Parameterization class.

MWPTest 
Implementation of MannWhitney U test returning the pvalue (not the test
statistic, thus MWP) for MCDEDependence .

MWPTest.MWPRanking 
Structure to hold values needed for computing MWP in MCDEDependene.

MWPTest.Par 
Parameterizer, returning the static instance.

NaiveAgglomerativeHierarchicalClustering1<O> 
This tutorial will step you through implementing a well known clustering
algorithm, agglomerative hierarchical clustering, in multiple steps.

NaiveAgglomerativeHierarchicalClustering2<O> 
This tutorial will step you through implementing a well known clustering
algorithm, agglomerative hierarchical clustering, in multiple steps.

NaiveAgglomerativeHierarchicalClustering3<O> 
This tutorial will step you through implementing a well known clustering
algorithm, agglomerative hierarchical clustering, in multiple steps.

NaiveAgglomerativeHierarchicalClustering3.Linkage 
Different linkage strategies.

NaiveAgglomerativeHierarchicalClustering4<O> 
This tutorial will step you through implementing a well known clustering
algorithm, agglomerative hierarchical clustering, in multiple steps.

NaiveAgglomerativeHierarchicalClustering4.Linkage 
Different linkage strategies.

NaiveMeanShiftClustering<V extends NumberVector> 
Meanshift based clustering algorithm.

NaiveProjectedKNNPreprocessor<O extends NumberVector> 
Compute the approximate k nearest neighbors using 1 dimensional projections.

NaiveProjectedKNNPreprocessor.Factory<V extends NumberVector> 
Index factory class

NaiveProjectedKNNPreprocessor.Factory.Par 
Parameterization class.

NamingScheme 
Naming scheme implementation for clusterings.

NanoDuration 
Class that tracks the runtime of a task with System.nanoTime()

NDCGEvaluation 
Normalized Discounted Cumulative Gain.

NDCGEvaluation.Par 
Parameterization class.

NearestNeighborAffinityMatrixBuilder<O> 
Build sparse affinity matrix using the nearest neighbors only.

NearestNeighborAffinityMatrixBuilder.Par<O> 
Parameterization class.

NeighborPredicate<T> 
Get the neighbors of an object

NeighborPredicate.Instance<T> 
Instance for a particular data set.

NeighborSetPredicate 
Predicate to obtain the neighbors of a reference object as set.

NeighborSetPredicate.Factory<O> 
Factory interface to produce instances.

NNChain<O> 
NNchain clustering algorithm.

NNChain.Instance 
Main worker instance of NNChain.

NNDescent<O> 
NNdescent (also known as KNNGraph) is an approximate nearest neighbor search
algorithm beginning with a random sample, then iteratively refining this
sample until.

NNDescent.Factory<O> 
Index factory.

NoAutomaticEvaluation 
Nooperation evaluator, that only serves the purpose of explicitely disabling
the default value of AutomaticEvaluation , if you do not want
evaluation to run.

NoAutomaticEvaluation.Par 
Parameterization class

Node<E> 
This interface defines the common requirements of nodes in an index
structure.

NodeAppendChild 
Runnable wrapper for appending XMLElements to existing Elements.

NodeArrayAdapter 
Access the entries of a node as arraylike.

NodeReplaceAllChildren 
Runnable wrapper to replace all children of a given node.

NodeReplaceByID 
This helper class will replace a node in an SVG plot.

NodeSubstitute 
This helper class will replace a node in an SVG plot.

NoiseAsOutliers 
Noise as outliers, from a clustering algorithm.

NoiseAsOutliers.Par 
Parameterizer.

NoiseHandling 
Options for handling noise in internal measures.

NoMissingValuesFilter 
A filter to remove entries that have missing values.

NoMissingValuesFilter.Par 
Parameterization class.

NonFlatRStarTree<N extends AbstractRStarTreeNode<N,E>,E extends SpatialEntry,S extends RTreeSettings> 
Abstract superclass for all nonflat R*Tree variants.

NonNumericFeaturesException 
An exception to signal the encounter of non numeric features where numeric
features have been expected.

NoOpFilter 
Dummy filter that doesn't do any filtering.

Norm<O> 
Abstract interface for a mathematical norm.

NormalDistribution 
Gaussian distribution aka normal distribution

NormalDistribution.Par 
Parameterization class

Normalization<O> 
Normalization performs a normalization on a set of feature vectors and is
capable to transform a set of feature vectors to the original attribute
ranges.

NormalizedLevenshteinDistance 
Levenshtein distance on strings, normalized by string length.

NormalizedLevenshteinDistance.Par 
Parameterization class.

NormalizedPrimitiveSimilarity<O> 
Marker interface for similarity functions working on primitive objects, and
limited to the 01 value range.

NormalizedSimilarity<O> 
Marker interface to signal that the similarity function is normalized to
produce values in the range of [0:1].

NormalLevenbergMarquardtKDEEstimator 
Distribution parameter estimation using LevenbergMarquardt iterative
optimization and a kernel density estimation.

NormalLevenbergMarquardtKDEEstimator.Par 
Parameterization class.

NormalLMMEstimator 
Estimate the parameters of a normal distribution using the method of
LMoments (LMM).

NormalLMMEstimator.Par 
Parameterization class.

NormalMADEstimator 
Estimator using Medians.

NormalMADEstimator.Par 
Parameterization class.

NormalMOMEstimator 
Naive maximumlikelihood estimations for the normal distribution using mean
and sample variance.

NormalMOMEstimator.Par 
Parameterization class.

NoSupportedDataTypeException 
Exception thrown when no supported data type was found.

NotImplementedException 
Exception thrown when a particular code path was not yet implemented.

NullAlgorithm 
Null algorithm, which does nothing.

NumberArrayAdapter<N extends java.lang.Number,A> 
Adapter for arrays of numbers, to avoid boxing.

NumberParameter<P extends NumberParameter<P,T>,T extends java.lang.Number> 
Abstract class for defining a number parameter.

NumberVector 
Interface NumberVector defines the methods that should be implemented by any
Object that is element of a real vector space of type N.

NumberVector.Factory<V extends NumberVector> 
Factory API for this feature vector.

NumberVectorAdapter 
Adapter to use a feature vector as an array of features.

NumberVectorDistance<O> 
Base interface for the common case of distance functions defined on numerical
vectors.

NumberVectorFeatureSelectionFilter<V extends NumberVector> 
Parser to project the ParsingResult obtained by a suitable base parser onto a
selected subset of attributes.

NumberVectorFeatureSelectionFilter.Par 
Parameterization class.

NumberVectorLabelParser<V extends NumberVector> 
Parser for a simple CSV type of format, with columns separated by the given
pattern (default: whitespace).

NumberVectorLabelParser.Par<V extends NumberVector> 
Parameterization class.

NumberVectorRandomFeatureSelectionFilter<V extends NumberVector> 
Parser to project the ParsingResult obtained by a suitable base parser onto a
randomly selected subset of attributes.

NumberVectorRandomFeatureSelectionFilter.Par 
Parameterization class.

NumericalFeatureSelection<V extends NumberVector> 
Projection class for number vectors.

NumericalFeatureSelection.Par<V extends NumberVector> 
Parameterization class.

NuSolver 

NuSVC 

NuSVR 

ObjectBundle 
Abstract interface for object packages.

ObjectFilter 
Object filters as part of the input step.

ObjectHeap<K> 
Basic inmemory heap for Object values.

ObjectHeap.UnsortedIter<K> 
Unsorted iterator  in heap order.

ObjectListParameter<C> 
Parameter that represents a list of objects (in contrast to a class list
parameter, they will be instanced at most once.)

ObjectNotFoundException 
Exception thrown when the requested object was not found in the database.

ObjectParameter<C> 
Parameter class for a parameter representing a single object.

ObjHistogram<T> 
Histogram class storing double values.

ObjHistogram.BucketFactory<T> 
Function to make new buckets.

OCSVM<V> 
Outlierdetection using oneclass support vector machines.

OddsRatio 
Odds ratio interestingness measure.

ODIN<O> 
Outlier detection based on the indegree of the kNN graph.

ODIN<O> 
Outlier detection based on the indegree of the kNN graph.

OfflineChangePointDetectionAlgorithm 
Offline change point detection algorithm detecting a change in mean, based
on the cumulative sum (CUSUM), samevariance assumption, and using bootstrap
sampling for significance estimation.

OfflineChangePointDetectionAlgorithm.Par 
Parameterization class.

OnDiskArray 
On Disc Array storage for records of a given size.

OnDiskArrayPageFile<P extends Page> 
A OnDiskArrayPageFile stores objects persistently that implement the
Page interface.

OnDiskArrayPageFileFactory<P extends Page> 
Page file factory for diskbased page files.

OnDiskUpperTriangleMatrix 
Class representing an upper triangle matrix backed by an ondisk array of
O((n+1)*n/2) size

OneClassSVM 
Oneclass classification is similar to regression.

OnedimensionalDistance 
Distance function that computes the distance between feature vectors as the
absolute difference of their values in a specified dimension only.

OnedimensionalDistance.Par 
Parameterization class.

OneDimensionalDoubleVector 
Specialized class implementing a onedimensional double vector without using
an array.

OneDimensionalDoubleVector.Factory 
Factory class.

OneDimensionalDoubleVector.Factory.Par 
Parameterization class.

OneDimSortBulkSplit 
Simple bulk loading strategy by sorting the data along the first dimension.

OneDimSortBulkSplit.Par 
Parameterization class.

OneItemset 
Frequent itemset with one element.

OnlineLOF<O> 
Incremental version of the LOF Algorithm, supports insertions and
removals.

OnlineLOF.Par<O> 
Parameterization class.

OpenGL3DParallelCoordinates<O extends NumberVector> 
Simple JOGL2 based parallel coordinates visualization.

OpenGL3DParallelCoordinates.Instance<O extends NumberVector> 
Visualizer instance.

OpenGL3DParallelCoordinates.Instance.Shared<O> 
Shared data for visualization modules.

OpenGL3DParallelCoordinates.Instance.State 
States of the UI.

OpenGL3DParallelCoordinates.Settings<O> 
Class keeping the visualizer settings.

OPTICSClusterVisualization 
Visualize the clusters and cluster hierarchy found by OPTICS on the OPTICS
Plot.

OPTICSClusterVisualization.Instance 
Instance.

OPTICSCut 
Compute a partitioning from an OPTICS plot by doing a horizontal cut.

OPTICSHeap<O> 
The OPTICS algorithm for densitybased hierarchical clustering.

OPTICSHeap.Par<O> 
Parameterization class.

OPTICSHeapEntry 
Entry in the priority heap.

OPTICSList<O> 
The OPTICS algorithm for densitybased hierarchical clustering.

OPTICSList.Par<O> 
Parameterization class.

OPTICSModel 
Model for an OPTICS cluster

OPTICSOF<O> 
OPTICSOF outlier detection algorithm, an algorithm to find Local Outliers in
a database based on ideas from OPTICSTypeAlgorithm clustering.

OPTICSOF.Par<O> 
Parameterization class.

OPTICSPlot 
Class to produce an OPTICS plot image.

OPTICSPlotCutVisualization 
Visualizes a cut in an OPTICS Plot to select an Epsilon value and generate a
new clustering result.

OPTICSPlotCutVisualization.Instance 
Instance.

OPTICSPlotSelectionVisualization 
Handle the marker in an OPTICS plot.

OPTICSPlotSelectionVisualization.Instance 
Instance.

OPTICSPlotSelectionVisualization.Mode 
Input modes

OPTICSPlotVisualizer 
Visualize an OPTICS result by constructing an OPTICS plot for it.

OPTICSPlotVisualizer.Instance 
Instance.

OPTICSProjection 
OPTICS projection.

OPTICSProjector 
Projection for OPTICS plots.

OPTICSProjectorFactory 
Produce OPTICS plot projections

OPTICSSteepAreaVisualization 
Visualize the steep areas found in an OPTICS plot

OPTICSSteepAreaVisualization.Instance 
Instance

OPTICSToHierarchical 
Convert a OPTICS ClusterOrder to a hierarchical clustering.

OPTICSToHierarchical.Par 
Parameterization class

OPTICSTypeAlgorithm 
Interface for OPTICS type algorithms, that can be analyzed by OPTICS Xi etc.

OPTICSXi 
Extract clusters from OPTICS plots using the original ξ (Xi) extraction,
which defines steep areas if the reachability drops below 1ξ,
respectively increases to 1+ξ, of the current value, then constructs
valleys that begin with a steep down, and end with a matching steep up area.

OPTICSXi.ClusterHierarchyBuilder 
Class to build the hierarchical clustering result structure.

OPTICSXi.Par 
Parameterization class.

OPTICSXi.SteepArea 
Data structure to represent a steepdownarea for the xi method.

OPTICSXi.SteepAreaResult 
Result containing the xisteep areas.

OPTICSXi.SteepDownArea 
Data structure to represent a steepdownarea for the xi method.

OPTICSXi.SteepScanPosition 
Position when scanning for steep areas

OPTICSXi.SteepUpArea 
Data structure to represent a steepdownarea for the xi method.

OptionID 
An OptionID is used by option handlers as a unique identifier for specific
options.

OptionUtil 
Utility functions related to Option handling.

ORCLUS 
ORCLUS: Arbitrarily ORiented projected CLUSter generation.

ORCLUS.ORCLUSCluster 
Encapsulates the attributes of a cluster.

ORCLUS.Par 
Parameterization class.

ORCLUS.ProjectedEnergy 
Encapsulates the projected energy for a cluster.

OrderingFromRelation 
Ordering obtained from an outlier score.

OrderingResult 
Interface for a result providing an object ordering.

ORLibBenchmark 
Load an ORlib problem to evaluate kmedoids clustering quality.

ORLibBenchmark.Par<O> 
Parameterization class.

Ostrovsky 
Ostrovsky initial means, a variant of kmeans++ that is expected to give
slightly better results on average, but only works for kmeans and not for,
e.g., PAM (kmedoids).

Ostrovsky.Par 
Parameterization class.

OutlierAlgorithm 
Generic super interface for outlier detection algorithms.

OutlierGammaScaling 
Scaling that can map arbitrary values to a probability in the range of [0:1]
by assuming a Gamma distribution on the values.

OutlierGammaScaling.Par 
Parameterization class.

OutlierLinearScaling 
Scaling that can map arbitrary values to a value in the range of [0:1].

OutlierLinearScaling.Par 
Parameterization class.

OutlierMinusLogScaling 
Scaling function to invert values by computing log(x)

OutlierPrecisionAtKCurve 
Compute a curve containing the precision values for an outlier detection
method.

OutlierPrecisionAtKCurve.Par 
Parameterization class.

OutlierPrecisionAtKCurve.PrecisionAtKCurve 
Precision at K curve.

OutlierPrecisionRecallCurve 
Compute a curve containing the precision values for an outlier detection
method.

OutlierPrecisionRecallCurve.Par 
Parameterization class.

OutlierPrecisionRecallGainCurve 
Compute a curve containing the precision gain and revall gain values for an
outlier detection method.

OutlierPrecisionRecallGainCurve.Par 
Parameterization class.

OutlierRankingEvaluation 
Evaluate outlier scores by their ranking

OutlierRankingEvaluation.Par 
Parameterization class.

OutlierResult 
Wrap a typical Outlier result, keeping direct references to the main result
parts.

OutlierROCCurve 
Compute a ROC curve to evaluate a ranking algorithm and compute the
corresponding AUROC value.

OutlierROCCurve.Par 
Parameterization class.

OutlierScaling 
Interface for scaling functions used by Outlier evaluation such as Histograms
and visualization.

OutlierScoreAdapter 
This adapter can be used for an arbitrary collection of Integers, and uses
that id1.compareTo(id2) !

OutlierScoreMeta 
Generic meta information about the value range of an outlier score.

OutlierSmROCCurve 
Smooth ROC curves are a variation of classic ROC curves that takes the scores
into account.

OutlierSmROCCurve.Par 
Parameterization class.

OutlierSmROCCurve.SmROCResult 
Result object for Smooth ROC curves.

OutlierSqrtScaling 
Scaling that can map arbitrary positive values to a value in the range of
[0:1].

OutlierSqrtScaling.Par 
Parameterization class.

OutlierThresholdClustering 
Pseudo clustering algorithm that builds clusters based on their outlier
score.

OutlierThresholdClustering.Par 
Parameterization helper

OutputStep 
The "output" step, where data is analyzed.

OutputStep.Par 
Parameterization class.

OutputStreamLogger 

OutputTabPanel 
Panel to handle result output / visualization

OutRankS1 
OutRank: ranking outliers in high dimensional data.

OutRankS1.Par 
Parameterization class.

OUTRES 
Adaptive outlierness for subspace outlier ranking (OUTRES).

OUTRES.KernelDensityEstimator 
Kernel density estimation and utility class.

OUTRES.Par 
Parameterization class.

OverflowTreatment 
Reinsertion strategy to resolve overflows in the R*tree.

OverviewPlot 
Generate an overview plot for a set of visualizations.

P3C 
P3C: A Robust Projected Clustering Algorithm.

P3C.ClusterCandidate 
This class is used to represent potential clusters.

P3C.Par 
Parameterization class.

P3C.Signature 
P3C Cluster signature.

Page 
Defines the requirements for objects that can be stored in a cache and can be
persistently saved.

PagedIndexFactory<O> 
Abstract base class for treebased indexes.

PagedIndexFactory.Par<O> 
Parameterization class.

PageFile<P extends Page> 
Page file interface.

PageFileFactory<P extends Page> 
Factory interface for generating page files.

PageHeader 
Defines the requirements for a header of a persistent page file.

Pair<F,S> 
Simple class wrapping two objects.

PairCounting 
Paircounting measures, with support for "noise" clusters and selfpairing
support.

PairSetsIndex 
The Pair Sets Index calculates an index based on the maximum matching of
relative cluster sizes by the Hungarian algorithm.

PAM<O> 
The original Partitioning Around Medoids (PAM) algorithm or kmedoids
clustering, as proposed by Kaufman and Rousseeuw; a largely equivalent method
was also proposed by Whitaker in the operations research domain, and is well
known by the name "fast interchange" there.

PAM.Instance 
Instance for a single dataset.

PAM.Par<O> 
Parameterization class.

PAMMEDSIL<O> 
Clustering to optimize the Medoid Silhouette coefficient with a PAMbased
swap heuristic.

PAMMEDSIL.Instance 
Instance for a single dataset.

PAMMEDSIL.Par<O> 
Parameterization class.

PAMSIL<O> 
Clustering to optimize the Silhouette coefficient with a PAMbased swap
heuristic.

PAMSIL.Instance 
Instance for a single dataset.

PAMSIL.Par<O> 
Parameterization class.

Parallel3DRenderer<O extends NumberVector> 
Renderer for 3D parallel plots.

ParallelAxisVisualization 
Generates a SVGElement containing axes, including labeling.

ParallelCore 
Core for parallel processing in ELKI, based on ThreadPoolExecutor .

ParallelExecutor 
Class to run processors in parallel, on all available cores.

ParallelExecutor.BlockArrayRunner 
Run for an array part, without step size.

ParallelGeneralizedDBSCAN 
Parallel version of DBSCAN clustering.

ParallelGeneralizedDBSCAN.Instance<T> 
Instance for a particular data set.

ParallelGeneralizedDBSCAN.Par 
Parameterization class

ParallelKNNOutlier<O> 
Parallel implementation of KNN Outlier detection.

ParallelKNNWeightOutlier<O> 
Parallel implementation of KNN Weight Outlier detection.

ParallelLloydKMeans<V extends NumberVector> 
Parallel implementation of kMeans clustering.

ParallelLOF<O> 
Parallel implementation of Local Outlier Factor using processors.

ParallelPlotFactory 
Produce parallel axes projections.

ParallelPlotProjector<V extends SpatialComparable> 
ParallelPlotProjector is responsible for producing a parallel axes
visualization.

ParallelSimplifiedLOF<O> 
Parallel implementation of SimplifiedLOF Outlier detection using processors.

Parameter<T> 
Interface for the parameter of a class.

ParameterConfigurator 
Interface for different configuration assistants for the multistep GUI.

ParameterConstraint<T> 
Interface for specifying parameter constraints.

ParameterException 
Abstract super class for all exceptions thrown during parameterization.

Parameterization 
Interface for object parameterizations.

ParameterizationFunction 
A parameterization function describes all lines in a ddimensional feature
space intersecting in one point p.

ParameterizationFunction.ExtremumType 
Available types for the global extremum.

Parameterizer 
Generic interface for a parameterizable factory.

ParametersModel 

ParameterTable 
Class showing a table of ELKI parameters.

ParameterTable.DispatchingPanel 
This is a panel that will dispatch keystrokes to a particular component.

ParameterTabPanel 
Abstract panel, showing particular options.

ParameterTabPanel.Status 
Status code enumeration

ParkJun<O> 
Initialization method proposed by Park and Jun.

ParkJun.Par<V> 
Parameterization class.

ParseIntRanges 
Parse integer range syntaxes.

Parser 
A Parser shall provide a ParsingResult by parsing an InputStream.

ParseUtil 
Helper functionality for parsing.

ParseUtil.PreallocatedException 
Preallocated exception.

PartialDistance<O> 
Interface to maintain partial distance bounds.

PartialEuclideanDistance 
Partial distance computations for Euclidean distance.

PartialLPNormDistance 
Partial distance computations for Euclidean distance.

PartialManhattanDistance 
Partial distance computations for Euclidean distance.

PartialSquaredEuclideanDistance 
Partial distance computations for squared Euclidean distance.

PartialVAFile<V extends NumberVector> 
PartialVAFile.

PartialVAFile.Factory<V extends NumberVector> 
Index factory class.

PartialVAFile.Factory.Par 
Parameterization class.

PartialVAFile.PartialVACandidate 
Object in a VA approximation.

PartialVAFile.Statistics 
Class for tracking Partial VA file statistics.

PartialVAFile.WorstCaseDistComparator 
Compare DAfiles by their worst case distance.

PartitionApproximationMaterializeKNNPreprocessor<O> 
A preprocessor for annotation of the k nearest neighbors (and their
distances) to each database object.

PartitionApproximationMaterializeKNNPreprocessor.Factory<O> 
The parameterizable factory.

PartitionApproximationMaterializeKNNPreprocessor.Factory.Par<O> 
Parameterization class.

PassingDataToELKI 
Example program to generate a random data set, and run kmeans on it.

PatternParameter 
Parameter class for a parameter specifying a pattern.

PBMIndex 
Compute the PBM index of a clustering

PBMIndex.Par 
Parameterization class.

PCAFilteredResult 
Result class for a filtered PCA.

PCAResult 
Result class for Principal Component Analysis with some convenience methods

PCARunner 
Class to run PCA on given data.

PCARunner.Par 
Parameterization class.

PeanoSpatialSorter 
Bulkload an Rtree index by presorting the objects with their position on
the Peano curve.

PeanoSpatialSorter.Par 
Parameterization class.

PearsonCorrelation 
Class to compute the Pearson correlation coefficient (PCC) also known as
Pearson productmoment correlation coefficient (PPMCC).

PearsonCorrelationDependence 
Pearson productmoment correlation coefficient.

PearsonCorrelationDependence.Par 
Parameterization class

PearsonCorrelationDistance 
Pearson correlation distance function for feature vectors.

PearsonCorrelationDistance.Par 
Parameterization class.

PercentageEigenPairFilter 
The PercentageEigenPairFilter sorts the eigenpairs in descending order of
their eigenvalues and marks the first eigenpairs, whose sum of eigenvalues is
higher than the given percentage of the sum of all eigenvalues as strong
eigenpairs.

PercentageEigenPairFilter.Par 
Parameterization class.

PerplexityAffinityMatrixBuilder<O> 
Compute the affinity matrix for SNE and tSNE.

PerplexityAffinityMatrixBuilder.Par<O> 
Parameterization class.

PersistentPageFile<P extends ExternalizablePage> 
A PersistentPageFile stores objects persistently that implement the
Page interface.

PersistentPageFileFactory<P extends ExternalizablePage> 
Page file factory for diskbased page files.

PerturbationFilter<V extends NumberVector> 
A filter to perturb the values by adding micronoise.

PerturbationFilter.NoiseDistribution 
Nature of the noise distribution.

PerturbationFilter.Par<V extends NumberVector> 
Parameterization class.

PerturbationFilter.ScalingReference 
Scaling reference options.

PhiCorrelationCoefficient 
Phi Correlation Coefficient interestingness measure.

PINN<O extends NumberVector> 
ProjectionIndexed nearestneighbors (PINN) is an index to retrieve the
nearest neighbors in high dimensional spaces by using a random projection
based index.

PixmapResult 
Result encapsulating a single image.

PixmapVisualizer 
Visualize an arbitrary pixmap result.

PixmapVisualizer.Instance 
Instance.

PlotItem 
Item to collect visualization tasks on a specific position on the plot map.

PlotItem.ItmItr 
Recursive iterator

PoissonDistribution 
INCOMPLETE implementation of the poisson distribution.

PoissonDistribution.Par 
Parameterization class

Polygon 
Class representing a simple polygon.

PolygonsObject 
Object representation consisting of (multiple) polygons.

PolygonVisualization 
Renders PolygonsObject in the data set.

PolygonVisualization.Instance 
Instance

PolynomialApproximation 
Provides an polynomial approximation bo + b1*k + b2*k^2 + ... + bp*k^p
for knndistances consisting of parameters b0, ..., bp.

PolynomialKernel 
Polynomial Kernel function that computes a similarity between the two feature
vectors x and y defined by \((x^T\cdot y+b)^{\text{degree}}\).

PolynomialKernel.Par 
Parameterization class.

PolynomialRegression 
A polynomial fit is a specific type of multiple regression.

PrecisionAtKEvaluation 
Evaluate using Precision@k, or Rprecision (when k=0 ).

PrecisionAtKEvaluation.Par 
Parameterization class.

PrecomputedDistanceMatrix<O> 
Distance matrix, for precomputing similarity for a small data set.

PrecomputedDistanceMatrix.Factory<O> 
Factory for the index.

PrecomputeDistancesAsciiApplication<O> 
Application to precompute pairwise distances into an ascii file.

PrecomputeDistancesAsciiApplication.Par<O> 
Parameterization class.

PrecomputedKNearestNeighborNeighborhood 
Neighborhoods based on k nearest neighbors.

PrecomputedKNearestNeighborNeighborhood.Factory<O> 
Factory class to instantiate for a particular relation.

PrecomputedSimilarityMatrix<O> 
Precomputed similarity matrix, for a small data set.

PrecomputedSimilarityMatrix.Factory<O> 
Factory for the index.

PreDeCon 
PreDeCon computes clusters of subspace preference weighted connected points.

PreDeCon.Par 
Parameterization class.

PreDeCon.Settings 
Class containing all the PreDeCon settings.

PreDeCon.Settings.Par 
Parameterization class.

PreDeConCorePredicate 
The PreDeCon core point predicate  having at least minpts. neighbors, and a
maximum preference dimensionality of lambda.

PreDeConCorePredicate.Instance 
Instance for a particular data set.

PreDeConCorePredicate.Par 
Parameterization class

PreDeConNeighborPredicate 
Neighborhood predicate used by PreDeCon.

PreDeConNeighborPredicate.Instance 
Instance for a particular data set.

PreDeConNeighborPredicate.Par 
Parameterization class.

PreDeConNeighborPredicate.PreDeConModel 
Model used by PreDeCon for core point property.

Predefined 
Run kmeans with prespecified initial means.

Predefined.Par 
Parameterization class.

PreprocessorKNNQuery 
Use precomputed kNN.

PreprocessorRKNNQuery<O> 
Instance for a particular database, invoking the preprocessor.

PreprocessorSqrtKNNQuery 
Use the square rooted values of precomputed kNN.

PreprocessorSquaredKNNQuery 
Use the squared values of precomputed kNN.

PresortedBlindJoinDatabaseConnection 
Joins multiple data sources by their existing order.

PresortedBlindJoinDatabaseConnection.Par 
Parameterization class.

PrettyMarkers 
Marker library achieving a larger number of styles by combining different
shapes with different colors.

PRGCEvaluation 
Compute the area under the precisionrecallgain curve

PRGCEvaluation.Par 
Parameterization class.

PRGCEvaluation.PRGCurve 
PrecisionRecallGain curve.

Primes 
Class for prime number handling.

PrimitiveDistance<O> 
Primitive distance function that is defined on some kind of object.

PrimitiveDistanceQuery<O> 
Run a database query in a database context.

PrimitiveDistanceSimilarityQuery<O> 
Combination query class, for convenience.

PrimitiveSimilarity<O> 
Interface Similarity describes the requirements of any similarity
function.

PrimitiveSimilarityQuery<O> 
Run a database query in a database context.

PrimsMinimumSpanningTree 
Prim's algorithm for finding the minimum spanning tree.

PrimsMinimumSpanningTree.Adapter<T> 
Adapter interface to allow use with different data representations.

PrimsMinimumSpanningTree.Array2DAdapter 
Adapter for a simple 2d double matrix.

PrimsMinimumSpanningTree.Collector 
Interface for collecting edges.

Priority 
This annotation is used for sorting entries in the UIs.

PrioritySearchBenchmark<O> 
Benchmarking experiment that computes the k nearest neighbors for each query
point.

PrioritySearcher<O> 
Distance prioritybased searcher.

PriorProbabilityClassifier 
Classifier to classify instances based on the prior probability of classes in
the database, without using the actual data values.

ProbabilisticClassificationModel 

ProbabilisticOutlierScore 
Outlier score that is a probability value in the range 0.0  1.0
But the baseline may be different from 0.0!

ProbabilisticRegressionModel 

ProbabilityWeightedMoments 
Estimate the LMoments of a sample.

Processor 
Class to represent a processor factory.

Processor.Instance 
Instance.

PROCLUS 
The PROCLUS algorithm, an algorithm to find subspace clusters in high
dimensional spaces.

PROCLUS.DoubleIntInt 
Simple triple.

PROCLUS.Par 
Parameterization class.

PROCLUS.PROCLUSCluster 
Encapsulates the attributes of a cluster.

Progress 
Generic Progress logging interface.

ProgressiveEigenPairFilter 
The ProgressiveEigenPairFilter sorts the eigenpairs in descending order of
their eigenvalues and marks the first eigenpairs, whose sum of eigenvalues is
higher than the given percentage of the sum of all eigenvalues as strong
eigenpairs.

ProgressiveEigenPairFilter.Par 
Parameterization class.

ProgressLogRecord 
Log record for progress messages.

ProgressTracker 
Class to keep track of "alive" progresses.

ProjectedCentroid 
Centroid only using a subset of dimensions.

ProjectedIndex<O,I> 
Index data in an arbitrary projection.

ProjectedIndex.Factory<O,I> 
Index factory.

ProjectedView<IN,OUT> 
Projected relation view (nonmaterialized)

Projection<IN,OUT> 
Projection interface.

Projection 
Base interface used for projections in the ELKI visualizers.

Projection1D 
Interface for projections that have a specialization to only compute the
first component.

Projection2D 
Projections that have specialized methods to only compute the first two
dimensions of the projection.

ProjectionFilter<I,O> 
Apply a projection to the data.

ProjectionParallel 
Projection to parallel coordinates that allows reordering and inversion of
axes.

Projector 
A projector is responsible for adding projections to the visualization.

ProjectorFactory 
A projector is responsible for adding projections to the visualization by
detecting appropriate relations in the database.

PropertiesBasedStyleLibrary 
Style library loading the parameters from a properties file.

PrototypeDendrogramModel 
Hierarchical cluster, with prototype.

PrototypeModel<V> 
Cluster model that stores a prototype for each cluster.

ProxyDatabase 
A proxy database to use, e.g., for projections and partitions.

ProxyView<O> 
A virtual partitioning of the database.

PWM2Estimator 
Probability weighted moments based estimator, using the second moment.

PWM2Estimator.Par 
Parameterization class.

PWMEstimator 
Probability weighted moments based estimator.

PWMEstimator.Par 
Parameterization class.

QMatrix 
API to get kernel similarity values.

QRDecomposition 
QR Decomposition.

QuadraticStddevWeight 
Quadratic weight function, scaled using the standard deviation:
\( \max\{0.0, 1.0  \frac{\text{dist}^2}{3\sigma^2} \} \).

QuadraticWeight 
Quadratic weight function, scaled using the maximum to reach 0.1 at that
point using: \( 1.0  0.9 \frac{\text{dist}^2}{\max^2}\} \)

QueryBuilder<O> 
Class to build a query.

QueryOptimizer 
Interface to automatically add indexes to a database when no suitable indexes
have been found.

QuickSelect 
QuickSelect computes ("selects") the element at a given rank and can be used
to compute Medians and arbitrary quantiles by computing the appropriate rank.

QuickSelect.Adapter<T> 
Adapter class to apply QuickSelect to arbitrary data structures.

QuickSelectDBIDs 
QuickSelect computes ("selects") the element at a given rank and can be used
to compute Medians and arbitrary quantiles by computing the appropriate rank.

QuotientOutlierScoreMeta 
Score for outlier values generated by a quotient.

R2_Qq 
Q matrix used by SVDD

R2q 
R2q variant

RABIDEstimator 
Raw angle based intrinsic dimensionality (RABID) estimator.

RABIDEstimator.Par 
Parameterization class.

RadialBasisFunctionKernel 
Gaussian radial basis function kernel (RBF Kernel).

RadialBasisFunctionKernel.Par 
Parameterization class.

RadiusCriterion 
Average Radius (R) criterion.

RadiusCriterion.Par 
Parameterization class

RadiusDistance 
Average Radius (R) criterion.

RadiusDistance.Par 
Parameterization class

RandomDoubleVectorDatabaseConnection 
Produce a database of random double vectors with each dimension in [0:1].

RandomDoubleVectorDatabaseConnection.Par 
Parameterization class.

RandomFactory 
RandomFactory is responsible for creating Random generator objects.

RandomGeneratedReferencePoints 
Reference points generated randomly within the used data space.

RandomGeneratedReferencePoints.Par 
Parameterization class.

RandomizedCrossValidation 
RandomizedCrossValidation provides a set of partitions of a database
to perform crossvalidation.

RandomizedCrossValidation.Par 
Parameterization class

RandomizedHoldout 
A holdout providing a seed for randomized operations.

RandomizedHoldout.Par 
Parameterization class

RandomlyChosen<O> 
Initialize Kmeans by randomly choosing k existing elements as initial
cluster centers.

RandomlyChosen.Par<V> 
Parameterization class.

RandomNormalGenerated 
Initialize kmeans by generating random vectors (normal distributed
with \(N(\mu,\sigma)\) in each dimension).

RandomNormalGenerated.Par 
Parameterization class.

RandomParameter 
Parameter for random generators and/or random seeds.

RandomProjectedNeighborsAndDensities 
Random Projections used for computing neighbors and density estimates.

RandomProjectedNeighborsAndDensities.Par 
Parameterization class.

RandomProjection<V extends NumberVector> 
Randomized projections of the data.

RandomProjection.Par 
Parameterization class.

RandomProjectionFamily 
Interface for random projection families.

RandomProjectionFamily.Projection 
Interface for projection instances (not thread safe).

RandomSampleKNNPreprocessor<O> 
Class that computed the kNN only on a random sample.

RandomSampleKNNPreprocessor.Factory<O> 
The parameterizable factory.

RandomSampleReferencePoints 
RandomSampling strategy for picking reference points.

RandomSampleReferencePoints.Par 
Parameterization class.

RandomSamplingStreamFilter 
Subsampling stream filter.

RandomSamplingStreamFilter.Par 
Parameterization class

RandomSplit<E extends MTreeEntry,N extends AbstractMTreeNode<?,N,E>> 
Encapsulates the required methods for a split of a node in an MTree.

RandomStableDistance 
This is a dummy distance providing random values (obviously not metrical),
useful mostly for unit tests and baseline evaluations: obviously this
distance provides no benefit whatsoever.

RandomStableDistance.Par 
Parameterization class.

RandomSubsetProjectionFamily 
Random projection family based on selecting random features.

RandomSubsetProjectionFamily.Par 
Parameterization class.

RandomSubsetProjectionFamily.SubsetProjection 
Random subset projection.

RandomUniformGenerated 
Initialize kmeans by generating random vectors (uniform, within the value
range of the data set).

RandomUniformGenerated.Par 
Parameterization class.

RangeIndex<O> 
Index with support for range queries (radius queries).

RangeQueryBenchmark<O extends NumberVector> 
Benchmarking algorithm that computes a range query for each point.

RangeQuerySelectivity<V extends NumberVector> 
Evaluate the range query selectivity.

RangeSearcher<O> 
The interface for range queries, that can return all objects within the
specified radius.

RangeSelection 
Class representing selected DatabaseIDs and/or a selection range.

RankingPseudoOutlierScaling 
This is a pseudo outlier scoring obtained by only considering the ranks of
the objects.

RankingQualityHistogram<O> 
Evaluate a distance function with respect to kNN queries.

RANSACCovarianceMatrixBuilder 
RANSAC based approach to a more robust covariance matrix computation.

RANSACCovarianceMatrixBuilder.Par 
Parameterization class

RationalQuadraticKernel 

RationalQuadraticKernel.Par 
Parameterization class.

RayleighDistribution 
Rayleigh distribution, a special case of the Weibull distribution.

RayleighDistribution.Par 
Parameterization class

RayleighLMMEstimator 
Estimate the scale parameter of a (nonshifted) RayleighDistribution using
the method of LMoments (LMM).

RayleighLMMEstimator.Par 
Parameterization class.

RayleighMADEstimator 
Estimate the parameters of a RayleighDistribution using the MAD.

RayleighMADEstimator.Par 
Parameterization class.

RayleighMLEEstimator 
Estimate the scale parameter of a (nonshifted) RayleighDistribution using a
maximum likelihood estimate.

RayleighMLEEstimator.Par 
Parameterization class.

RdKNNDirectoryEntry 
Represents an entry in a directory node of an RdKNNTree.

RdKNNEntry 
Defines the requirements for an entry in an RdKNNTree node.

RdKNNLeafEntry 
Represents an entry in a leaf node of an RdKNNTree.

RdKNNNode 
Represents a node in a RDkNNTree.

RdkNNSettings 
Settings for the RdKNN Tree.

RdKNNTree<O extends NumberVector> 
RDkNNTree is a spatial index structure based on the concepts of the R*Tree
supporting efficient processing of reverse k nearest neighbor queries.

RdKNNTreeFactory<O extends NumberVector> 
Factory for RdKNN R*Trees.

RdKNNTreeFactory.Par<O extends NumberVector> 
Parameterization class.

RdKNNTreeHeader 
Encapsulates the header information of a RDkNNTree.

RecordStore 
Represents a storage which stores multiple values per object in a record fashion.

RectangleArranger<T> 
This is a rather naive rectangle arrangement class.

Reference 
Annotation to specify a reference.

ReferenceBasedOutlierDetection 
ReferenceBased Outlier Detection algorithm, an algorithm that computes kNN
distances approximately, using reference points.

ReferenceBasedOutlierDetection.Par 
Parameterization class.

ReferenceClustering<M extends Model> 
Reference clustering.

ReferencePointsHeuristic 
Simple Interface for an heuristic to pick reference points.

ReferencePointsResult<O> 
Result used in passing the reference points to the visualizers.

ReferencePointsVisualization 
The actual visualization instance, for a single projection

ReferencePointsVisualization.Instance 
Instance.

References 
Container annotation to store multiple Reference annotations.

RegressionModel 

ReinsertStrategy 
Reinsertion strategy to resolve overflows in the RStarTree.

Relation<O> 
An object representation from a database.

RelationUtil 
Utility functions for handling database relation.

RelationUtil.AscendingByDoubleRelation 
Sort objects by a double relation

RelationUtil.CollectionFromRelation<O> 
Collection view on a database that retrieves the objects when needed.

RelationUtil.DescendingByDoubleRelation 
Sort objects by a double relation

RelationUtil.RelationObjectIterator<O> 
Iterator class that retrieves the given objects from the database.

RelativeEigenPairFilter 
The RelativeEigenPairFilter sorts the eigenpairs in descending order of their
eigenvalues and marks the first eigenpairs who are a certain factor above the
average of the remaining eigenvalues.

RelativeEigenPairFilter.Par 
Parameterization class.

RemoveCSSClass 
Remove a CSS class to the event target.

ReplaceNaNWithRandomFilter 
A filter to replace all NaN values with random values.

ReplaceNaNWithRandomFilter.Par 
Parameterization class.

RepresentativeUncertainClustering 
Representative clustering of uncertain data.

RepresentativeUncertainClustering.Par 
Parameterization class.

RepresentativeUncertainClustering.RepresentativenessEvaluation 
Representativeness evaluation result.

RescaleMetaOutlierAlgorithm 
Scale another outlier score using the given scaling function.

RescaleMetaOutlierAlgorithm.Par 
Parameterization class

Restricted 
Indicator that the given class has distibution restrictions such as
associated patents, and therefore must not be included in the release.

ResultHandler 
Interface for any class that can handle results

ResultListener 
Listener interface invoked when new results are added to the result tree.

ResultProcessor 
Interface for any class that can handle results.

ResultUtil 
Utilities for handling result objects

ResultWindow 
Swing window to manage a particular result visualization.

ResultWindow.TextWriterPanel 
Simple configuration panel for the text output.

ResultWriter 
Result handler that feeds the data into a TextWriter.

ResultWriter.Par 
Parameterization class.

ReynoldsPAM<O> 
The Partitioning Around Medoids (PAM) algorithm with some additional
optimizations proposed by Reynolds et al.

ReynoldsPAM.Instance 
Instance for a single dataset.

ReynoldsPAM.Par<V> 
Parameterization class.

RGBHistogramQuadraticDistance 
Distance function for RGB color histograms based on a quadratic form and
color similarity.

RGBHistogramQuadraticDistance.Par 
Parameterization class.

RKNNIndex<O> 
Index with support for kNN queries.

RKNNSearcher<O> 
Abstract reverse kNN Query interface.

ROCEvaluation 
Compute ROC (Receiver Operating Characteristics) curves.

ROCEvaluation.Par 
Parameterization class.

ROCEvaluation.ROCurve 
ROC Curve

RStarTree 
RStarTree is a spatial index structure based on the concepts of the R*Tree.

RStarTreeDistancePrioritySearcher<O extends SpatialComparable> 
Instance of priority search for a particular spatial index.

RStarTreeFactory<O extends NumberVector> 
Factory for regular R*Trees.

RStarTreeIndex<O extends NumberVector> 
The common use of the rstar tree: indexing number vectors.

RStarTreeKNNSearcher<O extends SpatialComparable> 
Instance of a KNN query for a particular spatial index.

RStarTreeNode 
Represents a node in an R*Tree.

RStarTreeRangeSearcher<O extends SpatialComparable> 
Instance of a range query for a particular spatial index.

RStarTreeUtil 
Utility class for RStar trees.

RTreeLinearSplit 
Lineartime complexity greedy split as used by the original RTree.

RTreeLinearSplit.Par 
Parameterization class.

RTreeParallelVisualization 
Visualize the of an RTree based index.

RTreeParallelVisualization.Par 
Parameterization class.

RTreeQuadraticSplit 
Quadratictime complexity greedy split as used by the original RTree.

RTreeQuadraticSplit.Par 
Parameterization class.

RTreeSettings 
Class to wrap common Rtree settings.

RVEstimator 
Regularly Varying Functions estimator of the intrinsic dimensionality

RVEstimator.Par 
Parameterization class.

SameSizeKMeans<V extends NumberVector> 
Kmeans variation that produces equally sized clusters.

SameSizeKMeans.Meta 
Object metadata.

SameSizeKMeans.Par<V extends NumberVector> 
Parameterization class.

SameSizeKMeans.PreferenceComparator 
Sort a list of integers (= cluster numbers) by the distances.

SampleKMeans<V extends NumberVector> 
Initialize kmeans by running kmeans on a sample of the data set only.

SamplingResult 
Wrapper for storing the current database sample.

SavedSettingsFile 
Class to manage saved settings in a text file.

SavedSettingsTabPanel 
Tab panel to manage saved settings.

SaveOptionsPanel 
A component (JPanel) which can be displayed in the save dialog to show
additional options when saving as JPEG or PNG.

Scales 
Scales helper class.

ScalesResult 
Class to keep shared scales across visualizers.

ScalingFunction 
Interface for scaling functions used, e.g., by outlier evaluation such as
Histograms and visualization.

ScatterPlotFactory 
Produce scatterplot projections.

ScatterPlotFactory.Par 
Parameterization class.

ScatterPlotProjector<V extends SpatialComparable> 
ScatterPlotProjector is responsible for producing a set of scatterplot
visualizations.

ScoreEvaluation 
Compute ranking/scoring based evaluation measures.

ScoreEvaluation.Adapter 
Predicate to test whether an object is a true positive or false positive.

SebagSchonauer 
Sebag Schonauer interestingness measure.

Segment 
A segment represents a set of pairs that share the same clustering
properties.

Segments 
Creates segments of two or more clusterings.

SegmentsStylingPolicy 
Styling policy to communicate the segment selection to other visualizers.

SelectionAxisRangeVisualization 
Visualizer for generating an SVGElement representing the selected range.

SelectionConvexHullVisualization 
Visualizer for generating an SVGElement containing the convex hull of the
selected points

SelectionConvexHullVisualization.Instance 
Instance

SelectionCubeVisualization 
Visualizer for generating an SVGElement containing a cube as marker
representing the selected range for each dimension

SelectionCubeVisualization.Par 
Parameterization class.

SelectionDotVisualization 
Visualizer for generating an SVGElement containing dots as markers
representing the selected Database's objects.

SelectionDotVisualization.Instance 
Instance

SelectionLineVisualization 
Visualizer for generating SVGElements representing the selected objects

SelectionResult 
Selection result wrapper.

SelectionTableWindow 
Visualizes selected Objects in a JTable, objects can be selected, changed and
deleted

SelectionToolAxisRangeVisualization 
ToolVisualization for the tool to select axis ranges

SelectionToolCubeVisualization 
ToolVisualization for the tool to select ranges.

SelectionToolCubeVisualization.Instance 
Instance.

SelectionToolDotVisualization 
ToolVisualization for the tool to select objects

SelectionToolDotVisualization.Instance 
Instance

SelectionToolDotVisualization.Mode 
Input modes

SelectionToolLineVisualization 
ToolVisualization for the tool to select objects

SelectionToolLineVisualization.Mode 
Input modes

SerializedParameterization 
Manage a parameterization serialized as String array, e.g., from command
line.

SetDBIDs 
Interface for DBIDs that support fast "set" operations, in particular
"contains" lookups.

SetMatchingPurity 
Set matching purity measures.

SettingsResult 
Result that keeps track of settings that were used in generating this
particular result.

SettingsResult.SettingInformation 
Settings information.

SettingsVisualization 
PseudoVisualizer, that lists the settings of the algorithm

ShallotKMeans<V extends NumberVector> 
Borgelt's Shallot kmeans algorithm, exploiting the triangle inequality.

ShallotKMeans.Instance 
Inner instance, storing state for a single data set.

ShallotKMeans.Par<V extends NumberVector> 
Parameterization class.

SharedDouble 
Direct channel connecting two processors.

SharedDouble.Instance 
Instance for a subchannel.

SharedInteger 
Direct channel connecting two processors.

SharedInteger.Instance 
Instance for a subchannel.

SharedNearestNeighborIndex<O> 
Interface for an index providing nearest neighbor sets.

SharedNearestNeighborIndex.Factory<O> 
Factory interface

SharedNearestNeighborJaccardDistance<O> 
SharedNearestNeighborJaccardDistance computes the Jaccard
coefficient, which is a proper distance metric.

SharedNearestNeighborJaccardDistance.Instance<T> 
Actual instance for a dataset.

SharedNearestNeighborJaccardDistance.Par<O> 
Parameterization class.

SharedNearestNeighborPreprocessor<O> 
A preprocessor for annotation of the ids of nearest neighbors to each
database object.

SharedNearestNeighborPreprocessor.Factory<O> 
Factory class

SharedNearestNeighborPreprocessor.Factory.Par<O> 
Parameterization class.

SharedNearestNeighborSimilarity<O> 
SharedNearestNeighborSimilarity with a pattern defined to accept
Strings that define a nonnegative Integer.

SharedNearestNeighborSimilarity.Instance<O> 
Instance for a particular database.

SharedObject<T> 
Variable to share between different processors (within one thread only!)

SharedObject.Instance<T> 
Instance for a particular thread.

SharedVariable<I extends SharedVariable.Instance<?>> 
Shared variables storing a particular type.

SharedVariable.Instance<T> 
Instance for a single execution thread.

ShortVector 
Vector type using short[] storage.

ShortVector.Factory 
Factory for Short vectors.

ShortVector.Factory.Par 
Parameterization class.

ShortVector.ShortSerializer 
Serialization class for dense Short vectors with up to
Short.MAX_VALUE dimensions, by using a short for storing the
dimensionality.

ShortVector.VariableSerializer 
Serialization class for variable dimensionality by using VarInt encoding.

ShuffleObjectsFilter 
A filter to shuffle the dataset.

ShuffleObjectsFilter.Par 
Parameterization class.

SigmoidKernel 
Sigmoid kernel function (aka: hyperbolic tangent kernel, multilayer
perceptron MLP kernel).

SigmoidKernel.Par 
Parameterization class.

SigmoidOutlierScaling 
Tries to fit a sigmoid to the outlier scores and use it to convert the values
to probability estimates in the range of 0.0 to 1.0

SignificantEigenPairFilter 
The SignificantEigenPairFilter sorts the eigenpairs in descending order of
their eigenvalues and chooses the contrast of an Eigenvalue to the remaining
Eigenvalues is maximal.

SignificantEigenPairFilter.Par 
Parameterization class.

SigniTrendChangeDetection 
SigniTrend detection algorithm applies to a single timeseries.

SigniTrendChangeDetection.Par 
Parameterization class.

Silhouette<O> 
Compute the silhouette of a data set.

Silhouette.Par<O> 
Parameterization class.

SilhouetteOutlierDetection<O> 
Outlier detection by using the Silhouette Coefficients.

SilhouettePlot 
Class to produce an Silhouette plot image.

SilhouettePlotFactory 
Produce Silhouette plot projections

SilhouettePlotProjector 
Projection for Silhouette plots.

SilhouettePlotSelectionToolVisualization 
Handle the events to select elements in a Silhouette Plot.

SilhouettePlotSelectionToolVisualization.Instance 
Instance.

SilhouettePlotSelectionToolVisualization.Mode 
Input modes

SilhouettePlotSelectionVisualization 
Visualize the selection in a Silhouette Plot.

SilhouettePlotSelectionVisualization.Instance 
Instance.

SilhouettePlotVisualizer 
Visualize a Silhouette result by constructing a Silhouette plot for it.

SilhouettePlotVisualizer.Instance 
Instance.

SilhouetteProjection 
Silhouette projection.

Similarity<O> 
Interface Similarity describes the requirements of any similarity
function.

SimilarityBasedInitializationWithMedian<O> 
Similarity based initialization.

SimilarityBasedLayouter3DPC 
Similarity based layouting algorithms.

SimilarityIndex<O> 
Index with support for similarity queries
(e.g., precomputed similarity matrixes, caches)

SimilarityMatrixVisualizer 
Visualize a similarity matrix with object labels

SimilarityMatrixVisualizer.Instance 
Instance

SimilarityNeighborPredicate<O> 
The DBSCAN neighbor predicate for a Similarity , using all
neighbors with a minimum similarity.

SimilarityNeighborPredicate.Instance 
Instance for a particular data set.

SimilarityQuery<O> 
A similarity query serves as adapter layer for database and primitive
similarity functions.

SimilarityQueryAdapter 
Use a relation as data set

SimilarityRangeIndex<O> 
Index with support for similarity range queries.

Simple1D 
Dimensionselecting 1D projection.

Simple1DOFCamera 
Class for a simple camera.

Simple1DOFCamera.CameraListener 