All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
| Class |
Description |
| ABIDEstimator |
Angle based intrinsic dimensionality (ABID) estimator.
|
| ABIDEstimator.Par |
Parameterization class.
|
| ABOD<V extends NumberVector> |
Angle-Based Outlier Detection / Angle-Based 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 sparse-grid-cell 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 k-means 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 distance-based tasks and experiments.
|
| AbstractDistanceBasedSpatialOutlier<N,O> |
Abstract base class for distance-based 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 |
One-dimensional 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 k-means implementations.
|
| AbstractKMeans.Instance |
Inner instance for a run, for better encapsulation, that encapsulates the
standard flow of most (but not all) k-means variations.
|
| AbstractKMeans.Par<V extends NumberVector> |
Parameterization class.
|
| AbstractKMeansInitialization |
Abstract base class for common k-means 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 lower-triangular similarity matrix for distance-based 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 M-Tree variants supporting processing of reverse
k-nearest neighbor queries by using the k-nn 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 M-Tree variants supporting processing of reverse
k-nearest neighbor queries by using the k-nn 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 Mk-Trees
|
| 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 M-Tree 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 M-Tree variants.
|
| AbstractMTreeSplit<E extends MTreeEntry,N extends AbstractMTreeNode<?,N,E>> |
Abstract super class for splitting a node in an M-Tree.
|
| 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 density-based 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
(in-memory and on-disk).
|
| 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 Filter-refinement 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 UncertainObjects, 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 double-valued 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 non-rectangular 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(Y|X)-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 |
AFK-MC² initialization
|
| AFKMC2.Instance |
Abstract instance implementing the weight handling.
|
| AFKMC2.Par |
Parameterization class.
|
| AggarwalYuEvolutionary |
Evolutionary variant (EAFOD) of the high-dimensional outlier detection
algorithm by Aggarwal and Yu.
|
| AggarwalYuEvolutionary.Individuum |
Individuum for the evolutionary search.
|
| AggarwalYuEvolutionary.Par |
Parameterization class.
|
| AggarwalYuNaive |
BruteForce variant of the high-dimensional 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 alpha-shape of a point set, using Delaunay triangulation.
|
| AlternateRefinement<O> |
Meta-Initialization for k-medoids by performing one (or many) k-means-style
iteration.
|
| AlternateRefinement.Par<O> |
Parameterization class.
|
| AlternatingKMedoids<O> |
A k-medoids clustering algorithm, implemented as EM-style 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 nearest-neighbor heuristic for acceleration.
|
| Anderberg.Instance |
Main worker instance of Anderberg's algorithm.
|
| AndersonDarlingTest |
Perform Anderson-Darling test for a Gaussian distribution.
|
| AngTanLinearSplit |
Line-time complexity split proposed by Ang and Tan.
|
| AngTanLinearSplit.Par |
Parameterization class.
|
| AnnulusKMeans<V extends NumberVector> |
Annulus k-means 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 knn-distances 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 array-like 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 plug-in use of various "array-like" 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 |
Array-oriented 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 thread-safe counter.
|
| AttributeModifier |
Runnable wrapper for modifying XML-Attributes.
|
| 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 precision-recall curve (AUPRC).
|
| AUPRCEvaluation.Par |
Parameterization class.
|
| AUPRCEvaluation.PRCurve |
ROC Curve
|
| AutomaticEvaluation |
Evaluator that tries to auto-run a number of evaluation methods.
|
| AutomaticEvaluation.Par |
Parameterization class
|
| AutomaticVisualization |
Handler to process and visualize a Result.
|
| AutomaticVisualization.Par |
Parameterization class.
|
| AutotuningPCA |
Performs a self-tuning 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 SVG-Elements for reordering the axes.
|
| AxisVisibilityVisualization |
Layer for controlling axis visbility in parallel coordinates.
|
| AxisVisualization |
Generates a SVG-Element containing axes, including labeling.
|
| AxisVisualization.Instance |
Instance.
|
| BalancedDistribution |
Balanced entry distribution strategy of the M-tree.
|
| BarnesHutTSNE<O> |
t-SNE using Barnes-Hut-Approximation.
|
| BarnesHutTSNE.QuadTree |
Quad Tree for use in a Barnes-Hut 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 k-means results.
|
| BayesianInformationCriterionXMeans |
Bayesian Information Criterion (BIC), also known as Schwarz criterion (SBC,
SBIC) for the use with evaluating k-means 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 K-Means 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 (EM-Algorithm), also known as Gaussian
Mixture Modeling (GMM), with optional MAP regularization.
|
| BetulaGMM.Par |
Parameterizer
|
| BetulaGMMWeighted |
Clustering by expectation maximization (EM-Algorithm), also known as Gaussian
Mixture Modeling (GMM), with optional MAP regularization.
|
| BetulaGMMWeighted.Par |
Parameterizer
|
| BetulaLeafPreClustering |
BETULA-based clustering algorithm that simply treats the leafs of the CFTree
as clusters.
|
| BetulaLeafPreClustering.Par |
Parameterization class.
|
| BetulaLloydKMeans |
BIRCH/BETULA-based 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 |
K-Means++-like initialization for BIRCH k-means; this cannot be used to
initialize regular k-means, use KMeansPlusPlus instead. |
| BIRCHKMeansPlusPlus.Par |
Parameterization class.
|
| BIRCHLeafClustering |
BIRCH-based clustering algorithm that simply treats the leafs of the CFTree
as clusters.
|
| BIRCHLeafClustering.Par |
Parameterization class.
|
| BIRCHLloydKMeans |
BIRCH-based 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 k-means 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 |
Bray-Curtis 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 SVG-Element 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 k-means (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
"all-in-one" 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 on-disk 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 on-disk 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 pre-clustering 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 (1-stable).
|
| CauchyRandomProjectionFamily.Par |
Parameterization class.
|
| CBLOF<O extends NumberVector> |
Cluster-based local outlier factor (CBLOF).
|
| CenterOfMassMetaClustering<C extends Clustering<?>> |
Center-of-mass meta clustering reduces uncertain objects to their center of
mass, then runs a vector-oriented 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 Pair-Group 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 k-means initialization with BETULA.
|
| CFKPlusPlusLeaves |
K-Means++-like initialization for BETULA k-means, treating the leaf
clustering features as a flat list, and called "leaves" in the publication.
|
| CFKPlusPlusLeaves.Par |
Parameterization class.
|
| CFKPlusPlusTree |
Initialize K-means by following tree paths weighted by their variance
contribution.
|
| CFKPlusPlusTree.Par |
Parameterization class.
|
| CFKPlusPlusTrunk |
Trunk strategy for initializing k-means with BETULA: only the nodes up to a
particular level are considered for k-means++ style initialization.
|
| CFKPlusPlusTrunk.Par |
Parameterization class.
|
| CFNode<L extends ClusterFeature> |
Interface for TreeNode
|
| CFRandomlyChosen |
Initialize K-means 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
density-based clustering method similar to mean-shift 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 |
CF-Tree Factory.
|
| CFTree.Factory<L extends ClusterFeature> |
CF-Tree 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 K-means 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 |
Chi-Squared distribution (a specialization of the Gamma distribution).
|
| ChiSquaredDistribution.Par |
Parameterization class
|
| CholeskyDecomposition |
Cholesky Decomposition.
|
| CIndex<O> |
Compute the C-index 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 k-means on the centers of each uncertain object.
|
| CKMeans.Par |
Parameterization class, based on k-means.
|
| 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 grid-based 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 in-memory 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 Fowlkes-Mallows 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 KMeans-Clustering
|
| 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 SVG-Element 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 SVG-Element 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 KMeans-Clustering 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> |
Connectivity-based Outlier Factor (COF).
|
| CollectionResult<O> |
Simple 'collection' type of result.
|
| ColoredHistogramVisualizer |
Generates a SVG-Element 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> |
Compare-Means: Accelerated k-means 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 |
Complete-linkage ("maximum linkage") clustering method.
|
| CompleteLinkage.Par |
Class parameterizer.
|
| ComputeKNNOutlierScores<O extends NumberVector> |
Application that runs a series of kNN-based 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(Y|X) \).
|
| 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 correlation-based 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 (in-memory).
|
| 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 (C-SVC, C-SVM).
|
| CSVReaderFormat |
Basic format factory for parsing CSV-like formats.
|
| CSVReaderFormat.Par |
Parameterization class.
|
| CTLuGLSBackwardSearchAlgorithm<V extends NumberVector> |
GLS-Backward 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> |
Scatterplot-outlier 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 one-dimensional 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 Database-related 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 Davies-Bouldin index of a data set.
|
| DaviesBouldinIndex.Par |
Parameterization class.
|
| DBCV<O> |
Compute the Density-Based 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 |
DBID-valued 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 Database-IDs 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 |
Pseudo-representation 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> |
Density-Based Clustering of Applications with Noise (DBSCAN), an algorithm to
find density-connected 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: Density-Based 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 DeLiClu-Tree node.
|
| DeLiCluEntry |
Defines the requirements for an entry in an DeLiClu-Tree node.
|
| DeLiCluLeafEntry |
Defines the requirements for a leaf entry in an DeLiClu-Tree node.
|
| DeLiCluNode |
Represents a node in a DeLiClu-Tree.
|
| DeLiCluTree |
DeLiCluTree is a spatial index structure based on an R-Tree.
|
| 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 kernel-density
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 cross-validation.
|
| 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 |
Distance-based 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 SVG-Element 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 priority-based 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 |
M-tree 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 |
Double-valued 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 in-memory 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 in-memory 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 in-memory 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 sub-channel / part of the data set.
|
| DoubleObjectHeap<V> |
Basic in-memory 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 double-valued relations.
|
| DoubleRelation.Consumer |
Consumer for (DBIDRef, double) pairs.
|
| DoubleStatistic |
Trivial double-valued 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 dynamic-window 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 depth-first 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 k-means 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 inspection-related utility functions.
|
| ELKIServiceScanner.DirClassIterator |
Class to iterate over a directory tree.
|
| EM<O,M extends MeanModel> |
Clustering by expectation maximization (EM-Algorithm), 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 SVG-Elements 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(1-s_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
epsilon-neighborhood.
|
| 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 |
2-stable 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 k-means 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 k-Means algorithm based on Hamerly's fast k-means 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 k-Means algorithm based on Hamerly's fast k-means 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 |
Pseudo-Visualizer, that lists the cluster evaluation results found.
|
| Evaluator |
Interface for post-algorithm 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 |
Exp-Gamma 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
L-Moments (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
maximum-likelihood 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 k-means 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 k-fold 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 M-tree, beginning with the most
difficult points first.
|
| FarthestPoints<O> |
K-Means 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> |
K-Means initialization by repeatedly choosing the farthest point (by the
sum of distances to previous objects).
|
| FarthestSumPoints.Par<V> |
Parameterization class.
|
| FastABOD<V extends NumberVector> |
Fast-ABOD (approximateABOF) version of
Angle-Based Outlier Detection / Angle-Based 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 non-medoid.
|
| 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 |
Drop-in 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((n-k)²).
|
| 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 |
Density-based Clustering of Applications with Noise and Fuzzy objects
(FDBSCAN) is an Algorithm to find sets in a fuzzy database that are
density-connected 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 K-means 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 |
Fisher-Rao riemannian metric for (discrete) probability distributions.
|
| FisherRaoDistance.Par |
Parameterization class.
|
| FittingFunction |
Interface for a function used in Levenberg-Marquard-Fitting
|
| 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 |
Flexible-beta 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 |
FP-Growth 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 |
FP-Tree 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 non-negative 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
L-Moments (LMM).
|
| GammaLMMEstimator.Par |
Parameterization class.
|
| GammaMOMEstimator |
Simple parameter estimation for the Gamma distribution.
|
| GammaMOMEstimator.Par |
Parameterization class.
|
| GammaScaling |
Non-linear 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 (1-stable).
|
| 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, density-based 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 L-Moments (LMM).
|
| GeneralizedExtremeValueLMMEstimator.Par |
Parameterization class.
|
| GeneralizedHyperplaneDistribution |
Generalized hyperplane entry distribution strategy of the M-tree.
|
| GeneralizedLogisticAlternateDistribution |
Generalized logistic distribution.
|
| GeneralizedLogisticAlternateDistribution.Par |
Parameterization class
|
| GeneralizedLogisticAlternateLMMEstimator |
Estimate the parameters of a Generalized Logistic Distribution, using the
methods of L-Moments (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 L-Moments (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 R-tree index of ELKI, with Haversine distance.
|
| GeometricLinkage |
Geometric linkages, in addition to the combination with
Lance-Williams-Equations, these linkages can also be computed by aggregating
data points (for vector data only).
|
| GiniIndex |
Gini-index based interestingness measure, using the weighted squared
conditional probabilities compared to the non-conditional 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 |
Global-Local Outlier Scores from Hierarchies.
|
| GLOSH.Par |
Parameterization class.
|
| GMeans<V extends NumberVector,M extends MeanModel> |
G-Means extends K-Means 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 Near-neighbor Access Tree (GNAT), also known as Multi Vantage Point
Tree or MVP-Tree.
|
| GNAT.Factory<O extends NumberVector> |
Index Factory
|
| GNAT.Factory.Par<O extends NumberVector> |
Parameterization class.
|
| GNAT.GNATKNNSearcher |
kNN query for the mvp-tree.
|
| GNAT.GNATRangeSearcher |
range query for the mvp-tree
|
| 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 Greater-Equal-Than-Number 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 k-medoids that combines the Greedy (PAM
BUILD) with "alternate" refinement steps. |
| GreedyG.Par<V> |
Parameterization class.
|
| GreedyKCenter<O> |
Greedy algorithm for k-center algorithm also known as Gonzalez clustering,
or farthest-first traversal.
|
| GreedyKCenter.Par<O> |
Parameterization class
|
| GreeneSplit |
Quadratic-time complexity split as used by Diane Greene for the R-Tree.
|
| GreeneSplit.Par |
Parameterization class.
|
| GridBasedReferencePoints |
Grid-based strategy to pick reference points.
|
| GridBasedReferencePoints.Par |
Parameterization class.
|
| GriDBSCAN<V extends NumberVector> |
Using Grid for Accelerating Density-Based Clustering.
|
| GriDBSCAN.Instance<V extends NumberVector> |
Instance, for a single run.
|
| GroupAverageLinkage |
Group-average 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 Log-Weibull distribution.
|
| GumbelDistribution.Par |
Parameterization class
|
| GumbelLMMEstimator |
Estimate the parameters of a Gumbel Distribution, using the methods of
L-Moments (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 pseudo-uniform distribution.
|
| HaltonUniformDistribution.Par |
Parameterization class
|
| HamerlyKMeans<V extends NumberVector> |
Hamerly's fast k-means 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 k-means 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 |
Hash-organized DBIDs
|
| HashSetModifiableDBIDs |
Set-oriented 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 in-memory 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, Hellinger-Kakutani 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 Density-Based 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 one-dimensional 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 |
Hypercube-Based 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 High-Dimensional 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 two-way search,
is an outlier detection method based on LOF; but also using the reverse kNN.
|
| INFLO.Par<O> |
Parameterization class.
|
| InMemoryIDistanceIndex<O> |
In-memory 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 |
Integer-valued 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 in-memory 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 in-memory 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 k-means++ 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 number-distance as similarity measure, by
computing 1/distance.
|
| InvertedOutlierScoreMeta |
Class to signal a value-inverted outlier score, i.e. low values are outliers.
|
| IsolationForest |
Isolation-Based 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 one-by-one.
|
| Jaccard |
Jaccard interestingness measure:
|
| JaccardSimilarityDistance |
A flexible extension of Jaccard similarity to non-binary vectors.
|
| JeffreyDivergenceDistance |
|
| JeffreyDivergenceDistance.Par |
Parameterization class, using the static instance.
|
| JensenShannonDivergenceDistance |
|
| JensenShannonDivergenceDistance.Par |
Parameterization class, using the static instance.
|
| JensenShannonEquiwidthDependence |
Jensen-Shannon Divergence is closely related to mutual information.
|
| JensenShannonEquiwidthDependence.Par |
Parameterization class.
|
| JMeasure |
J-Measure 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 (EM-Algorithm), also known as Gaussian
Mixture Modeling (GMM), calculated on a kd-tree.
|
| KDTreeEM.KDTree |
KDTree class with the statistics needed for EM clustering.
|
| KDTreeEM.Par |
Parameterization class.
|
| KDTreeFilteringKMeans<V extends NumberVector> |
Filtering or "blacklisting" K-means with k-d-tree acceleration.
|
| KDTreeFilteringKMeans.Par<V extends NumberVector> |
Parameterization class.
|
| KDTreePruningKMeans<V extends NumberVector> |
Pruning K-means with k-d-tree acceleration.
|
| KDTreePruningKMeans.KDNode |
Node of the k-d-tree used internally.
|
| KDTreePruningKMeans.Par<V extends NumberVector> |
Parameterization class.
|
| KDTreePruningKMeans.Split |
Splitting strategies for constructing the k-d-tree.
|
| 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 |
K-MC² 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 K-Means
|
| KMeansMinusMinus<V extends NumberVector> |
k-means--: A Unified Approach to Clustering and Outlier Detection.
|
| KMeansMinusMinus.Par<V extends NumberVector> |
Parameterization class.
|
| KMeansMinusMinusOutlierDetection |
k-means--: 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 k-means (so the Voronoi cell visualization is sensible). |
| KMeansOutlierDetection<O extends NumberVector> |
Outlier detection by using k-means clustering.
|
| KMeansOutlierDetection.Rule |
Outlier scoring rule
|
| KMeansPlusPlus<O> |
K-Means++ initialization for k-means.
|
| KMeansPlusPlus.Instance<T> |
Abstract instance implementing the weight handling.
|
| KMeansPlusPlus.MedoidsInstance |
Instance for k-medoids.
|
| KMeansPlusPlus.NumberVectorInstance |
Instance for k-means, number vector based.
|
| KMeansPlusPlus.Par<V> |
Parameterization class.
|
| KMeansProcessor<V extends NumberVector> |
Parallel k-means 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 K-Means clustering.
|
| KMediansLloyd<V extends NumberVector> |
k-medians clustering algorithm, but using Lloyd-style 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 K-Medoids.
|
| KMedoidsKMedoidsInitialization<O> |
Initialize k-medoids with k-medoids, 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 kNN-distances 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 k-nearest 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 R-tree.
|
| KNNJoinMaterializeKNNPreprocessor.Factory<O extends SpatialComparable> |
The parameterizable factory.
|
| KNNKernelDensityMinimaClustering |
Cluster one-dimensional 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> |
kNN-based 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 Kolmogorov-Smirnov goodness of fit test.
|
| KolmogorovSmirnovDistance.Par |
Parameterization class, using the static instance.
|
| KolmogorovSmirnovTest |
Kolmogorov-Smirnov test.
|
| KolmogorovSmirnovTest.Par |
Parameterizer, to use the static instance.
|
| KuhnMunkres |
Kuhn-Munkres optimal matching (aka the Hungarian algorithm).
|
| KuhnMunkresStern |
A version of Kuhn-Munkres inspired by the implementation of Kevin L.
|
| KuhnMunkresWong |
Kuhn-Munkres 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 |
Kullback-Leibler divergence, also known as relative entropy,
information deviation, or just KL-distance (albeit asymmetric).
|
| KullbackLeiblerDivergenceAsymmetricDistance.Par |
Parameterization class, using the static instance.
|
| KullbackLeiblerDivergenceReverseAsymmetricDistance |
Kullback-Leibler divergence, also known as relative entropy, information
deviation or just KL-distance (albeit asymmetric).
|
| KullbackLeiblerDivergenceReverseAsymmetricDistance.Par |
Parameterization class, using the static instance.
|
| LAB<O> |
Linear approximative BUILD (LAB) initialization for FastPAM (and k-means).
|
| 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 L-Moments (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 (WGS-86 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 line-of-sight.
|
| LatLngToECEFProjection<V extends NumberVector> |
Project (Latitude, Longitude) vectors to (X, Y, Z), from spherical
coordinates to ECEF (earth-centered earth-fixed).
|
| 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> |
LB-ABOD (lower-bound) version of
Angle-Based Outlier Detection / Angle-Based 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 Distance-Based 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 R-Tree insertion strategy: find rectangle with least volume
enlargement.
|
| LeastEnlargementInsertionStrategy.Par |
Parameterization class.
|
| LeastEnlargementWithAreaInsertionStrategy |
A slight modification of the default R-Tree 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 sum-of-squares, 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 sum-of-squares.
|
| LeastSSQSplit.Par |
Parameterizer
|
| LeaveOneOut |
A leave-one-out-holdout 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 Less-Than-Number parameter constraint.
|
| LessEqualConstraint |
Represents a Less-Equal-Than-Number parameter constraint.
|
| LevenbergMarquardtMethod |
Function parameter fitting using Levenberg-Marquardt 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> |
Outlier-detection using one-class 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, non-accelerated) 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 k-fold 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, package-private.
|
| ListSizeConstraint |
Represents a list-size parameter constraint.
|
| LloydKMeans<V extends NumberVector> |
The standard k-means 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 L-Moments
(LMM).
|
| LMomentsEstimator |
Probability weighted moments based estimator using L-Moments.
|
| 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 (WGS-86 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 line-of-sight.
|
| LngLatToECEFProjection<V extends NumberVector> |
Project (Longitude, Latitude) vectors to (X, Y, Z), from spherical
coordinates to ECEF (earth-centered earth-fixed).
|
| 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 double-int values.
|
| LOF<O> |
Algorithm to compute density-based 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+|x|b)}{\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 |
Log-Gamma 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 |
Pseudo-step 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
L-Moments (LMM).
|
| LogisticLMMEstimator.Par |
Parameterization class.
|
| LogisticMADEstimator |
Estimate Logistic distribution parameters using Median and MAD.
|
| LogisticMADEstimator.Par |
Parameterization class.
|
| LogLogisticDistribution |
Log-Logistic 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 L-Moments (LMM) for the Generalized Normal Distribution.
|
| LogNormalBilkovaLMMEstimator.Par |
Parameterization class.
|
| LogNormalDistribution |
Log-Normal distribution.
|
| LogNormalDistribution.Par |
Parameterization class
|
| LogNormalLevenbergMarquardtKDEEstimator |
Distribution parameter estimation using Levenberg-Marquardt iterative
optimization and a kernel density estimation.
|
| LogNormalLevenbergMarquardtKDEEstimator.Par |
Parameterization class.
|
| LogNormalLMMEstimator |
Estimate the parameters of a log Normal Distribution, using the methods of
L-Moments (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 long-valued statistic.
|
| LoOP<O> |
LoOP: Local Outlier Probabilities
|
| LPCAEstimator |
Local PCA based ID estimator.
|
| LPCAEstimator.Par |
Parameterization class.
|
| LPIntegerNormDistance |
L p-Norm for NumberVectors, optimized version for integer
values of p. |
| LPIntegerNormDistance.Par |
Parameterization class.
|
| LPNormDistance |
L p-Norm (Minkowski norms) are a family of distances for
NumberVectors. |
| 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 k-means 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 |
2-stable 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 bulk-loading 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 |
Median-linkage — 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 in-memory K-D-tree.
|
| 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/O-access.
|
| 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 table-based parameter editor.
|
| MiniGUI.SettingsComboboxModel |
Class to interface between the saved settings list and a JComboBox.
|
| MinimalisticMemoryKDTree<O extends NumberVector> |
Simple implementation of a static in-memory K-D-tree.
|
| 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 nearest-neighbor 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 M-tree.
|
| 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 MkApp-Tree.
|
| MkAppEntry |
Defines the requirements for an entry in an MkCop-Tree node.
|
| MkAppLeafEntry |
Represents an entry in a leaf node of a MkApp-Tree.
|
| MkAppTree<O> |
MkAppTree is a metrical index structure based on the concepts of the M-Tree
supporting efficient processing of reverse k nearest neighbor queries for
parameter k < kmax.
|
| MkAppTreeFactory<O> |
Factory for a MkApp-Tree
|
| MkAppTreeIndex<O> |
MkAppTree used as database index.
|
| MkAppTreeNode<O> |
Represents a node in an MkApp-Tree.
|
| MkAppTreeSettings<O> |
Settings class for the MkApp Tree.
|
| MkCoPDirectoryEntry |
Represents an entry in a directory node of an MkCop-Tree.
|
| MkCoPEntry |
Defines the requirements for an entry in an MkCop-Tree node.
|
| MkCoPLeafEntry |
Represents an entry in a leaf node of a MkCoP-Tree.
|
| MkCoPTree<O> |
MkCopTree is a metrical index structure based on the concepts of the M-Tree
supporting efficient processing of reverse k nearest neighbor queries for
parameter k < kmax.
|
| MkCopTreeFactory<O> |
Factory for a MkCoPTree-Tree
|
| MkCoPTreeIndex<O> |
MkCoPTree used as database index.
|
| MkCoPTreeNode<O> |
Represents a node in an MkCop-Tree.
|
| 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 M-Tree
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 MkTab-Tree.
|
| MkTabEntry |
Defines the requirements for an entry in an MkCop-Tree node.
|
| MkTabLeafEntry |
Represents an entry in a leaf node of a MkTab-Tree.
|
| MkTabTree<O> |
MkTabTree is a metrical index structure based on the concepts of the M-Tree
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 MkMax-Tree.
|
| 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 M-Tree.
|
| MMRadSplit<E extends MTreeEntry,N extends AbstractMTreeNode<?,N,E>> |
Encapsulates the required methods for a split of a node in an M-Tree.
|
| 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 Distance-DBID 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 M-Tree.
|
| MSTSplit<E extends MTreeEntry,N extends AbstractMTreeNode<?,N,E>> |
Splitting algorithm using the minimum spanning tree (MST), as proposed by the
Slim-Tree variant.
|
| MTree<O> |
MTree is a metrical index structure based on the concepts of the M-Tree.
|
| MTreeDirectoryEntry |
Represents an entry in a directory node of an M-Tree.
|
| MTreeEntry |
Defines the requirements for an entry in an M-Tree node.
|
| MTreeFactory<O> |
Factory for a M-Tree
|
| MTreeIndex<O> |
Class for using an m-tree as database index.
|
| MTreeInsert<E extends MTreeEntry,N extends AbstractMTreeNode<?,N,E>> |
Default insertion strategy for the M-tree.
|
| 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 M-Tree.
|
| MTreeNode<O> |
Represents a node in an M-Tree.
|
| 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 M-tree splitting strategies.
|
| MultiBorder |
Multiple border point assignment.
|
| MultidimensionalScalingMSTLayout3DPC |
Layout the axes by multi-dimensional scaling.
|
| MultidimensionalScalingMSTLayout3DPC.Node |
Node class for this layout.
|
| MultidimensionalScalingMSTLayout3DPC.Par |
Parameteriation class.
|
| MultiLPNorm |
Tutorial example Minowski-distance 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 |
Experimenter-style 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 multi-variate 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
equal-width bins.
|
| MutualInformationEquiwidthDependence.Par |
Parameterization class.
|
| MWPTest |
Implementation of Mann-Whitney U test returning the p-value (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> |
Mean-shift 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> |
NN-descent (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 |
No-operation 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 XML-Elements to existing Elements.
|
| NodeArrayAdapter |
Access the entries of a node as array-like.
|
| 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 non-flat 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 0-1 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 Levenberg-Marquardt iterative
optimization and a kernel density estimation.
|
| NormalLevenbergMarquardtKDEEstimator.Par |
Parameterization class.
|
| NormalLMMEstimator |
Estimate the parameters of a normal distribution using the method of
L-Moments (LMM).
|
| NormalLMMEstimator.Par |
Parameterization class.
|
| NormalMADEstimator |
Estimator using Medians.
|
| NormalMADEstimator.Par |
Parameterization class.
|
| NormalMOMEstimator |
Naive maximum-likelihood 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 in-memory 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> |
Outlier-detection using one-class support vector machines.
|
| OddsRatio |
Odds ratio interestingness measure.
|
| ODIN<O> |
Outlier detection based on the in-degree of the kNN graph.
|
| ODIN<O> |
Outlier detection based on the in-degree of the kNN graph.
|
| OfflineChangePointDetectionAlgorithm |
Off-line change point detection algorithm detecting a change in mean, based
on the cumulative sum (CUSUM), same-variance 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 disk-based page files.
|
| OnDiskUpperTriangleMatrix |
Class representing an upper triangle matrix backed by an on-disk array of
O((n+1)*n/2) size
|
| OneClassSVM |
One-class 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 one-dimensional 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 density-based hierarchical clustering.
|
| OPTICSHeap.Par<O> |
Parameterization class.
|
| OPTICSHeapEntry |
Entry in the priority heap.
|
| OPTICSList<O> |
The OPTICS algorithm for density-based hierarchical clustering.
|
| OPTICSList.Par<O> |
Parameterization class.
|
| OPTICSModel |
Model for an OPTICS cluster
|
| OPTICSOF<O> |
OPTICS-OF 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 steep-down-area for the xi method.
|
| OPTICSXi.SteepAreaResult |
Result containing the xi-steep areas.
|
| OPTICSXi.SteepDownArea |
Data structure to represent a steep-down-area for the xi method.
|
| OPTICSXi.SteepScanPosition |
Position when scanning for steep areas
|
| OPTICSXi.SteepUpArea |
Data structure to represent a steep-down-area 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 k-medoids clustering quality.
|
| ORLibBenchmark.Par<O> |
Parameterization class.
|
| Ostrovsky |
Ostrovsky initial means, a variant of k-means++ that is expected to give
slightly better results on average, but only works for k-means and not for,
e.g., PAM (k-medoids).
|
| 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 tree-based 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 |
Pair-counting measures, with support for "noise" clusters and self-pairing
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 k-medoids
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 PAM-based
swap heuristic.
|
| PAMMEDSIL.Instance |
Instance for a single dataset.
|
| PAMMEDSIL.Par<O> |
Parameterization class.
|
| PAMSIL<O> |
Clustering to optimize the Silhouette coefficient with a PAM-based 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 SVG-Element 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 k-Means 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 Simplified-LOF 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 d-dimensional 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 k-means 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 |
Bulk-load an R-tree 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 product-moment correlation coefficient (PPMCC).
|
| PearsonCorrelationDependence |
Pearson product-moment 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 disk-based page files.
|
| PerturbationFilter<V extends NumberVector> |
A filter to perturb the values by adding micro-noise.
|
| 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> |
Projection-Indexed nearest-neighbors (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 knn-distances 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 R-precision (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 k-means 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 precision-recall-gain curve
|
| PRGCEvaluation.Par |
Parameterization class.
|
| PRGCEvaluation.PRGCurve |
Precision-Recall-Gain 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 priority-based 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 L-Moments 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 (non-materialized)
|
| 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 cross-validation.
|
| RandomizedCrossValidation.Par |
Parameterization class
|
| RandomizedHoldout |
A holdout providing a seed for randomized operations.
|
| RandomizedHoldout.Par |
Parameterization class
|
| RandomlyChosen<O> |
Initialize K-means by randomly choosing k existing elements as initial
cluster centers.
|
| RandomlyChosen.Par<V> |
Parameterization class.
|
| RandomNormalGenerated |
Initialize k-means 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 |
Random-Sampling 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 M-Tree.
|
| 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 k-means 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 Database-IDs 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 (non-shifted) RayleighDistribution using
the method of L-Moments (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 (non-shifted) RayleighDistribution using a
maximum likelihood estimate.
|
| RayleighMLEEstimator.Par |
Parameterization class.
|
| RdKNNDirectoryEntry |
Represents an entry in a directory node of an RdKNN-Tree.
|
| RdKNNEntry |
Defines the requirements for an entry in an RdKNN-Tree node.
|
| RdKNNLeafEntry |
Represents an entry in a leaf node of an RdKNN-Tree.
|
| RdKNNNode |
Represents a node in a RDkNN-Tree.
|
| 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 RDkNN-Tree.
|
| 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 |
Reference-Based 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 |
Linear-time complexity greedy split as used by the original R-Tree.
|
| RTreeLinearSplit.Par |
Parameterization class.
|
| RTreeParallelVisualization |
Visualize the of an R-Tree based index.
|
| RTreeParallelVisualization.Par |
Parameterization class.
|
| RTreeQuadraticSplit |
Quadratic-time complexity greedy split as used by the original R-Tree.
|
| 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> |
K-means 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 k-means by running k-means 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 SVG-Element representing the selected range.
|
| SelectionConvexHullVisualization |
Visualizer for generating an SVG-Element containing the convex hull of the
selected points
|
| SelectionConvexHullVisualization.Instance |
Instance
|
| SelectionCubeVisualization |
Visualizer for generating an SVG-Element containing a cube as marker
representing the selected range for each dimension
|
| SelectionCubeVisualization.Par |
Parameterization class.
|
| SelectionDotVisualization |
Visualizer for generating an SVG-Element containing dots as markers
representing the selected Database's objects.
|
| SelectionDotVisualization.Instance |
Instance
|
| SelectionLineVisualization |
Visualizer for generating SVG-Elements representing the selected objects
|
| SelectionResult |
Selection result wrapper.
|
| SelectionTableWindow |
Visualizes selected Objects in a JTable, objects can be selected, changed and
deleted
|
| SelectionToolAxisRangeVisualization |
Tool-Visualization for the tool to select axis ranges
|
| SelectionToolCubeVisualization |
Tool-Visualization for the tool to select ranges.
|
| SelectionToolCubeVisualization.Instance |
Instance.
|
| SelectionToolDotVisualization |
Tool-Visualization for the tool to select objects
|
| SelectionToolDotVisualization.Instance |
Instance
|
| SelectionToolDotVisualization.Mode |
Input modes
|
| SelectionToolLineVisualization |
Tool-Visualization 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 |
Pseudo-Visualizer, that lists the settings of the algorithm-
|
| ShallotKMeans<V extends NumberVector> |
Borgelt's Shallot k-means 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 sub-channel.
|
| SharedInteger |
Direct channel connecting two processors.
|
| SharedInteger.Instance |
Instance for a sub-channel.
|
| 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 non-negative 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 |
Signi-Trend detection algorithm applies to a single time-series.
|
| 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 |
Dimension-selecting 1D projection.
|
| Simple1DOFCamera |
Class for a simple camera.
|
| Simple1DOFCamera.CameraListener |
Camera Listener class
|
| Simple2D |
Dimension-selecting 2D projection.
|
| SimpleAdapter |
This adapter can be used for an arbitrary collection of DBIDs, and does hence
not have a notion of ties.
|
| SimpleCircularMSTLayout3DPC |
Simple circular layout based on the minimum spanning tree.
|
| SimpleCircularMSTLayout3DPC.Node |
Node class for this layout.
|
| SimpleCircularMSTLayout3DPC.Par |
Parameteriation class.
|
| SimpleClassLabel |
A simple class label casting a String as it is as label.
|
| SimpleClassLabel.Factory |
Factory class.
|
| SimpleClassLabel.Serializer |
Serialization class.
|
| SimpleCOP<V extends NumberVector> |
Algorithm to compute local correlation outlier probability.
|
| SimpleCOP.Par<V extends NumberVector> |
Parameterization class.
|
| SimpleEnumeratingScheme |
Simple enumerating naming scheme.
|
| SimpleGaussianContinuousUncertainObject |
Gaussian model for uncertain objects, sampled from a 3-sigma bounding box.
|
| SimpleGaussianContinuousUncertainObject.Factory |
Factory class for this data type.
|
| SimpleGaussianUncertainifier |
Vector factory
|
| SimpleGaussianUncertainifier.Par |
Parameterizer class.
|
| SimpleKernelDensityLOF<O extends NumberVector> |
A simple variant of the LOF algorithm, which uses a simple kernel density
estimation instead of the local reachability density.
|
| SimpleMenuOverlay |
Simple menu overlay.
|
| SimpleMessageOverlay |
Simple menu overlay.
|
| SimpleOutlierEnsemble |
Simple outlier ensemble method.
|
| SimpleOutlierEnsemble.Par |
Parameterization class.
|
| SimpleParallel |
Simple parallel projection
Scaled space: reordered, scaled and inverted.
|
| SimplePolygonParser |
Parser to load polygon data (2D and 3D only) from a simple format.
|
| SimplePolygonParser.Par |
Parameterization class.
|
| SimplePrototypeModel<V> |
Cluster model that stores a prototype for each cluster.
|
| SimpleScoreDumper |
Simple example output handler for processing outlier scores.
|
| SimpleSVGViewer |
A minimalistic SVG viewer with export dialog.
|
| SimpleTransactionParser |
Simple parser for transactional data, such as market baskets.
|
| SimpleTransactionParser.Par |
Parameterization class.
|
| SimpleTypeInformation<T> |
Class wrapping a particular data type.
|
| SimplifiedCoverTree<O> |
Simplified cover tree data structure (in-memory).
|
| SimplifiedCoverTree.Factory<O> |
Index factory.
|
| SimplifiedCoverTree.Factory.Par<O> |
Parameterization class.
|
| SimplifiedCoverTree.Node |
Node object.
|
| SimplifiedElkanKMeans<V extends NumberVector> |
Simplified version of Elkan's k-means by exploiting the triangle inequality.
|
| SimplifiedElkanKMeans.Instance |
Inner instance, storing state for a single data set.
|
| SimplifiedElkanKMeans.Par<V extends NumberVector> |
Parameterization class.
|
| SimplifiedHierarchyExtraction |
Extraction of simplified cluster hierarchies, as proposed in HDBSCAN.
|
| SimplifiedHierarchyExtraction.Par |
Parameterization class.
|
| SimplifiedHierarchyExtraction.TempCluster |
Temporary cluster.
|
| SimplifiedHierarchyExtractionEvaluator |
Extract clusters from a hierarchical clustering, during the evaluation phase.
|
| SimplifiedHierarchyExtractionEvaluator.Par |
Parameterization class.
|
| SimplifiedLOF<O> |
A simplified version of the original LOF algorithm, which does not use the
reachability distance, yielding less stable results on inliers.
|
| SimplifiedLRDProcessor |
Processor for the "local reachability density" of LOF.
|
| SimplifiedRandomHyperplaneProjectionFamily |
Random hyperplane projection family.
|
| SimplifiedRandomHyperplaneProjectionFamily.Par |
Parameterization class.
|
| SimplifiedRandomHyperplaneProjectionFamily.SignedProjection |
Fast projection class, using booleans to represent +-1 matrix entries.
|
| SimplifiedSilhouette |
Compute the simplified silhouette of a data set.
|
| SimplifiedSilhouette.Par |
Parameterization class.
|
| SinCosTable |
Class to precompute / cache Sinus and Cosinus values.
|
| SinCosTable.FullTable |
Table that can't exploit much symmetry, because the steps are not divisible
by 2.
|
| SinCosTable.HalfTable |
Table that exploits just one symmetry, as the number of steps is divisible
by two.
|
| SinCosTable.QuarterTable |
Table that exploits both symmetries, as the number of steps is divisible by
four.
|
| SingleAssignmentKMeans<V extends NumberVector> |
Pseudo-k-means variations, that assigns each object to the nearest center.
|
| SingleAssignmentKMeans.Instance |
Inner instance, storing state for a single data set.
|
| SingleAssignmentKMeans.Par<V extends NumberVector> |
Parameterization class.
|
| SingleAssignmentKMedoids<O> |
K-medoids clustering by using the initialization only, then assigning each
object to the nearest neighbor.
|
| SingleAssignmentKMedoids.Instance |
Instance for a single dataset.
|
| SingleAssignmentKMedoids.Par<O> |
Parameterization class.
|
| SingleLinkage |
Single-linkage ("minimum") clustering method.
|
| SingleLinkage.Par |
Class parameterizer.
|
| SingleObjectBundle |
This class represents a "packaged" object, which is a transfer container for
objects, e.g., from parsers to a database.
|
| SingleObjectsStylingPolicy |
Styling policy based on assigning objects individual colors.
|
| SingleStreamOutput |
Class to output all result data to a single stream (e.g., Stdout, single
file)
|
| SingleThreadedExecutor |
Class to process the whole data set in a single thread.
|
| SingleThreadedExecutor.SingleThreadedRunner |
Run for an array part, without step size.
|
| SingularValueDecomposition |
Singular Value Decomposition.
|
| SkewGeneralizedNormalDistribution |
Generalized normal distribution by adding a skew term, similar to lognormal
distributions.
|
| SkewGeneralizedNormalDistribution.Par |
Parameterization class
|
| SkewGNormalLMMEstimator |
Estimate the parameters of a skew Normal Distribution (Hoskin's Generalized
Normal Distribution), using the methods of L-Moments (LMM).
|
| SkewGNormalLMMEstimator.Par |
Parameterization class.
|
| SLINK<O> |
Implementation of the efficient Single-Link Algorithm SLINK of R.
|
| SLINK.Par<O> |
Parameterization class.
|
| SLINKHDBSCANLinearMemory<O> |
Linear memory implementation of HDBSCAN clustering based on SLINK.
|
| SLOM<N,O> |
SLOM: a new measure for local spatial outliers
|
| SlopeDependence |
Arrange dimensions based on the entropy of the slope spectrum.
|
| SlopeDependence.Par |
Parameterization class.
|
| SlopeInversionDependence |
Arrange dimensions based on the entropy of the slope spectrum.
|
| SlopeInversionDependence.Par |
Parameterization class.
|
| SmallDenseItemset |
Frequent itemset, dense representation for up to 64 items.
|
| SmallMemoryKDTree<O extends NumberVector> |
Simple implementation of a static in-memory K-D-tree.
|
| SmallMemoryKDTree.Factory<O extends NumberVector> |
Factory class
|
| SmallMemoryKDTree.Factory.Par<O extends NumberVector> |
Parameterization class.
|
| SmallMemoryKDTree.PrioritySearchBranch |
Search position for priority search.
|
| SNE<O> |
Stochastic Neighbor Embedding is a projection technique designed for
visualization that tries to preserve the nearest neighbor structure.
|
| SNNClustering<O> |
Shared nearest neighbor clustering.
|
| SOD<V extends NumberVector> |
Subspace Outlier Degree: Outlier Detection in Axis-Parallel Subspaces of High
Dimensional Data.
|
| SOD.Par<V extends NumberVector> |
Parameterization class.
|
| SOD.SODModel |
SOD Model class
|
| SOF<N,O> |
The Spatial Outlier Factor (SOF) is a spatial
LOF variation. |
| SolidLineStyleLibrary |
Line style library featuring solid lines for default styles only (combine
with a color library to obtain enough classes!)
|
| Solver |
SMO solver for support vector machines, derived from libSVM.
|
| Solver.SolutionInfo |
|
| SortByLabelFilter |
A filter to sort the data set by some label.
|
| SortMeans<V extends NumberVector> |
Sort-Means: Accelerated k-means by exploiting the triangle inequality and
pairwise distances of means to prune candidate means (with sorting).
|
| SortMeans.Instance |
Inner instance, storing state for a single data set.
|
| SortMeans.Par<V extends NumberVector> |
Parameterization class.
|
| SortTileRecursiveBulkSplit |
Sort-Tile-Recursive aims at tiling the data space with a grid-like structure
for partitioning the dataset into the required number of buckets.
|
| SortTileRecursiveBulkSplit.Par |
Parameterization class.
|
| SOS<O> |
Stochastic Outlier Selection.
|
| SpacefillingKNNPreprocessor<O extends NumberVector> |
Compute the nearest neighbors approximatively using space filling curves.
|
| SpacefillingKNNPreprocessor.Factory<V extends NumberVector> |
Index factory class
|
| SpacefillingKNNPreprocessor.Factory.Par |
Parameterization class.
|
| SpacefillingMaterializeKNNPreprocessor<O extends NumberVector> |
Compute the nearest neighbors approximatively using space filling curves.
|
| SpacefillingMaterializeKNNPreprocessor.Factory<V extends NumberVector> |
Index factory class
|
| SparseAffinityMatrix |
Dense affinity matrix storage.
|
| SparseByteVector |
Sparse vector type, using byte[] for storing the values, and
int[] for storing the indexes, approximately 5 bytes per non-zero
value (limited to -128..+127).
|
| SparseByteVector.Factory |
Factory class.
|
| SparseByteVector.Factory.Par |
Parameterization class.
|
| SparseByteVector.VariableSerializer |
Serialization class using VarInt encodings.
|
| SparseDoubleVector |
Sparse vector type, using double[] for storing the values, and
int[] for storing the indexes, approximately 12 bytes per non-zero
value.
|
| SparseDoubleVector.Factory |
Factory class.
|
| SparseDoubleVector.Factory.Par |
Parameterization class.
|
| SparseDoubleVector.VariableSerializer |
Serialization class using VarInt encodings.
|
| SparseEuclideanDistance |
|
| SparseEuclideanDistance.Par |
Parameterizer
|
| SparseFeatureVector<D> |
Extended interface for sparse feature vector types.
|
| SparseFloatVector |
Sparse vector type, using float[] for storing the values, and
int[] for storing the indexes, approximately 8 bytes per non-zero
value.
|
| SparseFloatVector.Factory |
Factory class.
|
| SparseFloatVector.Factory.Par |
Parameterization class.
|
| SparseFloatVector.VariableSerializer |
Serialization class using VarInt encodings.
|
| SparseIntegerVector |
Sparse vector type, using int[] for storing the values, and
int[] for storing the indexes, approximately 8 bytes per non-zero
integer value.
|
| SparseIntegerVector.Factory |
Factory class.
|
| SparseIntegerVector.Factory.Par |
Parameterization class.
|
| SparseIntegerVector.VariableSerializer |
Serialization class using VarInt encodings.
|
| SparseItemset |
Frequent itemset, sparse representation.
|
| SparseLPNormDistance |
|
| SparseLPNormDistance.Par |
Parameterizer
|
| SparseManhattanDistance |
|
| SparseManhattanDistance.Par |
Parameterizer
|
| SparseMaximumDistance |
|
| SparseMaximumDistance.Par |
Parameterizer
|
| SparseNumberVector |
Combines the SparseFeatureVector and NumberVector.
|
| SparseNumberVector.Factory<V extends SparseNumberVector> |
Factory for sparse number vectors: make from a dim-value map.
|
| SparseNumberVectorLabelParser<V extends SparseNumberVector> |
Parser for parsing one point per line, attributes separated by whitespace.
|
| SparseNumberVectorLabelParser.Par<V extends SparseNumberVector> |
Parameterization class.
|
| SparseShortVector |
Sparse vector type, using short[] for storing the values, and
int[] for storing the indexes, approximately 6 bytes per non-zero
value.
|
| SparseShortVector.Factory |
Factory class.
|
| SparseShortVector.Factory.Par |
Parameterization class.
|
| SparseShortVector.VariableSerializer |
Serialization class using VarInt encodings.
|
| SparseSquaredEuclideanDistance |
|
| SparseSquaredEuclideanDistance.Par |
Parameterizer
|
| SparseVectorFieldFilter<V extends SparseNumberVector> |
Class that turns sparse float vectors into a proper vector field, by setting
the maximum dimensionality for each vector.
|
| SpatialApproximationMaterializeKNNPreprocessor<O extends NumberVector> |
A preprocessor for annotation of the k nearest neighbors (and their
distances) to each database object.
|
| SpatialApproximationMaterializeKNNPreprocessor.Factory |
The actual preprocessor instance.
|
| SpatialApproximationMaterializeKNNPreprocessor.Factory.Par |
Parameterization class.
|
| SpatialComparable |
Defines the required methods needed for comparison of spatial objects.
|
| SpatialDirectoryEntry |
Represents an entry in a directory node of a spatial index.
|
| SpatialDistanceQuery<V extends SpatialComparable> |
Query interface for spatial distance queries.
|
| SpatialEntry |
Defines the requirements for an entry in a node of a spatial index.
|
| SpatialPair<K,V extends SpatialComparable> |
Defines the requirements for objects that can be indexed by a Spatial Index,
which are spatial nodes or data objects.
|
| SpatialPointLeafEntry |
Represents an entry in a leaf node of a spatial index.
|
| SpatialPrimitiveDistance<V extends SpatialComparable> |
API for a spatial primitive distance function.
|
| SpatialPrimitiveDistanceQuery<V extends SpatialComparable> |
Distance query for spatial distance functions
|
| SpatialPrimitiveDistanceSimilarityQuery<O extends SpatialComparable> |
Combination query class, to allow combined implementations of spatial
distances and similarities.
|
| SpatialSingleMaxComparator |
Comparator for sorting spatial objects by the maximum value in a single
dimension.
|
| SpatialSingleMeanComparator |
Comparator for sorting spatial objects by the mean value in a single
dimension.
|
| SpatialSingleMinComparator |
Comparator for sorting spatial objects by the minimum value in a single
dimension.
|
| SpatialSortBulkSplit |
Bulk loading by spatially sorting the objects, then partitioning the sorted
list appropriately.
|
| SpatialSortBulkSplit.Par |
Parametization class
|
| SpatialSorter |
Interface for spatial sorting - ZCurves, Peano curves, Hilbert curves, ...
|
| SpatialUtil |
Utility class with spatial functions.
|
| SpearmanCorrelationDependence |
Spearman rank-correlation coefficient, also known as Spearmans Rho.
|
| SpearmanCorrelationDependence.Par |
Parameterization class
|
| SphereUtil |
Class with utility functions for distance computations on the sphere.
|
| SphericalAFKMC2 |
Spherical K-Means++ initialization with markov chains.
|
| SphericalAFKMC2.Instance |
Abstract instance implementing the weight handling.
|
| SphericalAFKMC2.Par |
Parameterization class.
|
| SphericalCosineEarthModel |
A simple spherical earth model using radius 6371009 m.
|
| SphericalCosineEarthModel.Par |
Parameterization class.
|
| SphericalElkanKMeans<V extends NumberVector> |
Elkan's fast k-means by exploiting the triangle inequality.
|
| SphericalElkanKMeans.Instance |
Inner instance, storing state for a single data set.
|
| SphericalElkanKMeans.Par<V extends NumberVector> |
Parameterization class.
|
| SphericalGaussianModel |
Simple spherical Gaussian cluster (scaled identity matrixes).
|
| SphericalGaussianModelFactory |
Factory for EM with multivariate gaussian models using a single variance.
|
| SphericalHamerlyKMeans<V extends NumberVector> |
A spherical k-Means algorithm based on Hamerly's fast k-means by exploiting
the triangle inequality.
|
| SphericalHamerlyKMeans.Instance |
Inner instance, storing state for a single data set.
|
| SphericalHamerlyKMeans.Par<V extends NumberVector> |
Parameterization class.
|
| SphericalHaversineEarthModel |
A simple spherical earth model using radius 6371009 m.
|
| SphericalHaversineEarthModel.Par |
Parameterization class.
|
| SphericalKMeans<V extends NumberVector> |
The standard spherical k-means algorithm.
|
| SphericalKMeans.Instance |
Instance for a particular data set.
|
| SphericalKMeans.Par<V extends NumberVector> |
Parameterization class.
|
| SphericalKMeansPlusPlus<O> |
Spherical K-Means++ initialization for k-means.
|
| SphericalKMeansPlusPlus.Instance |
Abstract instance implementing the weight handling.
|
| SphericalKMeansPlusPlus.Par<V> |
Parameterization class.
|
| SphericalSimplifiedElkanKMeans<V extends NumberVector> |
A spherical k-Means algorithm based on Hamerly's fast k-means by exploiting
the triangle inequality.
|
| SphericalSimplifiedElkanKMeans.Instance |
Inner instance, storing state for a single data set.
|
| SphericalSimplifiedElkanKMeans.Par<V extends NumberVector> |
Parameterization class.
|
| SphericalSimplifiedHamerlyKMeans<V extends NumberVector> |
A spherical k-Means algorithm based on Hamerly's fast k-means by exploiting
the triangle inequality.
|
| SphericalSimplifiedHamerlyKMeans.Instance |
Inner instance, storing state for a single data set.
|
| SphericalSimplifiedHamerlyKMeans.Par<V extends NumberVector> |
Parameterization class.
|
| SphericalSingleAssignmentKMeans<V extends NumberVector> |
Pseudo-k-Means variations, that assigns each object to the nearest center.
|
| SphericalSingleAssignmentKMeans.Instance |
Instance for a particular data set.
|
| SphericalSingleAssignmentKMeans.Par<V extends NumberVector> |
Parameterization class.
|
| SphericalVincentyEarthModel |
A simple spherical earth model using radius 6371009 m.
|
| SphericalVincentyEarthModel.Par |
Parameterization class.
|
| SplitNumberVectorFilter<V extends NumberVector> |
Split an existing column into two types.
|
| SplitNumberVectorFilter.Par<V extends NumberVector> |
Parameterization class.
|
| SplitOnlyOverflowTreatment |
Always split, as in the original R-Tree
|
| SplitOnlyOverflowTreatment.Par |
Parameterization class.
|
| SplitStrategy |
Split strategy for full k-d-tree construction.
|
| SplitStrategy |
Generic interface for split strategies.
|
| SplitStrategy.Info |
Split information.
|
| SplitStrategy.Util |
Utility functions.
|
| SqrtCosineDistance |
Cosine distance function for feature vectors using the square root.
|
| SqrtCosineDistance.Par |
Parameterization class.
|
| SqrtCosineUnitlengthDistance |
Cosine distance function for unit length feature vectors using the
square root.
|
| SqrtCosineUnitlengthDistance.Par |
Parameterization class.
|
| SqrtJensenShannonDivergenceDistance |
The square root of Jensen-Shannon divergence is a metric.
|
| SqrtJensenShannonDivergenceDistance.Par |
Parameterization class, using the static instance.
|
| SqrtStandardDeviationScaling |
Scaling that can map arbitrary values to a probability in the range of [0:1].
|
| SqrtStandardDeviationScaling.Par |
Parameterization class.
|
| SquaredErrors |
Evaluate a clustering by reporting the squared errors (SSE, SSQ), as used by
k-means.
|
| SquaredErrors.Par |
Parameterization class.
|
| SquaredEuclideanDistance |
|
| SquaredEuclideanDistance.Par |
Parameterization class.
|
| SquaredEuclideanWeight |
Use the squared Euclidean distance only for distance measurement.
|
| SquaredPearsonCorrelationDistance |
Squared Pearson correlation distance function for feature vectors.
|
| SquaredPearsonCorrelationDistance.Par |
Parameterization class.
|
| SquaredUncenteredCorrelationDistance |
Squared uncentered correlation distance function for feature vectors.
|
| SquaredUncenteredCorrelationDistance.Par |
Parameterization class.
|
| StackedIter<B,A extends B> |
Filtered iterator.
|
| StandardCovarianceMatrixBuilder |
|
| StandardDeviationScaling |
Scaling that can map arbitrary values to a probability in the range of [0:1].
|
| StandardDeviationScaling.Par |
Parameterization class.
|
| StandardizedTwoSampleAndersonDarlingTest |
Perform a two-sample Anderson-Darling rank test, and standardize the
statistic according to Scholz and Stephens.
|
| StarBasedReferencePoints |
Star-based strategy to pick reference points.
|
| StarBasedReferencePoints.Par |
Parameterization class.
|
| StaticArrayDatabase |
This database class uses array-based storage and thus does not allow for
dynamic insert, delete and update operations.
|
| StaticArrayDatabase.Par |
Parameterization class.
|
| StaticDBIDs |
Unmodifiable DBIDs.
|
| StaticIntGenerator |
Generate a static set of integers.
|
| StaticScalingFunction |
Interface for Scaling functions that do NOT depend on analyzing the data set.
|
| StaticVisualizationInstance |
Static visualization
|
| Statistic |
Abstract base interface for statistics tracking.
|
| StatisticalMoments |
Track various statistical moments, including mean, variance, skewness and
kurtosis.
|
| StepProgress |
This progress class is used for multi-step processing.
|
| StockIcon |
Stock icon library for use in the GUI.
|
| StratifiedCrossValidation |
A stratified n-fold crossvalidation to distribute the data to n buckets where
each bucket exhibits approximately the same distribution of classes as does
the complete data set.
|
| StratifiedCrossValidation.Par |
Parameterization class
|
| StreamFactory |
Interface for output handling (single file, multiple files, ...)
|
| StreamFilter |
Streaming filters are often more efficient (less memory use) as they do not
keep a reference to earlier data.
|
| StreamFromBundle |
Convert a MultipleObjectsBundle to a stream.
|
| StreamingParser |
Interface for streaming parsers, that may be much more efficient in
combination with filters.
|
| StringParameter |
Parameter class for a parameter specifying a string.
|
| StringParser |
Parser that loads a text file for use with string similarity measures.
|
| StringParser.Par |
Parameterization class.
|
| StringStatistic |
Trivial string based statistic.
|
| StudentsTDistribution |
Student's t distribution.
|
| StudentsTDistribution.Par |
Parameterization class
|
| StyleLibrary |
Style library interface.
|
| StylingPolicy |
Styling policy.
|
| SUBCLU<V extends NumberVector> |
Implementation of the SUBCLU algorithm, an algorithm to detect arbitrarily
shaped and positioned clusters in subspaces.
|
| SUBCLU.Par<V extends NumberVector> |
Parameterization class.
|
| Subspace |
Represents a subspace of the original data space.
|
| SubspaceClusteringAlgorithm<M extends SubspaceModel> |
Interface for subspace clustering algorithms that use a model derived from
SubspaceModel, that can then be post-processed for outlier detection. |
| SubspaceEuclideanDistance |
Euclidean distance function between NumberVectors only in specified
dimensions. |
| SubspaceEuclideanDistance.Par |
Parameterization class.
|
| SubspaceLPNormDistance |
L p-Norm distance function between NumberVectors only in
specified dimensions. |
| SubspaceLPNormDistance.Par |
Parameterization class.
|
| SubspaceManhattanDistance |
Manhattan distance function between NumberVectors only in specified
dimensions. |
| SubspaceManhattanDistance.Par |
Parameterization class.
|
| SubspaceMaximumDistance |
Maximum distance function between NumberVectors only in specified
dimensions. |
| SubspaceMaximumDistance.Par |
Parameterization class.
|
| SubspaceModel |
Model for Subspace Clusters.
|
| SubtypeIt<O> |
Filtered iterator.
|
| SupportVectorClustering |
Support Vector Clustering works on SVDD, which tries to find the smallest
sphere enclosing all objects in kernel space.
|
| SURFINGDependence |
Compute the similarity of dimensions using the SURFING score.
|
| SURFINGDependence.Par |
Parameterization class.
|
| SVC_Q |
Q matrix used by CSVC and NuSVC classification. |
| SVDD<V> |
Support Vector Data Description for outlier detection.
|
| SVDD |
Support Vector Data Description.
|
| SVDD.RadiusAcceptor |
|
| SVGArrow |
Static class for drawing simple arrows
|
| SVGArrow.Direction |
Direction constants
|
| SVGButton |
Class to draw a button as SVG.
|
| SVGCheckbox |
SVG checkbox.
|
| SVGCloneVisible |
Clone visible parts of an SVG document.
|
| SVGEffects |
Class containing some popular SVG effects.
|
| SVGHyperCube |
Utility class to draw hypercubes, wireframe and filled.
|
| SVGHyperSphere |
Utility class to draw hypercubes, wireframe and filled.
|
| SVGPath |
Element used for building an SVG path using a string buffer.
|
| SVGPlot |
Base class for SVG plots.
|
| SVGSaveDialog |
A save dialog to save/export a SVG image to a file.
|
| SVGScoreBar |
Draw a score bar.
|
| SVGSimpleLinearAxis |
Class to draw a simple axis with tick marks on the plot.
|
| SVGSimpleLinearAxis.Alignment |
Flag for axis label position.
|
| SVGSimpleLinearAxis.LabelStyle |
Labeling style: left-handed, right-handed, no ticks, labels at ends
|
| SVGUtil |
Utility class for SVG processing.
|
| SVR_Q |
|
| SweepHullDelaunay2D |
Compute the Convex Hull and/or Delaunay Triangulation, using the sweep-hull
approach of David Sinclair.
|
| SweepHullDelaunay2D.Orientation |
The possible orientations two triangles can have to each other.
|
| SweepHullDelaunay2D.Triangle |
Class representing a triangle, by referencing points in a list.
|
| TermFrequencyParser<V extends SparseNumberVector> |
A parser to load term frequency data, which essentially are sparse vectors
with text keys.
|
| TermFrequencyParser.Par<V extends SparseNumberVector> |
Parameterization class.
|
| TextbookMultivariateGaussianModel |
Numerically problematic implementation of the GMM model, using the textbook
algorithm.
|
| TextbookMultivariateGaussianModelFactory |
Factory for EM with multivariate Gaussian model, using the textbook
algorithm.
|
| TextbookSphericalGaussianModel |
Simple spherical Gaussian cluster.
|
| TextbookSphericalGaussianModelFactory |
Factory for EM with multivariate gaussian models using a single variance.
|
| TextParameterConfigurator |
Provide a configuration panel to input an arbitrary text parameter.
|
| TextWriteable |
Interface for objects providing a text serialization suitable for
human reading and storage in CSV files.
|
| TextWriter |
Class to write a result to human-readable text output.
|
| TextWriterConfusionMatrixResult |
Write a classification evaluation to a text file.
|
| TextWriterDoubleArray |
Write a double array.
|
| TextWriterDoubleDoublePair |
Write a pair
|
| TextWriterIgnore |
Ignore the given object when serializing to text.
|
| TextWriterIntArray |
Write a double array.
|
| TextWriterObjectArray<T> |
Write an object into the inline section, using the objects toString method.
|
| TextWriterObjectComment |
Write an object into the comments section, using the objects toString()
method.
|
| TextWriterObjectInline |
Write an object into the inline section, using the objects toString method.
|
| TextWriterPair |
Write a pair
|
| TextWriterStream |
Representation of an output stream to a text file.
|
| TextWriterTextWriteable |
|
| TextWriterWriterInterface<O> |
Base class for object writers.
|
| TextWriterXYCurve |
Serialize an XYCurve to text.
|
| ThumbnailRegistryEntry |
Access images via an internal image registry.
|
| ThumbnailRegistryEntry.InternalParsedURLData |
URL representation for internal URLs.
|
| ThumbnailThread |
Thread to render thumbnails in the background.
|
| ThumbnailThread.Listener |
Listener interface for completed thumbnails.
|
| ThumbnailThread.Task |
A single thumbnailer task.
|
| ThumbnailTranscoder |
Transcode images to in-memory thumbnails.
|
| ThumbnailVisualization |
Thumbnail visualization.
|
| TightLIDEstimator |
TightLID Estimator (TLE) of the intrinsic dimensionality (maximum likelihood
estimator for ID using auxiliary distances).
|
| TightLIDEstimator.Par |
Parameterization class.
|
| Title |
Simple interface to provide a nicer title for the class.
|
| TokenizedReader |
Reader that will tokenize the input data as desired.
|
| Tokenizer |
String tokenizer.
|
| TooltipScoreVisualization |
Generates a SVG-Element containing Tooltips.
|
| TooltipScoreVisualization.Par |
Parameterization class.
|
| TooltipStringVisualization |
Generates a SVG-Element containing Tooltips.
|
| TooltipStringVisualization.Instance |
Instance
|
| TooManyRetriesException |
Exception thrown when too many retries were attempted.
|
| TopKOutlierScaling |
Outlier scaling function that only keeps the top k outliers.
|
| TopKOutlierScaling.Par |
Parameterization class.
|
| TopologicalSplitter |
Encapsulates the required parameters for a topological split of a R*-Tree.
|
| TopologicalSplitter.Par |
Parameterization class.
|
| TopologicalSplitter.Split<A,E extends SpatialComparable> |
Internal data for an actual split.
|
| TrackedParameter |
Class containing an object, and the associated value.
|
| TrackParameters |
Utility wrapper to track parameters for a configuration session.
|
| TrainingAndTestSet |
Wrapper to hold a pair of training and test data sets.
|
| TreeIndexHeader |
Encapsulates the header information of a tree-like index structure.
|
| TreeMBRVisualization |
Visualize the bounding rectangles of an R-Tree based index.
|
| TreeMBRVisualization.Par |
Parameterization class.
|
| TreePopup |
Popup menu that contains a JTree.
|
| TreePopup.Renderer |
Tree cell render.
|
| TreeSphereVisualization |
Visualize the bounding sphere of a metric index.
|
| TreeSphereVisualization.Mode |
Drawing modes.
|
| TreeSphereVisualization.Par |
Parameterization class.
|
| TriangularDiscriminationDistance |
Triangular Discrimination has relatively tight upper and lower bounds to the
Jensen-Shannon divergence, but is much less expensive.
|
| TriangularDiscriminationDistance.Par |
Parameterization class, using the static instance.
|
| TriangularDistance |
Triangular Distance has relatively tight upper and lower bounds to the
(square root of the) Jensen-Shannon divergence, but is much less expensive.
|
| TriangularDistance.Par |
Parameterization class, using the static instance.
|
| TriangularKernelDensityFunction |
Triangular kernel density estimator.
|
| TriangularKernelDensityFunction.Par |
Parameterization stub.
|
| TricubeKernelDensityFunction |
Tricube kernel density estimator.
|
| TricubeKernelDensityFunction.Par |
Parameterization stub.
|
| TrimmedEstimator<D extends Distribution> |
Trimmed wrapper around other estimators.
|
| TrimmedMeanApproach<N> |
A Trimmed Mean Approach to Finding Spatial Outliers.
|
| TrivialAllInOne |
Trivial pseudo-clustering that just considers all points to be one big
cluster.
|
| TrivialAllNoise |
Trivial pseudo-clustering that just considers all points to be noise.
|
| TrivialAllOutlier |
Trivial method that claims all objects to be outliers.
|
| TrivialAverageCoordinateOutlier |
Trivial method that takes the average of all dimensions (for one-dimensional
data that is just the actual value!)
|
| TrivialDBIDFactory |
Trivial DBID management, that never reuses IDs and just gives them out in
sequence.
|
| TrivialGeneratedOutlier |
Extract outlier score from the model the objects were generated by.
|
| TrivialGeneratedOutlier.Par |
Parameterization class.
|
| TrivialNoOutlier |
Trivial method that claims to find no outliers.
|
| TriweightKernelDensityFunction |
Triweight kernel density estimator.
|
| TriweightKernelDensityFunction.Par |
Parameterization stub.
|
| TSNE<O> |
t-Stochastic Neighbor Embedding is a projection technique designed for
visualization that tries to preserve the nearest neighbor structure.
|
| TutorialDistance |
Tutorial distance function example for ELKI.
|
| TwoPassMultivariateGaussianModel |
Model for a single Gaussian cluster, using two-passes for slightly better
numerics.
|
| TwoPassMultivariateGaussianModelFactory |
Factory for EM with multivariate Gaussian models (with covariance; also known
as Gaussian Mixture Modeling, GMM).
|
| TypeInformation |
Class wrapping a particular data type.
|
| TypeInformationSerializer |
Class to handle the serialization and deserialization of type information.
|
| TypeInformationSerializer.SimpleTypeSerializer |
Serialization class for pure simple types.
|
| TypeInformationSerializer.VectorFieldTypeSerializer |
Serialization class for field vector types.
|
| TypeInformationSerializer.VectorTypeSerializer |
Serialization class for non-field vector types.
|
| TypeUtil |
Utility package containing various common types.
|
| UKMeans |
Uncertain K-Means clustering, using the average deviation from the center.
|
| UKMeans.Par |
Parameterization class.
|
| UncenteredCorrelationDistance |
Uncentered correlation distance.
|
| UncenteredCorrelationDistance.Par |
Parameterization class.
|
| UncertainBoundingBoxVisualization |
Visualize uncertain objects by their bounding box.
|
| UncertainBoundingBoxVisualization.Instance |
Instance.
|
| Uncertainifier<UO extends UncertainObject> |
Class to derive uncertain object from exact vectors.
|
| UncertainifyFilter<UO extends UncertainObject> |
Filter class to transform a database containing vector fields into a database
containing UncertainObject fields by invoking a
Uncertainifier on each vector. |
| UncertainifyFilter.Par<UO extends UncertainObject> |
Parameterization class.
|
| UncertainInstancesVisualization |
Visualize a single derived sample from an uncertain database.
|
| UncertainInstancesVisualization.Instance |
Instance.
|
| UncertainObject |
Interface for uncertain objects.
|
| UncertainSamplesVisualization |
Visualize uncertain objects by multiple samples.
|
| UncertainSplitFilter |
Filter to transform a single vector into a set of samples to interpret as
uncertain observation.
|
| UncertainSplitFilter.Par |
Parameterization class.
|
| UniformContinuousUncertainObject |
Continuous uncertain object model using a uniform distribution on the
bounding box.
|
| UniformContinuousUncertainObject.Factory |
Factory class for this data type.
|
| UniformDistribution |
Uniform distribution.
|
| UniformDistribution.Par |
Parameterization class
|
| UniformEnhancedMinMaxEstimator |
Slightly improved estimation, that takes sample size into account and
enhances the interval appropriately.
|
| UniformEnhancedMinMaxEstimator.Par |
Parameterization class.
|
| UniformKernelDensityFunction |
Uniform / Rectangular kernel density estimator.
|
| UniformKernelDensityFunction.Par |
Parameterization stub.
|
| UniformLMMEstimator |
Estimate the parameters of a normal distribution using the method of
L-Moments (LMM).
|
| UniformLMMEstimator.Par |
Parameterization class.
|
| UniformMADEstimator |
Estimate Uniform distribution parameters using Median and MAD.
|
| UniformMADEstimator.Par |
Parameterization class.
|
| UniformMinMaxEstimator |
Estimate the uniform distribution by computing min and max.
|
| UniformMinMaxEstimator.Par |
Parameterization class.
|
| UniformUncertainifier |
Factory class.
|
| UniformUncertainifier.Par |
Parameterizer class.
|
| UnionFind |
Union-find implementations in ELKI, for DBID objects.
|
| UnionFindUtil |
Union-find algorithm factory, to choose the best implementation.
|
| UnmodifiableIntegerArrayDBIDs |
Unmodifiable wrapper for DBIDs.
|
| UnmodifiableIntegerArrayDBIDs.Itr |
Make an existing DBIDMIter unmodifiable.
|
| UnmodifiableIntegerDBIDs |
Unmodifiable wrapper for DBIDs.
|
| UnmodifiableIntegerDBIDs.UnmodifiableDBIDIter |
Make an existing DBIDMIter unmodifiable.
|
| UnParameterization |
Parameterization handler that doesn't set any parameters.
|
| UnspecifiedParameterException |
Exception when a required parameter was not given.
|
| UnsynchronizedLongCounter |
Class to count events in a thread-safe counter.
|
| UnweightedDiscreteUncertainifier |
Class to generate unweighted discrete uncertain objects.
|
| UnweightedDiscreteUncertainifier.Par |
Parameterization class.
|
| UnweightedDiscreteUncertainObject |
Unweighted implementation of discrete uncertain objects.
|
| UnweightedDiscreteUncertainObject.Factory |
Factory class for this data type.
|
| UnweightedNeighborhoodAdapter |
Adapter to use unweighted neighborhoods in an algorithm that requires
weighted neighborhoods.
|
| UnweightedNeighborhoodAdapter.Factory<O> |
Factory class
|
| UpdatableDatabase |
Database API with updates.
|
| UpdatableHeap<O> |
A heap as used in OPTICS that allows updating entries.
|
| UpdateRunner |
Class to handle updates to an SVG plot, in particular when used in an Apache
Batik UI.
|
| UpdateSynchronizer |
API to synchronize updates
|
| Util |
This class collects various static helper methods.
|
| VAFile<V extends NumberVector> |
Vector-approximation file (VAFile)
|
| VAFile.Factory<V extends NumberVector> |
Index factory class.
|
| VAFile.Factory.Par |
Parameterization class.
|
| ValidateApproximativeKNNIndex<O> |
Algorithm to validate the quality of an approximative kNN index, by
performing a number of queries and comparing them to the results obtained by
exact indexing (e.g., linear scanning).
|
| VALPNormDistance |
Lp-Norm distance function for partially computed objects.
|
| VarianceIncreaseDistance |
Variance increase distance.
|
| VarianceIncreaseDistance |
Variance increase distance.
|
| VarianceIncreaseDistance.Par |
Parameterization class.
|
| VarianceIncreaseDistance.Par |
Parameterization class.
|
| VarianceOfVolume<O extends SpatialComparable> |
Variance of Volume for outlier detection.
|
| VarianceRatioCriterion |
Compute the Variance Ratio Criterion of a data set, also known as
Calinski-Harabasz index.
|
| VarianceRatioCriterion.Par |
Parameterization class.
|
| VarianceWeight |
Variance-based weighting scheme for k-means clustering with BETULA.
|
| VectorApproximation |
Object in a VA approximation.
|
| VectorDimensionalityFilter<V extends NumberVector> |
Filter to remove all vectors that do not have the desired dimensionality.
|
| VectorFieldTypeInformation<V extends FeatureVector<?>> |
Type information to specify that a type has a fixed dimensionality.
|
| VectorTypeInformation<V extends FeatureVector<?>> |
Construct a type information for vector spaces with variable dimensionality.
|
| VectorUtil |
Utility functions for use with vectors.
|
| VectorUtil.SortDBIDsBySingleDimension |
Compare number vectors by a single dimension.
|
| VectorUtil.SortVectorsBySingleDimension |
Compare number vectors by a single dimension.
|
| VIIFeature |
Clustering Feature of stable BIRCH with a single variance per cluster
feature
|
| VIIFeature.Factory |
Factory for making cluster features.
|
| VIIFeature.Factory.Par |
Parameterization class.
|
| VisFactory |
Defines the requirements for a visualizer.
|
| Visualization |
Base class for a materialized Visualization.
|
| VisualizationItem |
Currently an empty interface for visualization items, that serves the purpose
of improving type safety.
|
| VisualizationListener |
Listener for visualization events.
|
| VisualizationMenuAction |
Visualizer actions.
|
| VisualizationMenuToggle |
Toggle action.
|
| VisualizationPlot |
SVG plot that allows visualization to schedule updates.
|
| VisualizationProcessor |
Visualization processor
|
| VisualizationTask |
Container class, with ugly casts to reduce generics crazyness.
|
| VisualizationTask.RenderFlag |
Rendering flags enum.
|
| VisualizationTask.UpdateFlag |
Update flags enum.
|
| VisualizationTree |
Tree - actually a forest - to manage visualizations.
|
| VisualizeGeodesicDistances |
Visualization function for Cross-track, Along-track, and minimum distance
function.
|
| VisualizeGeodesicDistances.Mode |
Visualization mode.
|
| VisualizeGeodesicDistances.Par |
Parameterization class.
|
| VisualizePairwiseGainMatrix |
Class to load an outlier detection summary file, as produced by
ComputeKNNOutlierScores, and compute a matrix with the pairwise
gains. |
| VisualizePairwiseGainMatrix.Par |
Parameterization class.
|
| VisualizerContext |
Map to store context information for the visualizer.
|
| VisualizerParameterizer |
Utility class to determine the visualizers for a result class.
|
| VisualizerParameterizer.Par |
Parameterization class.
|
| VMath |
Class providing basic vector mathematics, for low-level vectors stored as
double[].
|
| VoronoiDraw |
Draw the Voronoi cells
|
| VoronoiVisualization |
Visualizer drawing Voronoi cells for k-means clusterings.
|
| VoronoiVisualization.Mode |
Visualization mode.
|
| VoronoiVisualization.Par |
Parameterization class.
|
| VPTree<O> |
Vantage Point Tree with no additional information
|
| VPTree.Factory<O extends NumberVector> |
Index factory for the VP-Tree
|
| VPTree.Factory.Par<O extends NumberVector> |
Parameterization class.
|
| VPTree.Node |
The Node Class saves the important information for the each Node
|
| VPTree.VPTreeKNNSearcher |
kNN search for the VP-Tree.
|
| VPTree.VPTreeRangeSearcher |
Range search for the VP-tree.
|
| VVIFeature |
Clustering Feature of stable BIRCH with variance per dimension
|
| VVIFeature.Factory |
Factory for making cluster features.
|
| VVIFeature.Factory.Par |
Parameterization class.
|
| VVVFeature |
Clustering Feature of stable BIRCH with covariance instead of variance
|
| VVVFeature.Factory |
Factory for making cluster features.
|
| VVVFeature.Factory.Par |
Parameterization class.
|
| WardLinkage |
Ward's method clustering method.
|
| WardLinkage.Par |
Class parameterizer.
|
| WeakEigenPairFilter |
The WeakEigenPairFilter sorts the eigenpairs in descending order of their
eigenvalues and returns the first eigenpairs who are above the average mark
as "strong", the others as "weak".
|
| WeakEigenPairFilter.Par |
Parameterization class.
|
| WeibullDistribution |
Weibull distribution.
|
| WeibullDistribution.Par |
Parameterization class
|
| WeibullLMMEstimator |
Estimate parameters of the Weibull distribution using the method of L-Moments
(LMM).
|
| WeibullLMMEstimator.Par |
Parameterization class.
|
| WeibullLogMADEstimator |
Parameter estimation via median and median absolute deviation from median
(MAD).
|
| WeibullLogMADEstimator.Par |
Parameterization class.
|
| WeightedAverageLinkage |
Weighted average linkage clustering method (WPGMA).
|
| WeightedAverageLinkage.Par |
Class parameterizer.
|
| WeightedCanberraDistance |
Weighted Canberra distance function, a variation of Manhattan distance.
|
| WeightedCanberraDistance.Par |
Parameterization class.
|
| WeightedCovarianceMatrixBuilder |
|
| WeightedCovarianceMatrixBuilder.Par |
Parameterization class.
|
| WeightedDiscreteUncertainifier |
Class to generate weighted discrete uncertain objects.
|
| WeightedDiscreteUncertainifier.Par |
Parameterization class.
|
| WeightedDiscreteUncertainObject |
Weighted version of discrete uncertain objects.
|
| WeightedDiscreteUncertainObject.Factory |
Factory class for this data type.
|
| WeightedEuclideanDistance |
|
| WeightedEuclideanDistance.Par |
Parameterization class.
|
| WeightedLPNormDistance |
Weighted version of the Minkowski L p norm distance for
NumberVector. |
| WeightedLPNormDistance.Par |
Parameterization class.
|
| WeightedManhattanDistance |
Weighted version of the Manhattan (L1) metric.
|
| WeightedManhattanDistance.Par |
Parameterization class.
|
| WeightedMaximumDistance |
Weighted version of the maximum distance function for
NumberVectors. |
| WeightedMaximumDistance.Par |
Parameterization class.
|
| WeightedNeighborSetPredicate |
Neighbor predicate with weight support.
|
| WeightedNeighborSetPredicate.Factory<O> |
Factory interface to produce instances.
|
| WeightedNumberVectorDistance<V> |
Distance functions where each dimension is assigned a weight.
|
| WeightedPearsonCorrelationDistance |
Pearson correlation distance function for feature vectors.
|
| WeightedPearsonCorrelationDistance.Par |
Parameterization class.
|
| WeightedQuickUnionInteger |
Union-find algorithm for primitive integers, with optimizations.
|
| WeightedQuickUnionRangeDBIDs |
Union-find algorithm for DBIDRange only, with optimizations. |
| WeightedQuickUnionStaticDBIDs |
Union-find algorithm for StaticDBIDs, with optimizations. |
| WeightedSquaredEuclideanDistance |
|
| WeightedSquaredEuclideanDistance.Par |
Parameterization class.
|
| WeightedSquaredPearsonCorrelationDistance |
Weighted squared Pearson correlation distance function for feature vectors.
|
| WeightedSquaredPearsonCorrelationDistance.Par |
Parameterization class.
|
| WeightedUncertainSplitFilter |
Filter to transform a single vector into a set of samples and weights to
interpret as uncertain observation.
|
| WeightedUncertainSplitFilter.Par |
Parameterization class.
|
| WeightFunction |
WeightFunction interface that allows the use of various distance-based weight
functions.
|
| WelchTTest |
Calculates a test statistic according to Welch's t test for two samples
Supplies methods for calculating the degrees of freedom according to the
Welch-Satterthwaite Equation.
|
| WelchTTest.Par |
Parameterizer, to use the static instance.
|
| WGS72SpheroidEarthModel |
The WGS72 spheroid earth model, without height model.
|
| WGS72SpheroidEarthModel.Par |
Parameterization class.
|
| WGS84SpheroidEarthModel |
The WGS84 spheroid earth model, without height model (so not a geoid, just a
spheroid!)
|
| WGS84SpheroidEarthModel.Par |
Parameterization class.
|
| WinsorizingEstimator<D extends Distribution> |
Winsorizing or Georgization estimator.
|
| WithinClusterMeanDistance |
Class for computing the average overall distance.
|
| WithinClusterVariance |
Class for computing the variance in a clustering result (sum-of-squares).
|
| WorkflowStep |
Trivial interface for workflow steps.
|
| WrappedKNNDBIDByLookup<O> |
Find nearest neighbors by querying with the original object.
|
| WrappedKNNDBIDByLookup.Linear<O> |
Linear scan searcher.
|
| WrappedPrioritySearchDBIDByLookup<O> |
Find nearest neighbors by querying with the original object.
|
| WrappedPrioritySearchDBIDByLookup.Linear<O> |
Linear scan searcher.
|
| WrappedRangeDBIDByLookup<O> |
Find radius neighbors by querying with the original object.
|
| WrappedRangeDBIDByLookup.Linear<O> |
Linear scan searcher.
|
| WrappedRKNNDBIDByLookup<O> |
Find nearest neighbors by querying with the original object.
|
| WrappedRKNNDBIDByLookup.Linear<O> |
Linear scan searcher.
|
| WritableDataStore<T> |
Writable data store.
|
| WritableDBIDDataStore |
Data store specialized for doubles.
|
| WritableDoubleDataStore |
Data store specialized for doubles.
|
| WritableIntegerDataStore |
Data store specialized for doubles.
|
| WritableRecordStore |
Represents a storage which stores multiple values per object in a record fashion.
|
| WriteDataStoreProcessor<T> |
|
| WriteDoubleDataStoreProcessor |
|
| WriteIntegerDataStoreProcessor |
|
| WrongParameterValueException |
Thrown by a Parameterizable object in case of wrong parameter format.
|
| XMeans<V extends NumberVector,M extends MeanModel> |
X-means: Extending K-means with Efficient Estimation on the Number of
Clusters.
|
| XMLNodeIterator |
Simple adapter class to iterate over a DOM tree nodes children.
|
| XMLNodeListIterator |
Simple adapter class to iterate over a DOM tree nodes children.
|
| Xoroshiro128NonThreadsafeRandom |
Replacement for Java's Random class, using a different
random number generation strategy.
|
| XorShift1024NonThreadsafeRandom |
Replacement for Java's Random class, using a different
random number generation strategy.
|
| XorShift64NonThreadsafeRandom |
Replacement for Java's Random class, using a different
random number generation strategy.
|
| XYCurve |
An XYCurve is an ordered collection of 2d points, meant for chart generation.
|
| XYCurveVisualization |
Visualizer to render a simple 2D curve such as a ROC curve.
|
| XYPlot |
An XYCurve is an ordered collection of 2d XYPlot.Curves, meant for chart
generation. |
| XYPlotVisualization |
Visualizer to render a simple 2D curve such as a ROC curve.
|
| YinYangKMeans<V extends NumberVector> |
Yin-Yang k-Means Clustering.
|
| YinYangKMeans.Instance |
Instance for a particular data set.
|
| YinYangKMeans.Par<V extends NumberVector> |
Parameterization class.
|
| YulesQ |
Yule's Q interestingness measure.
|
| YulesY |
Yule's Y interestingness measure.
|
| ZCurveSpatialSorter |
Class to sort the data set by their Z-index, without doing a full
materialization of the Z indexes.
|
| ZCurveSpatialSorter.Par |
Parameterization class.
|
| ZCurveTransformer |
Class to transform a relation to its Z coordinates.
|
| ZipfEstimator |
Zipf estimator (qq-estimator) of the intrinsic dimensionality.
|
| ZipfEstimator.Par |
Parameterization class.
|