|
|
|||||||||||||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Database | |
---|---|
de.lmu.ifi.dbs.elki.algorithm | Algorithms suitable as a task for the KDDTask main routine. |
de.lmu.ifi.dbs.elki.algorithm.clustering | Clustering algorithms
Clustering algorithms are supposed to implement the Algorithm -Interface. |
de.lmu.ifi.dbs.elki.algorithm.clustering.correlation | Correlation clustering algorithms |
de.lmu.ifi.dbs.elki.algorithm.clustering.correlation.cash | Helper classes for the CASH algorithm. |
de.lmu.ifi.dbs.elki.algorithm.clustering.subspace | Axis-parallel subspace clustering algorithms The clustering algorithms in this package are instances of both, projected clustering algorithms or subspace clustering algorithms according to the classical but somewhat obsolete classification schema of clustering algorithms for axis-parallel subspaces. |
de.lmu.ifi.dbs.elki.algorithm.clustering.subspace.clique | Helper classes for the CLIQUE algorithm. |
de.lmu.ifi.dbs.elki.algorithm.outlier | Outlier detection algorithms |
de.lmu.ifi.dbs.elki.algorithm.statistics | Statistical analysis algorithms The algorithms in this package perform statistical analysis of the data (e.g. compute distributions, distance distributions etc.) |
de.lmu.ifi.dbs.elki.application.visualization | Visualization applications in ELKI. |
de.lmu.ifi.dbs.elki.data.model | Cluster models classes for various algorithms. |
de.lmu.ifi.dbs.elki.database | ELKI database layer - loading, storing, indexing and accessing data |
de.lmu.ifi.dbs.elki.database.connection | Database connections are classes implementing data sources. |
de.lmu.ifi.dbs.elki.distance | Distances and (in subpackages) distance functions and similarity functions . |
de.lmu.ifi.dbs.elki.distance.distancefunction | Distance functions for use within ELKI. |
de.lmu.ifi.dbs.elki.distance.distancefunction.adapter | Distance functions deriving distances from e.g. similarity measures |
de.lmu.ifi.dbs.elki.distance.similarityfunction | Similarity functions. |
de.lmu.ifi.dbs.elki.distance.similarityfunction.kernel | Kernel functions. |
de.lmu.ifi.dbs.elki.evaluation | Functionality for the evaluation of algorithms. |
de.lmu.ifi.dbs.elki.index | Index structure implementations |
de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants | M-Tree and variants. |
de.lmu.ifi.dbs.elki.index.tree.spatial | Tree-based index structures for spatial indexing. |
de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.rdknn | RdKNNTree |
de.lmu.ifi.dbs.elki.math.linearalgebra.pca | Principal Component Analysis (PCA) and Eigenvector processing. |
de.lmu.ifi.dbs.elki.preprocessing | Preprocessors used for data preparation in a first step of various algorithms or distance and similarity measures. |
de.lmu.ifi.dbs.elki.result | Result types, representation and handling |
de.lmu.ifi.dbs.elki.result.textwriter | Text serialization (CSV, Gnuplot, Console, ...) |
de.lmu.ifi.dbs.elki.utilities | Utility and helper classes - commonly used data structures, output formatting, exceptions, ... |
de.lmu.ifi.dbs.elki.visualization | Visualization package of ELKI. |
de.lmu.ifi.dbs.elki.visualization.scales | Scales handling for plotting. |
Uses of Database in de.lmu.ifi.dbs.elki.algorithm |
---|
Methods in de.lmu.ifi.dbs.elki.algorithm with parameters of type Database | |
---|---|
protected BitSet[] |
APRIORI.frequentItemsets(BitSet[] candidates,
Database<BitVector> database)
Returns the frequent BitSets out of the given BitSets with respect to the given database. |
CorrelationAnalysisSolution<V> |
DependencyDerivator.generateModel(Database<V> db,
Collection<Integer> ids)
Runs the pca on the given set of IDs. |
CorrelationAnalysisSolution<V> |
DependencyDerivator.generateModel(Database<V> db,
Collection<Integer> ids,
V centroidDV)
Runs the pca on the given set of IDs and for the given centroid. |
R |
Algorithm.run(Database<O> database)
Runs the algorithm. |
R |
AbstractAlgorithm.run(Database<O> database)
Calls the runInTime()-method of extending classes. |
protected AprioriResult |
APRIORI.runInTime(Database<BitVector> database)
Performs the APRIORI algorithm on the given database. |
protected abstract R |
AbstractAlgorithm.runInTime(Database<O> database)
The run method encapsulated in measure of runtime. |
protected KNNDistanceOrderResult<D> |
KNNDistanceOrder.runInTime(Database<O> database)
Provides an order of the kNN-distances for all objects within the specified database. |
protected Result |
DummyAlgorithm.runInTime(Database<V> database)
Iterates over all points in the database. |
protected Result |
NullAlgorithm.runInTime(Database<V> database)
Iterates over all points in the database. |
CorrelationAnalysisSolution<V> |
DependencyDerivator.runInTime(Database<V> db)
Computes quantitatively linear dependencies among the attributes of the given database based on a linear correlation PCA. |
protected AnnotationFromHashMap<KNNList<D>> |
KNNJoin.runInTime(Database<V> database)
Joins in the given spatial database to each object its k-nearest neighbors. |
protected CollectionResult<CTriple<Integer,Integer,Double>> |
MaterializeDistances.runInTime(Database<V> database)
Iterates over all points in the database. |
Uses of Database in de.lmu.ifi.dbs.elki.algorithm.clustering |
---|
Methods in de.lmu.ifi.dbs.elki.algorithm.clustering with parameters of type Database | |
---|---|
protected void |
EM.assignProbabilitiesToInstances(Database<V> database,
List<Double> normDistrFactor,
List<V> means,
List<Matrix> invCovMatr,
List<Double> clusterWeights)
Assigns the current probability values to the instances in the database. |
protected void |
SNNClustering.expandCluster(Database<O> database,
Integer startObjectID,
FiniteProgress objprog,
IndefiniteProgress clusprog)
DBSCAN-function expandCluster adapted to SNN criterion. |
protected void |
DBSCAN.expandCluster(Database<O> database,
Integer startObjectID,
FiniteProgress objprog,
IndefiniteProgress clusprog)
DBSCAN-function expandCluster. |
protected void |
ProjectedDBSCAN.expandCluster(Database<V> database,
Integer startObjectID,
FiniteProgress objprog,
IndefiniteProgress clusprog)
ExpandCluster function of DBSCAN. |
protected void |
OPTICS.expandClusterOrder(Database<O> database,
Integer objectID,
FiniteProgress progress)
OPTICS-function expandClusterOrder. |
protected double |
EM.expectationOfMixture(Database<V> database)
The expectation value of the current mixture of distributions. |
protected List<Integer> |
SNNClustering.findSNNNeighbors(Database<O> database,
Integer queryObject)
Returns the shared nearest neighbors of the specified query object in the given database. |
protected List<V> |
EM.initialMeans(Database<V> database)
Creates k random points distributed uniformly within the
attribute ranges of the given database. |
protected List<V> |
KMeans.means(List<List<Integer>> clusters,
List<V> means,
Database<V> database)
Returns the mean vectors of the given clusters in the given database. |
C |
ClusteringAlgorithm.run(Database<O> database)
Runs the algorithm. |
protected Clustering<Model> |
SNNClustering.runInTime(Database<O> database)
Performs the SNN clustering algorithm on the given database. |
protected ClusterOrderResult<D> |
DeLiClu.runInTime(Database<O> database)
Performs the DeLiClu algorithm on the given database. |
protected Clustering<Model> |
ByLabelClustering.runInTime(Database<O> database)
Run the actual clustering algorithm. |
protected Clustering<Model> |
DBSCAN.runInTime(Database<O> database)
Performs the DBSCAN algorithm on the given database. |
protected MultiResult |
SLINK.runInTime(Database<O> database)
Performs the SLINK algorithm on the given database. |
protected ClusterOrderResult<D> |
OPTICS.runInTime(Database<O> database)
Performs the OPTICS algorithm on the given database. |
protected Clustering<Model> |
TrivialAllInOne.runInTime(Database<O> database)
Run the actual clustering algorithm. |
protected Clustering<Model> |
TrivialAllNoise.runInTime(Database<O> database)
Run the actual clustering algorithm. |
protected Clustering<Model> |
ByLabelHierarchicalClustering.runInTime(Database<O> database)
Run the actual clustering algorithm. |
protected Clustering<Model> |
ProjectedDBSCAN.runInTime(Database<V> database)
|
protected Clustering<EMModel<V>> |
EM.runInTime(Database<V> database)
Performs the EM clustering algorithm on the given database. |
protected Clustering<Model> |
KMeans.runInTime(Database<V> database)
Performs the k-means algorithm on the given database. |
protected List<List<Integer>> |
KMeans.sort(List<V> means,
Database<V> database)
Returns a list of clusters. |
Uses of Database in de.lmu.ifi.dbs.elki.algorithm.clustering.correlation |
---|
Fields in de.lmu.ifi.dbs.elki.algorithm.clustering.correlation declared as Database | |
---|---|
private Database<ParameterizationFunction> |
CASH.database
The database holding the objects. |
Fields in de.lmu.ifi.dbs.elki.algorithm.clustering.correlation with type parameters of type Database | |
---|---|
private ClassParameter<Database<V>> |
COPAC.PARTITION_DB_PARAM
Parameter to specify the database class for each partition, must extend Database . |
private Class<? extends Database<V>> |
COPAC.partitionDatabase
Holds the instance of the partition database specified by COPAC.PARTITION_DB_PARAM . |
Methods in de.lmu.ifi.dbs.elki.algorithm.clustering.correlation that return Database | |
---|---|
private Database<ParameterizationFunction> |
CASH.buildDB(int dim,
Matrix basis,
Set<Integer> ids,
Database<ParameterizationFunction> database)
Builds a dim-1 dimensional database where the objects are projected into the specified subspace. |
private Database<DoubleVector> |
CASH.buildDerivatorDB(Database<ParameterizationFunction> database,
CASHInterval interval)
Builds a database for the derivator consisting of the ids in the specified interval. |
private Database<DoubleVector> |
CASH.buildDerivatorDB(Database<ParameterizationFunction> database,
Set<Integer> ids)
Builds a database for the derivator consisting of the ids in the specified interval. |
Methods in de.lmu.ifi.dbs.elki.algorithm.clustering.correlation with parameters of type Database | |
---|---|
private void |
ORCLUS.assign(Database<V> database,
List<ORCLUS.ORCLUSCluster> clusters)
Creates a partitioning of the database by assigning each object to its closest seed. |
private Database<ParameterizationFunction> |
CASH.buildDB(int dim,
Matrix basis,
Set<Integer> ids,
Database<ParameterizationFunction> database)
Builds a dim-1 dimensional database where the objects are projected into the specified subspace. |
private Database<DoubleVector> |
CASH.buildDerivatorDB(Database<ParameterizationFunction> database,
CASHInterval interval)
Builds a database for the derivator consisting of the ids in the specified interval. |
private Database<DoubleVector> |
CASH.buildDerivatorDB(Database<ParameterizationFunction> database,
Set<Integer> ids)
Builds a database for the derivator consisting of the ids in the specified interval. |
private double[] |
CASH.determineMinMaxDistance(Database<ParameterizationFunction> database,
int dimensionality)
Determines the minimum and maximum function value of all parameterization functions stored in the specified database. |
private Clustering<Model> |
CASH.doRun(Database<ParameterizationFunction> database,
FiniteProgress progress)
Runs the CASH algorithm on the specified database, this method is recursively called until only noise is left. |
private SortedMap<Integer,List<Cluster<CorrelationModel<V>>>> |
ERiC.extractCorrelationClusters(Database<V> database,
int dimensionality)
Extracts the correlation clusters and noise from the copac result and returns a mapping of correlation dimension to maps of clusters within this correlation dimension. |
private Matrix |
ORCLUS.findBasis(Database<V> database,
ORCLUS.ORCLUSCluster cluster,
int dim)
Finds the basis of the subspace of dimensionality dim for
the specified cluster. |
private Set<Integer> |
CASH.getDatabaseIDs(Database<ParameterizationFunction> database)
Returns the set of ids belonging to the specified database. |
private void |
CASH.initHeap(DefaultHeap<Integer,CASHInterval> heap,
Database<ParameterizationFunction> database,
int dim,
Set<Integer> ids)
Initializes the heap with the root intervals. |
private List<ORCLUS.ORCLUSCluster> |
ORCLUS.initialSeeds(Database<V> database,
int k)
Initializes the list of seeds wit a random sample of size k. |
private void |
ORCLUS.merge(Database<V> database,
List<ORCLUS.ORCLUSCluster> clusters,
int k_new,
int d_new)
Reduces the number of seeds to k_new |
private ORCLUS.ProjectedEnergy |
ORCLUS.projectedEnergy(Database<V> database,
ORCLUS.ORCLUSCluster c_i,
ORCLUS.ORCLUSCluster c_j,
int i,
int j,
int dim)
Computes the projected energy of the specified clusters. |
private Matrix |
CASH.runDerivator(Database<ParameterizationFunction> database,
int dim,
CASHInterval interval,
Set<Integer> ids)
Runs the derivator on the specified interval and assigns all points having a distance less then the standard deviation of the derivator model to the model to this model. |
private LinearEquationSystem |
CASH.runDerivator(Database<ParameterizationFunction> database,
int dimensionality,
Set<Integer> ids)
Runs the derivator on the specified interval and assigns all points having a distance less then the standard deviation of the derivator model to the model to this model. |
protected Clustering<Model> |
CASH.runInTime(Database<ParameterizationFunction> database)
Performs the CASH algorithm on the given database. |
protected Clustering<CorrelationModel<V>> |
ERiC.runInTime(Database<V> database)
Performs the ERiC algorithm on the given database. |
protected Clustering<Model> |
ORCLUS.runInTime(Database<V> database)
Performs the ORCLUS algorithm on the given database. |
protected Clustering<Model> |
COPAC.runInTime(Database<V> database)
Performs the COPAC algorithm on the given database. |
private void |
COPAC.runPartitionAlgorithm(Database<V> database,
Map<Integer,List<Integer>> partitionMap)
Runs the partition algorithm and creates the result. |
private ORCLUS.ORCLUSCluster |
ORCLUS.union(Database<V> database,
ORCLUS.ORCLUSCluster c1,
ORCLUS.ORCLUSCluster c2,
int dim)
Returns the union of the two specified clusters. |
Uses of Database in de.lmu.ifi.dbs.elki.algorithm.clustering.correlation.cash |
---|
Fields in de.lmu.ifi.dbs.elki.algorithm.clustering.correlation.cash declared as Database | |
---|---|
private Database<ParameterizationFunction> |
CASHIntervalSplit.database
The database storing the parameterization functions. |
Constructors in de.lmu.ifi.dbs.elki.algorithm.clustering.correlation.cash with parameters of type Database | |
---|---|
CASHIntervalSplit(Database<ParameterizationFunction> database,
int minPts)
Initializes the logger and sets the debug status to the given value. |
Uses of Database in de.lmu.ifi.dbs.elki.algorithm.clustering.subspace |
---|
Methods in de.lmu.ifi.dbs.elki.algorithm.clustering.subspace with parameters of type Database | |
---|---|
private Map<Integer,PROCLUS.PROCLUSCluster> |
PROCLUS.assignPoints(Map<Integer,Set<Integer>> dimensions,
Database<V> database)
Assigns the objects to the clusters. |
private double |
PROCLUS.avgDistance(V centroid,
Set<Integer> objectIDs,
Database<V> database,
int dimension)
Computes the average distance of the objects to the centroid along the specified dimension. |
private void |
DiSH.buildHierarchy(Database<V> database,
DiSHDistanceFunction<V,DiSHPreprocessor<V,?>> distanceFunction,
List<Cluster<AxesModel>> clusters,
int dimensionality)
Builds the cluster hierarchy |
private void |
DiSH.checkClusters(Database<V> database,
DiSHDistanceFunction<V,DiSHPreprocessor<V,?>> distanceFunction,
Map<BitSet,List<Pair<BitSet,DatabaseObjectGroupCollection<List<Integer>>>>> clustersMap)
Removes the clusters with size < minpts from the cluster map and adds them to their parents. |
private void |
DiSH.computeClusters(Database<V> database,
ClusterOrderResult<PreferenceVectorBasedCorrelationDistance> clusterOrder)
Computes the hierarchical clusters according to the cluster order. |
private Map<CLIQUESubspace<V>,Set<Integer>> |
CLIQUE.determineClusters(Database<V> database,
SortedSet<CLIQUESubspace<V>> denseSubspaces)
Determines the clusters in the specified dense subspaces. |
private double |
PROCLUS.evaluateClusters(Map<Integer,PROCLUS.PROCLUSCluster> clusters,
Map<Integer,Set<Integer>> dimensions,
Database<V> database)
Evaluates the quality of the clusters. |
private Map<BitSet,List<Pair<BitSet,DatabaseObjectGroupCollection<List<Integer>>>>> |
DiSH.extractClusters(Database<V> database,
DiSHDistanceFunction<V,DiSHPreprocessor<V,?>> distanceFunction,
ClusterOrderResult<PreferenceVectorBasedCorrelationDistance> clusterOrder)
Extracts the clusters from the cluster order. |
private SortedSet<CLIQUESubspace<V>> |
CLIQUE.findDenseSubspaceCandidates(Database<V> database,
Set<CLIQUESubspace<V>> denseSubspaces)
Determines the k-dimensional dense subspace candidates. |
private SortedSet<CLIQUESubspace<V>> |
CLIQUE.findDenseSubspaces(Database<V> database,
SortedSet<CLIQUESubspace<V>> denseSubspaces)
Determines the k>1 dimensional dense subspaces and performs a pruning if this option is chosen. |
private Map<Integer,Set<Integer>> |
PROCLUS.findDimensions(Set<Integer> medoids,
Database<V> database)
Determines the set of correlated dimensions for each medoid in the specified medoid set. |
private SortedSet<CLIQUESubspace<V>> |
CLIQUE.findOneDimensionalDenseSubspaceCandidates(Database<V> database)
Determines the one-dimensional dense subspace candidates by making a pass over the database. |
private SortedSet<CLIQUESubspace<V>> |
CLIQUE.findOneDimensionalDenseSubspaces(Database<V> database)
Determines the one dimensional dense subspaces and performs a pruning if this option is chosen. |
private Pair<BitSet,DatabaseObjectGroupCollection<List<Integer>>> |
DiSH.findParent(Database<V> database,
DiSHDistanceFunction<V,DiSHPreprocessor<V,?>> distanceFunction,
Pair<BitSet,DatabaseObjectGroupCollection<List<Integer>>> child,
Map<BitSet,List<Pair<BitSet,DatabaseObjectGroupCollection<List<Integer>>>>> clustersMap)
Returns the parent of the specified cluster |
private Map<Integer,List<DistanceResultPair<DoubleDistance>>> |
PROCLUS.getLocalities(Set<Integer> m_c,
Database<V> database)
Computes the localities of the specified medoids. |
private Collection<CLIQUEUnit<V>> |
CLIQUE.initOneDimensionalUnits(Database<V> database)
Initializes and returns the one dimensional units. |
private boolean |
DiSH.isParent(Database<V> database,
DiSHDistanceFunction<V,DiSHPreprocessor<V,?>> distanceFunction,
Cluster<AxesModel> parent,
List<Cluster<AxesModel>> children)
Returns true, if the specified parent cluster is a parent of one child of the children clusters. |
protected Clustering<AxesModel> |
DiSH.runInTime(Database<V> database)
Performs the DiSH algorithm on the given database. |
protected Clustering<Model> |
PROCLUS.runInTime(Database<V> database)
Performs the PROCLUS algorithm on the given database. |
protected Clustering<CLIQUESubspace<V>> |
CLIQUE.runInTime(Database<V> database)
Performs the CLIQUE algorithm on the given database. |
Uses of Database in de.lmu.ifi.dbs.elki.algorithm.clustering.subspace.clique |
---|
Methods in de.lmu.ifi.dbs.elki.algorithm.clustering.subspace.clique with parameters of type Database | |
---|---|
Map<CLIQUESubspace<V>,Set<Integer>> |
CLIQUESubspace.determineClusters(Database<V> database)
Determines all clusters in this subspace by performing a depth-first search algorithm to find connected dense units. |
Uses of Database in de.lmu.ifi.dbs.elki.algorithm.outlier |
---|
Methods in de.lmu.ifi.dbs.elki.algorithm.outlier with parameters of type Database | |
---|---|
private PriorityQueue<FCPair<Double,Integer>> |
ABOD.calcDistsandNN(Database<V> data,
KernelMatrix<V> kernelMatrix,
int sampleSize,
Integer aKey,
HashMap<Integer,Double> dists)
|
private PriorityQueue<FCPair<Double,Integer>> |
ABOD.calcDistsandRNDSample(Database<V> data,
KernelMatrix<V> kernelMatrix,
int sampleSize,
Integer aKey,
HashMap<Integer,Double> dists)
|
private void |
ABOD.generateExplanation(Database<V> data,
Integer key,
LinkedList<Integer> expList)
|
void |
ABOD.getExplanations(Database<V> data)
|
MultiResult |
ABOD.getFastRanking(Database<V> database,
int k,
int sampleSize)
Main part of the algorithm. |
private KNNList<DoubleDistance> |
SOD.getKNN(Database<V> database,
Integer queryObject)
Provides the k nearest neighbors in terms of the shared nearest neighbor distance. |
MultiResult |
ABOD.getRanking(Database<V> database,
int k)
Main part of the algorithm. |
protected MultiResult |
LOCI.runInTime(Database<O> database)
Runs the algorithm in the timed evaluation part. |
protected MultiResult |
LOF.runInTime(Database<O> database)
Performs the Generalized LOF_SCORE algorithm on the given database. |
protected MultiResult |
SOD.runInTime(Database<V> database)
Performs the SOD algorithm on the given database. |
protected MultiResult |
ABOD.runInTime(Database<V> database)
|
Constructors in de.lmu.ifi.dbs.elki.algorithm.outlier with parameters of type Database | |
---|---|
SODModel(Database<O> database,
List<Integer> neighborhood,
double alpha,
O queryObject)
|
Uses of Database in de.lmu.ifi.dbs.elki.algorithm.statistics |
---|
Methods in de.lmu.ifi.dbs.elki.algorithm.statistics with parameters of type Database | |
---|---|
private DoubleMinMax |
DistanceStatisticsWithClasses.exactMinMax(Database<V> database,
DistanceFunction<V,D> distFunc)
|
protected CollectionResult<DoubleVector> |
EvaluateRankingQuality.runInTime(Database<V> database)
Run the algorithm. |
protected CollectionResult<DoubleVector> |
RankingQualityHistogram.runInTime(Database<V> database)
Run the algorithm. |
protected CollectionResult<DoubleVector> |
DistanceStatisticsWithClasses.runInTime(Database<V> database)
Iterates over all points in the database. |
private DoubleMinMax |
DistanceStatisticsWithClasses.sampleMinMax(Database<V> database,
DistanceFunction<V,D> distFunc)
|
Uses of Database in de.lmu.ifi.dbs.elki.application.visualization |
---|
Fields in de.lmu.ifi.dbs.elki.application.visualization declared as Database | |
---|---|
protected Database<O> |
KNNExplorer.ExplorerWindow.db
|
Methods in de.lmu.ifi.dbs.elki.application.visualization with parameters of type Database | |
---|---|
void |
KNNExplorer.ExplorerWindow.run(Database<O> db,
DistanceFunction<O,N> distanceFunction)
|
Uses of Database in de.lmu.ifi.dbs.elki.data.model |
---|
Fields in de.lmu.ifi.dbs.elki.data.model declared as Database | |
---|---|
private Database<V> |
Bicluster.database
The database this bicluster is defined for. |
Methods in de.lmu.ifi.dbs.elki.data.model that return Database | |
---|---|
Database<V> |
Bicluster.getDatabase()
Getter to retrieve the database |
Constructors in de.lmu.ifi.dbs.elki.data.model with parameters of type Database | |
---|---|
Bicluster(int[] rowIDs,
int[] colIDs,
Database<V> database)
Defines a new bicluster for given parameters. |
|
BiclusterWithInverted(int[] rowIDs,
int[] colIDs,
Database<V> database)
|
|
CorrelationAnalysisSolution(LinearEquationSystem solution,
Database<V> db,
Matrix strongEigenvectors,
Matrix weakEigenvectors,
Matrix similarityMatrix,
Vector centroid)
Provides a new CorrelationAnalysisSolution holding the specified matrix. |
|
CorrelationAnalysisSolution(LinearEquationSystem solution,
Database<V> db,
Matrix strongEigenvectors,
Matrix weakEigenvectors,
Matrix similarityMatrix,
Vector centroid,
NumberFormat nf)
Provides a new CorrelationAnalysisSolution holding the specified matrix and number format. |
Uses of Database in de.lmu.ifi.dbs.elki.database |
---|
Classes in de.lmu.ifi.dbs.elki.database that implement Database | |
---|---|
class |
AbstractDatabase<O extends DatabaseObject>
Provides a mapping for associations based on a Hashtable and functions to get the next usable ID for insertion, making IDs reusable after deletion of the entry. |
class |
IndexDatabase<O extends DatabaseObject>
IndexDatabase is a database implementation which is supported by an index structure. |
class |
MetricalIndexDatabase<O extends DatabaseObject,D extends Distance<D>,N extends MetricalNode<N,E>,E extends MTreeEntry<D>>
MetricalIndexDatabase is a database implementation which is supported by a metrical index structure. |
class |
SequentialDatabase<O extends DatabaseObject>
SequentialDatabase is a simple implementation of a Database. |
class |
SpatialIndexDatabase<O extends NumberVector<O,?>,N extends SpatialNode<N,E>,E extends SpatialEntry>
SpatialIndexDatabase is a database implementation which is supported by a spatial index structure. |
Methods in de.lmu.ifi.dbs.elki.database that return Database | ||
---|---|---|
|
LabelsFromClustering.makeDatabaseFromClustering(Database<O> olddb,
R clustering,
Class<L> classLabel)
Retrieve a cloned database that - does not contain noise points - has labels assigned based on the given clustering Useful for e.g. training a classifier based on a clustering. |
Methods in de.lmu.ifi.dbs.elki.database that return types with arguments of type Database | ||
---|---|---|
|
PartitionsFromClustering.makeDatabasesFromClustering(Database<O> olddb,
R clustering)
Use an existing clustering to partition a database. |
|
|
PartitionsFromClustering.makeDatabasesFromClustering(Database<O> olddb,
R clustering,
Class<L> classLabel)
Use an existing clustering to partition a database. |
|
Map<Integer,Database<O>> |
Database.partition(Map<Integer,List<Integer>> partitions)
Returns a Map of partition IDs to Databases according to the specified Map of partition IDs to Lists of IDs. |
|
Map<Integer,Database<O>> |
AbstractDatabase.partition(Map<Integer,List<Integer>> partitions)
|
|
Map<Integer,Database<O>> |
Database.partition(Map<Integer,List<Integer>> partitions,
Class<? extends Database<O>> dbClass,
List<String> dbParameters)
Returns a Map of partition IDs to Databases of the specified class according to the specified Map of partition IDs to Lists of IDs. |
|
Map<Integer,Database<O>> |
AbstractDatabase.partition(Map<Integer,List<Integer>> partitions,
Class<? extends Database<O>> dbClass,
List<String> dbParameters)
|
Methods in de.lmu.ifi.dbs.elki.database with parameters of type Database | ||
---|---|---|
|
LabelsFromClustering.makeDatabaseFromClustering(Database<O> olddb,
R clustering,
Class<L> classLabel)
Retrieve a cloned database that - does not contain noise points - has labels assigned based on the given clustering Useful for e.g. training a classifier based on a clustering. |
|
|
PartitionsFromClustering.makeDatabasesFromClustering(Database<O> olddb,
R clustering)
Use an existing clustering to partition a database. |
|
|
PartitionsFromClustering.makeDatabasesFromClustering(Database<O> olddb,
R clustering,
Class<L> classLabel)
Use an existing clustering to partition a database. |
Method parameters in de.lmu.ifi.dbs.elki.database with type arguments of type Database | |
---|---|
Map<Integer,Database<O>> |
Database.partition(Map<Integer,List<Integer>> partitions,
Class<? extends Database<O>> dbClass,
List<String> dbParameters)
Returns a Map of partition IDs to Databases of the specified class according to the specified Map of partition IDs to Lists of IDs. |
Map<Integer,Database<O>> |
AbstractDatabase.partition(Map<Integer,List<Integer>> partitions,
Class<? extends Database<O>> dbClass,
List<String> dbParameters)
|
Constructors in de.lmu.ifi.dbs.elki.database with parameters of type Database | |
---|---|
DatabaseEvent(Database<? extends DatabaseObject> source,
List<Integer> objectIDs)
Used to create an event when database objects have been updated, inserted, or removed. |
Uses of Database in de.lmu.ifi.dbs.elki.database.connection |
---|
Fields in de.lmu.ifi.dbs.elki.database.connection declared as Database | |
---|---|
(package private) Database<O> |
AbstractDatabaseConnection.database
Holds the instance of the database specified by AbstractDatabaseConnection.DATABASE_PARAM . |
Fields in de.lmu.ifi.dbs.elki.database.connection with type parameters of type Database | |
---|---|
private ClassParameter<Database<O>> |
AbstractDatabaseConnection.DATABASE_PARAM
Parameter to specify the database to be provided by the parse method, must extend Database . |
Methods in de.lmu.ifi.dbs.elki.database.connection that return Database | |
---|---|
Database<MultiRepresentedObject<O>> |
MultipleFileBasedDatabaseConnection.getDatabase(Normalization<MultiRepresentedObject<O>> normalization)
|
Database<O> |
InputStreamDatabaseConnection.getDatabase(Normalization<O> normalization)
|
Database<O> |
DatabaseConnection.getDatabase(Normalization<O> normalization)
Returns a Database according to parameter settings. |
Uses of Database in de.lmu.ifi.dbs.elki.distance |
---|
Fields in de.lmu.ifi.dbs.elki.distance declared as Database | |
---|---|
private Database<O> |
AbstractMeasurementFunction.database
The database that holds the objects for which the measurements should be computed. |
Methods in de.lmu.ifi.dbs.elki.distance that return Database | |
---|---|
protected Database<O> |
AbstractMeasurementFunction.getDatabase()
Returns the database holding the objects for which the measurements should be computed. |
Methods in de.lmu.ifi.dbs.elki.distance with parameters of type Database | |
---|---|
void |
AbstractMeasurementFunction.setDatabase(Database<O> database,
boolean verbose,
boolean time)
|
void |
MeasurementFunction.setDatabase(Database<O> database,
boolean verbose,
boolean time)
Set the database that holds the associations for the DatabaseObject for which the measurements should be computed. |
Uses of Database in de.lmu.ifi.dbs.elki.distance.distancefunction |
---|
Methods in de.lmu.ifi.dbs.elki.distance.distancefunction with parameters of type Database | |
---|---|
void |
AbstractPreprocessorBasedDistanceFunction.setDatabase(Database<O> database,
boolean verbose,
boolean time)
Calls AbstractMeasurementFunction(database, verbose, time) and
runs the preprocessor on the database. |
void |
AbstractLocallyWeightedDistanceFunction.setDatabase(Database<O> database,
boolean verbose,
boolean time)
|
void |
KernelBasedLocallyWeightedDistanceFunction.setDatabase(Database<V> database,
boolean verbose,
boolean time)
|
Uses of Database in de.lmu.ifi.dbs.elki.distance.distancefunction.adapter |
---|
Methods in de.lmu.ifi.dbs.elki.distance.distancefunction.adapter with parameters of type Database | |
---|---|
void |
SimilarityAdapterAbstract.setDatabase(Database<V> database,
boolean verbose,
boolean time)
|
Uses of Database in de.lmu.ifi.dbs.elki.distance.similarityfunction |
---|
Methods in de.lmu.ifi.dbs.elki.distance.similarityfunction with parameters of type Database | |
---|---|
void |
AbstractPreprocessorBasedSimilarityFunction.setDatabase(Database<O> database,
boolean verbose,
boolean time)
Calls AbstractMeasurementFunction(database, verbose, time) and
runs the preprocessor on the database. |
Uses of Database in de.lmu.ifi.dbs.elki.distance.similarityfunction.kernel |
---|
Methods in de.lmu.ifi.dbs.elki.distance.similarityfunction.kernel with parameters of type Database | |
---|---|
void |
ArbitraryKernelFunctionWrapper.setDatabase(Database<O> database,
boolean verbose,
boolean time)
|
Constructors in de.lmu.ifi.dbs.elki.distance.similarityfunction.kernel with parameters of type Database | |
---|---|
KernelMatrix(KernelFunction<O,DoubleDistance> kernelFunction,
Database<O> database)
Provides a new kernel matrix. |
|
KernelMatrix(KernelFunction<O,DoubleDistance> kernelFunction,
Database<O> database,
List<Integer> ids)
Provides a new kernel matrix. |
Uses of Database in de.lmu.ifi.dbs.elki.evaluation |
---|
Methods in de.lmu.ifi.dbs.elki.evaluation with parameters of type Database | |
---|---|
private Iterator<Integer> |
ComputeROCCurve.getIterableResult(Database<O> database,
Result result)
Find an "iterable" result that looks like object IDs. |
private Cluster<Model> |
ComputeROCCurve.getReferenceCluster(Database<O> database,
String class_name)
Find the "positive" reference cluster using a by label clustering. |
protected MultiResult |
ComputeROCCurve.runInTime(Database<O> database)
|
Uses of Database in de.lmu.ifi.dbs.elki.index |
---|
Methods in de.lmu.ifi.dbs.elki.index with parameters of type Database | |
---|---|
void |
Index.setDatabase(Database<O> database)
Sets the database in the distance function of this index (if existing). |
Uses of Database in de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants |
---|
Methods in de.lmu.ifi.dbs.elki.index.tree.metrical.mtreevariants with parameters of type Database | |
---|---|
void |
AbstractMTree.setDatabase(Database<O> database)
|
Uses of Database in de.lmu.ifi.dbs.elki.index.tree.spatial |
---|
Methods in de.lmu.ifi.dbs.elki.index.tree.spatial with parameters of type Database | |
---|---|
void |
SpatialIndex.setDatabase(Database<O> database)
Sets the database in the distance function of this index (if existing). |
Uses of Database in de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.rdknn |
---|
Methods in de.lmu.ifi.dbs.elki.index.tree.spatial.rstarvariants.rdknn with parameters of type Database | |
---|---|
void |
RdKNNTree.setDatabase(Database<O> database)
Sets the database in the distance function of this index. |
Uses of Database in de.lmu.ifi.dbs.elki.math.linearalgebra.pca |
---|
Methods in de.lmu.ifi.dbs.elki.math.linearalgebra.pca with parameters of type Database | |
---|---|
PCAResult |
PCARunner.processDatabase(Database<V> database)
Run PCA on the complete database |
Matrix |
StandardCovarianceMatrixBuilder.processDatabase(Database<V> database)
Compute Covariance Matrix for a complete database |
Matrix |
CovarianceMatrixBuilder.processDatabase(Database<V> database)
Compute Covariance Matrix for a complete database |
PCAFilteredResult |
PCAFilteredRunner.processIds(Collection<Integer> ids,
Database<V> database)
Run PCA on a collection of database IDs |
PCAResult |
PCARunner.processIds(Collection<Integer> ids,
Database<V> database)
Run PCA on a collection of database IDs |
Matrix |
WeightedCovarianceMatrixBuilder.processIds(Collection<Integer> ids,
Database<V> database)
Weighted Covariance Matrix for a set of IDs. |
Matrix |
KernelCovarianceMatrixBuilder.processIds(Collection<Integer> ids,
Database<V> database)
Returns the local kernel matrix of the specified ids. |
Matrix |
StandardCovarianceMatrixBuilder.processIds(Collection<Integer> ids,
Database<V> database)
Compute Covariance Matrix for a collection of database IDs |
abstract Matrix |
CovarianceMatrixBuilder.processIds(Collection<Integer> ids,
Database<V> database)
Compute Covariance Matrix for a collection of database IDs |
PCAFilteredResult |
PCAFilteredRunner.processQueryResult(Collection<DistanceResultPair<D>> results,
Database<V> database)
Run PCA on a QueryResult Collection |
PCAResult |
PCARunner.processQueryResult(Collection<DistanceResultPair<D>> results,
Database<V> database)
Run PCA on a QueryResult Collection |
Matrix |
CovarianceMatrixBuilder.processQueryResults(Collection<DistanceResultPair<D>> results,
Database<V> database)
Compute Covariance Matrix for a QueryResult Collection By default it will just collect the ids and run processIds |
Matrix |
WeightedCovarianceMatrixBuilder.processQueryResults(Collection<DistanceResultPair<D>> results,
Database<V> database,
int k)
Compute Covariance Matrix for a QueryResult Collection By default it will just collect the ids and run processIds |
Matrix |
CovarianceMatrixBuilder.processQueryResults(Collection<DistanceResultPair<D>> results,
Database<V> database,
int k)
Compute Covariance Matrix for a QueryResult Collection By default it will just collect the ids and run processIds |
Uses of Database in de.lmu.ifi.dbs.elki.preprocessing |
---|
Fields in de.lmu.ifi.dbs.elki.preprocessing declared as Database | |
---|---|
private Database<O> |
PreprocessorHandler.database
The database to run the preprocessor on. |
Methods in de.lmu.ifi.dbs.elki.preprocessing with parameters of type Database | |
---|---|
private BitSet |
HiSCPreprocessor.determinePreferenceVector(Database<V> database,
Integer id,
List<Integer> neighborIDs,
StringBuffer msg)
Determines the preference vector according to the specified neighbor ids. |
private BitSet |
DiSHPreprocessor.determinePreferenceVector(Database<V> database,
Set<Integer>[] neighborIDs,
StringBuffer msg)
Determines the preference vector according to the specified neighbor ids. |
private BitSet |
DiSHPreprocessor.determinePreferenceVectorByApriori(Database<V> database,
Set<Integer>[] neighborIDs,
StringBuffer msg)
Determines the preference vector with the apriori strategy. |
private SpatialIndexDatabase<O,N,E> |
SpatialApproximationMaterializeKNNPreprocessor.getSpatialDatabase(Database<O> database)
Do some (limited) type checking, then cast the database into a spatial database. |
private DimensionSelectingDistanceFunction<N,V>[] |
DiSHPreprocessor.initDistanceFunctions(Database<V> database,
int dimensionality,
boolean verbose,
boolean time)
Initializes the dimension selecting distancefunctions to determine the preference vectors. |
protected List<Integer> |
KnnQueryBasedHiCOPreprocessor.objectIDsForPCA(Integer id,
Database<V> database,
boolean verbose,
boolean time)
|
protected List<Integer> |
RangeQueryBasedHiCOPreprocessor.objectIDsForPCA(Integer id,
Database<V> database,
boolean verbose,
boolean time)
|
protected abstract List<Integer> |
HiCOPreprocessor.objectIDsForPCA(Integer id,
Database<V> database,
boolean verbose,
boolean time)
Returns the ids of the objects stored in the specified database to be considered within the PCA for the specified object id. |
protected List<DistanceResultPair<DoubleDistance>> |
KnnQueryBasedHiCOPreprocessor.resultsForPCA(Integer id,
Database<V> database,
boolean verbose,
boolean time)
|
protected List<DistanceResultPair<DoubleDistance>> |
RangeQueryBasedHiCOPreprocessor.resultsForPCA(Integer id,
Database<V> database,
boolean verbose,
boolean time)
|
protected abstract List<DistanceResultPair<DoubleDistance>> |
HiCOPreprocessor.resultsForPCA(Integer id,
Database<V> database,
boolean verbose,
boolean time)
Returns the ids of the objects and distances stored in the specified database to be considered within the PCA for the specified object id. |
void |
Preprocessor.run(Database<O> database,
boolean verbose,
boolean time)
This method executes the actual preprocessing step of this Preprocessor for the objects of the specified database. |
void |
MaterializeKNNPreprocessor.run(Database<O> database,
boolean verbose,
boolean time)
Annotates the nearest neighbors based on the values of MaterializeKNNPreprocessor.k and MaterializeKNNPreprocessor.distanceFunction to each database
object. |
void |
SharedNearestNeighborsPreprocessor.run(Database<O> database,
boolean verbose,
boolean time)
Annotates the nearest neighbors based on the values of SharedNearestNeighborsPreprocessor.numberOfNeighbors
and SharedNearestNeighborsPreprocessor.distanceFunction to each database object. |
void |
SpatialApproximationMaterializeKNNPreprocessor.run(Database<O> database,
boolean verbose,
boolean time)
Annotates the nearest neighbors based on the values of MaterializeKNNPreprocessor.k and MaterializeKNNPreprocessor.distanceFunction to each database
object. |
void |
DiSHPreprocessor.run(Database<V> database,
boolean verbose,
boolean time)
|
void |
HiSCPreprocessor.run(Database<V> database,
boolean verbose,
boolean time)
|
void |
ProjectedDBSCANPreprocessor.run(Database<V> database,
boolean verbose,
boolean time)
|
void |
HiCOPreprocessor.run(Database<V> database,
boolean verbose,
boolean time)
This method determines the correlation dimensions of the objects stored in the specified database and sets the necessary associations in the database. |
void |
PreprocessorHandler.runPreprocessor(Database<O> database,
boolean verbose,
boolean time)
Runs the preprocessor on the database if the omit flag is not set or the database does contain the association id neither for any id nor as global association. |
protected void |
FourCPreprocessor.runVarianceAnalysis(Integer id,
List<DistanceResultPair<D>> neighbors,
Database<V> database)
This method implements the type of variance analysis to be computed for a given point. |
protected abstract void |
ProjectedDBSCANPreprocessor.runVarianceAnalysis(Integer id,
List<DistanceResultPair<D>> neighbors,
Database<V> database)
This method implements the type of variance analysis to be computed for a given point. |
protected void |
PreDeConPreprocessor.runVarianceAnalysis(Integer id,
List<DistanceResultPair<D>> neighbors,
Database<V> database)
TODO provide correct commentary This method implements the type of variance analysis to be computed for a given point. |
Uses of Database in de.lmu.ifi.dbs.elki.result |
---|
Fields in de.lmu.ifi.dbs.elki.result declared as Database | |
---|---|
private Database<O> |
AnnotationFromDatabase.database
database storage |
protected Database<O> |
OrderingFromAssociation.db
Database |
Methods in de.lmu.ifi.dbs.elki.result that return Database | |
---|---|
Database<O> |
AnnotationFromDatabase.getDatabase()
Return database referenced by annotations |
Methods in de.lmu.ifi.dbs.elki.result with parameters of type Database | |
---|---|
void |
ResultHandler.processResult(Database<O> db,
R result)
Process a result. |
void |
DiscardResultHandler.processResult(Database<O> db,
R result)
Process the result... by discarding |
void |
ResultWriter.processResult(Database<O> db,
Result result)
Process a single result. |
Constructors in de.lmu.ifi.dbs.elki.result with parameters of type Database | |
---|---|
AnnotationFromDatabase(Database<O> db,
AssociationID<T> association)
Constructor |
|
OrderingFromAssociation(Database<O> db,
AssociationID<T> association)
Minimal constructor, using implied comparator and ascending order. |
|
OrderingFromAssociation(Database<O> db,
AssociationID<T> association,
boolean descending)
Constructor without comparator |
|
OrderingFromAssociation(Database<O> db,
AssociationID<T> association,
Comparator<T> comparator,
boolean descending)
Full Constructor (with comparator) |
Uses of Database in de.lmu.ifi.dbs.elki.result.textwriter |
---|
Methods in de.lmu.ifi.dbs.elki.result.textwriter with parameters of type Database | |
---|---|
void |
TextWriter.output(Database<O> db,
Result r,
StreamFactory streamOpener)
Stream output. |
protected void |
TextWriter.printSettings(Database<O> db,
TextWriterStream out,
List<AttributeSettings> settings)
Writes a header providing information concerning the underlying database and the specified parameter-settings. |
private void |
TextWriter.writeGroupResult(Database<O> db,
StreamFactory streamOpener,
DatabaseObjectGroup group,
List<AnnotationResult<?>> ra,
List<OrderingResult> ro,
NamingScheme naming,
List<AttributeSettings> settings)
|
private void |
TextWriter.writeIterableResult(Database<O> db,
StreamFactory streamOpener,
IterableResult<?> ri,
List<MetadataResult> rm)
|
Uses of Database in de.lmu.ifi.dbs.elki.utilities |
---|
Methods in de.lmu.ifi.dbs.elki.utilities with parameters of type Database | ||
---|---|---|
static
|
DatabaseUtil.centroid(Database<O> database)
Returns the centroid as a RealVector object of the specified database. |
|
static
|
DatabaseUtil.centroid(Database<V> database,
Collection<Integer> ids)
Returns the centroid as a RealVector object of the specified objects stored in the given database. |
|
static
|
DatabaseUtil.centroid(Database<V> database,
Collection<Integer> ids,
BitSet bitSet)
Returns the centroid w.r.t. the dimensions specified by the given BitSet as a RealVector object of the specified objects stored in the given database. |
|
static
|
DatabaseUtil.centroid(Database<V> database,
Iterator<Integer> iter,
BitSet bitSet)
Returns the centroid w.r.t. the dimensions specified by the given BitSet as a RealVector object of the specified objects stored in the given database. |
|
static
|
DatabaseUtil.covarianceMatrix(Database<O> database)
Determines the covariance matrix of the objects stored in the given database. |
|
static
|
DatabaseUtil.covarianceMatrix(Database<O> database,
O centroid)
Determines the covariance matrix of the objects stored in the given database w.r.t. the given centroid. |
|
static
|
DatabaseUtil.covarianceMatrix(Database<V> database,
Collection<Integer> ids)
Determines the covariance matrix of the objects stored in the given database. |
|
static
|
DatabaseUtil.getBaseObjectClassExpensive(Database<O> database)
Do a full inspection of the database to find the base object class. |
|
static SortedSet<ClassLabel> |
DatabaseUtil.getClassLabels(Database<?> database)
Retrieves all class labels within the database. |
|
static
|
DatabaseUtil.guessObjectClass(Database<O> database)
Do a cheap guess at the databases object class. |
|
static double[][] |
DatabaseUtil.min_max(Database<RealVector<?,?>> database)
Determines the minimum and maximum values in each dimension of all objects stored in the given database. |
|
static
|
DatabaseUtil.variances(Database<O> database)
Determines the variances in each dimension of all objects stored in the given database. |
|
static double[] |
DatabaseUtil.variances(Database<RealVector<?,?>> database,
RealVector<?,?> centroid,
Collection<Integer>[] ids)
Determines the variances in each dimension of the specified objects stored in the given database. |
|
static
|
DatabaseUtil.variances(Database<V> database,
Collection<Integer> ids)
Determines the variances in each dimension of the specified objects stored in the given database. |
|
static
|
DatabaseUtil.variances(Database<V> database,
V centroid,
Collection<Integer> ids)
Determines the variances in each dimension of the specified objects stored in the given database. |
Uses of Database in de.lmu.ifi.dbs.elki.visualization |
---|
Methods in de.lmu.ifi.dbs.elki.visualization with parameters of type Database | |
---|---|
void |
ResultROCCurveVisualizer.processResult(Database<O> db,
MultiResult result)
|
Uses of Database in de.lmu.ifi.dbs.elki.visualization.scales |
---|
Methods in de.lmu.ifi.dbs.elki.visualization.scales with parameters of type Database | ||
---|---|---|
static
|
Scales.calcScales(Database<O> db)
Compute a linear scale for each dimension. |
|
|
|||||||||||
PREV NEXT | FRAMES NO FRAMES |