| Cmlpack::adaboost::AdaBoost< decision_stump::DecisionStump<> > | |
| Cmlpack::adaboost::AdaBoost< perceptron::Perceptron<> > | |
| Cmlpack::optimization::AugLagrangian< mlpack::optimization::LRSDPFunction< optimization::SDP< arma::sp_mat > > > | |
| Cmlpack::optimization::AugLagrangian< mlpack::optimization::LRSDPFunction< SDPType > > | |
| Cmlpack::optimization::AugLagrangianFunction< mlpack::optimization::LRSDPFunction< optimization::SDP< arma::sp_mat > > > | |
| Cmlpack::optimization::AugLagrangianFunction< mlpack::optimization::LRSDPFunction< SDPType > > | |
| ►Cstatic_visitor | |
| Cmlpack::ann::AddVisitor | AddVisitor exposes the Add() method of the given module |
| Cmlpack::ann::BackwardVisitor | BackwardVisitor executes the Backward() function given the input, error and delta parameter |
| Cmlpack::ann::DeleteVisitor | DeleteVisitor executes the destructor of the instantiated object |
| Cmlpack::ann::DeltaVisitor | DeltaVisitor exposes the delta parameter of the given module |
| Cmlpack::ann::DeterministicSetVisitor | DeterministicSetVisitor set the deterministic parameter given the deterministic value |
| Cmlpack::ann::ForwardVisitor | ForwardVisitor executes the Forward() function given the input and output parameter |
| Cmlpack::ann::GradientSetVisitor | GradientSetVisitor update the gradient parameter given the gradient set |
| Cmlpack::ann::GradientUpdateVisitor | GradientUpdateVisitor update the gradient parameter given the gradient set |
| Cmlpack::ann::GradientVisitor | SearchModeVisitor executes the Gradient() method of the given module using the input and delta parameter |
| Cmlpack::ann::GradientZeroVisitor | |
| Cmlpack::ann::LoadOutputParameterVisitor | LoadOutputParameterVisitor restores the output parameter using the given parameter set |
| Cmlpack::ann::OutputHeightVisitor | OutputWidthVisitor exposes the OutputHeight() method of the given module |
| Cmlpack::ann::OutputParameterVisitor | OutputParameterVisitor exposes the output parameter of the given module |
| Cmlpack::ann::OutputWidthVisitor | OutputWidthVisitor exposes the OutputWidth() method of the given module |
| Cmlpack::ann::ParametersSetVisitor | ParametersSetVisitor update the parameters set using the given matrix |
| Cmlpack::ann::ParametersVisitor | ParametersVisitor exposes the parameters set of the given module and stores the parameters set into the given matrix |
| Cmlpack::ann::ResetVisitor | ResetVisitor executes the Reset() function |
| Cmlpack::ann::RewardSetVisitor | RewardSetVisitor set the reward parameter given the reward value |
| Cmlpack::ann::SaveOutputParameterVisitor | SaveOutputParameterVisitor saves the output parameter into the given parameter set |
| Cmlpack::ann::SetInputHeightVisitor | SetInputHeightVisitor updates the input height parameter with the given input height |
| Cmlpack::ann::SetInputWidthVisitor | SetInputWidthVisitor updates the input width parameter with the given input width |
| Cmlpack::ann::WeightSetVisitor | WeightSetVisitor update the module parameters given the parameters set |
| Cmlpack::ann::WeightSizeVisitor | WeightSizeVisitor returns the number of weights of the given module |
| Cmlpack::neighbor::BiSearchVisitor< SortPolicy > | BiSearchVisitor executes a bichromatic neighbor search on the given NSType |
| Cmlpack::neighbor::DeleteVisitor | DeleteVisitor deletes the given NSType instance |
| Cmlpack::neighbor::EpsilonVisitor | EpsilonVisitor exposes the Epsilon method of the given NSType |
| Cmlpack::neighbor::MonoSearchVisitor | MonoSearchVisitor executes a monochromatic neighbor search on the given NSType |
| Cmlpack::neighbor::ReferenceSetVisitor | ReferenceSetVisitor exposes the referenceSet of the given NSType |
| Cmlpack::neighbor::SearchModeVisitor | SearchModeVisitor exposes the SearchMode() method of the given NSType |
| Cmlpack::neighbor::TrainVisitor< SortPolicy > | TrainVisitor sets the reference set to a new reference set on the given NSType |
| Cmlpack::range::BiSearchVisitor | BiSearchVisitor executes a bichromatic range search on the given RSType |
| Cmlpack::range::DeleteVisitor | DeleteVisitor deletes the given RSType instance |
| Cmlpack::range::MonoSearchVisitor | MonoSearchVisitor executes a monochromatic range search on the given RSType |
| Cmlpack::range::NaiveVisitor | NaiveVisitor exposes the Naive() method of the given RSType |
| Cmlpack::range::ReferenceSetVisitor | ReferenceSetVisitor exposes the referenceSet of the given RSType |
| Cmlpack::range::SerializeVisitor< Archive > | Exposes the seralize method of the given RSType |
| Cmlpack::range::SingleModeVisitor | SingleModeVisitor exposes the SingleMode() method of the given RSType |
| Cmlpack::range::TrainVisitor | TrainVisitor sets the reference set to a new reference set on the given RSType |
| ►CtemplateAuxiliarySplitInfo< ElemType > | |
| Cmlpack::tree::DecisionTree< FitnessFunction, NumericSplitType, CategoricalSplitType, ElemType, NoRecursion > | This class implements a generic decision tree learner |
| Cmlpack::fastmks::FastMKS< kernel::CosineDistance > | |
| Cmlpack::fastmks::FastMKS< kernel::EpanechnikovKernel > | |
| Cmlpack::fastmks::FastMKS< kernel::GaussianKernel > | |
| Cmlpack::fastmks::FastMKS< kernel::HyperbolicTangentKernel > | |
| Cmlpack::fastmks::FastMKS< kernel::LinearKernel > | |
| Cmlpack::fastmks::FastMKS< kernel::PolynomialKernel > | |
| Cmlpack::fastmks::FastMKS< kernel::TriangularKernel > | |
| Cmlpack::hmm::HMM< distribution::DiscreteDistribution > | |
| Cmlpack::hmm::HMM< distribution::GaussianDistribution > | |
| ►Cmlpack::hmm::HMM< distribution::RegressionDistribution > | |
| Cmlpack::hmm::HMMRegression | A class that represents a Hidden Markov Model Regression (HMMR) |
| Cmlpack::hmm::HMM< gmm::GMM > | |
| Cmlpack::bound::HRectBound< metric::EuclideanDistance, ElemType > | |
| Cmlpack::bound::HRectBound< MetricType > | |
| Cmlpack::metric::IPMetric< kernel::CosineDistance > | |
| Cmlpack::metric::IPMetric< kernel::EpanechnikovKernel > | |
| Cmlpack::metric::IPMetric< kernel::GaussianKernel > | |
| Cmlpack::metric::IPMetric< kernel::HyperbolicTangentKernel > | |
| Cmlpack::metric::IPMetric< kernel::LinearKernel > | |
| Cmlpack::metric::IPMetric< kernel::PolynomialKernel > | |
| Cmlpack::metric::IPMetric< kernel::TriangularKernel > | |
| CIsVector< VecType > | If value == true, then VecType is some sort of Armadillo vector or subview |
| CIsVector< arma::Col< eT > > | |
| CIsVector< arma::Row< eT > > | |
| CIsVector< arma::SpCol< eT > > | |
| CIsVector< arma::SpRow< eT > > | |
| CIsVector< arma::SpSubview< eT > > | |
| CIsVector< arma::subview_col< eT > > | |
| CIsVector< arma::subview_row< eT > > | |
| Cmlpack::optimization::L_BFGS< AugLagrangianFunction< LagrangianFunction > > | |
| Cmlpack::optimization::L_BFGS< AugLagrangianFunction< mlpack::optimization::LRSDPFunction< optimization::SDP< arma::sp_mat > > > > | |
| Cmlpack::optimization::L_BFGS< AugLagrangianFunction< mlpack::optimization::LRSDPFunction< SDPType > > > | |
| Cmlpack::optimization::LRSDP< optimization::SDP< arma::sp_mat > > | |
| Cmlpack::optimization::LRSDPFunction< optimization::SDP< arma::sp_mat > > | |
| Cmlpack::adaboost::AdaBoost< WeakLearnerType, MatType > | The AdaBoost class |
| Cmlpack::adaboost::AdaBoostModel | The model to save to disk |
| Cmlpack::amf::AMF< TerminationPolicyType, InitializationRuleType, UpdateRuleType > | This class implements AMF (alternating matrix factorization) on the given matrix V |
| Cmlpack::amf::AverageInitialization | This initialization rule initializes matrix W and H to root of the average of V, perturbed with uniform noise |
| Cmlpack::amf::CompleteIncrementalTermination< TerminationPolicy > | This class acts as a wrapper for basic termination policies to be used by SVDCompleteIncrementalLearning |
| Cmlpack::amf::GivenInitialization | This initialization rule for AMF simply fills the W and H matrices with the matrices given to the constructor of this object |
| Cmlpack::amf::IncompleteIncrementalTermination< TerminationPolicy > | This class acts as a wrapper for basic termination policies to be used by SVDIncompleteIncrementalLearning |
| Cmlpack::amf::MaxIterationTermination | This termination policy only terminates when the maximum number of iterations has been reached |
| Cmlpack::amf::NMFALSUpdate | This class implements a method titled 'Alternating Least Squares' described in the following paper: |
| Cmlpack::amf::NMFMultiplicativeDistanceUpdate | The multiplicative distance update rules for matrices W and H |
| Cmlpack::amf::NMFMultiplicativeDivergenceUpdate | This follows a method described in the paper 'Algorithms for Non-negative |
| Cmlpack::amf::RandomAcolInitialization< columnsToAverage > | This class initializes the W matrix of the AMF algorithm by averaging p randomly chosen columns of V |
| Cmlpack::amf::RandomInitialization | This initialization rule for AMF simply fills the W and H matrices with uniform random noise in [0, 1] |
| Cmlpack::amf::SimpleResidueTermination | This class implements a simple residue-based termination policy |
| Cmlpack::amf::SimpleToleranceTermination< MatType > | This class implements residue tolerance termination policy |
| Cmlpack::amf::SVDBatchLearning | This class implements SVD batch learning with momentum |
| Cmlpack::amf::SVDCompleteIncrementalLearning< MatType > | This class computes SVD using complete incremental batch learning, as described in the following paper: |
| Cmlpack::amf::SVDCompleteIncrementalLearning< arma::sp_mat > | TODO : Merge this template specialized function for sparse matrix using common row_col_iterator |
| Cmlpack::amf::SVDIncompleteIncrementalLearning | This class computes SVD using incomplete incremental batch learning, as described in the following paper: |
| Cmlpack::amf::ValidationRMSETermination< MatType > | This class implements validation termination policy based on RMSE index |
| Cmlpack::ann::Add< InputDataType, OutputDataType > | Implementation of the Add module class |
| Cmlpack::ann::AddMerge< InputDataType, OutputDataType > | Implementation of the AddMerge module class |
| Cmlpack::ann::BaseLayer< ActivationFunction, InputDataType, OutputDataType > | Implementation of the base layer |
| Cmlpack::ann::Concat< InputDataType, OutputDataType > | Implementation of the Concat class |
| Cmlpack::ann::ConcatPerformance< OutputLayerType, InputDataType, OutputDataType > | Implementation of the concat performance class |
| Cmlpack::ann::Constant< InputDataType, OutputDataType > | Implementation of the constant layer |
| Cmlpack::ann::Convolution< ForwardConvolutionRule, BackwardConvolutionRule, GradientConvolutionRule, InputDataType, OutputDataType > | Implementation of the Convolution class |
| Cmlpack::ann::DropConnect< InputDataType, OutputDataType > | The DropConnect layer is a regularizer that randomly with probability ratio sets the connection values to zero and scales the remaining elements by factor 1 /(1 - ratio) |
| Cmlpack::ann::Dropout< InputDataType, OutputDataType > | The dropout layer is a regularizer that randomly with probability ratio sets input values to zero and scales the remaining elements by factor 1 / (1 - ratio) |
| Cmlpack::ann::ELU< InputDataType, OutputDataType > | The ELU activation function, defined by |
| Cmlpack::ann::FFN< OutputLayerType, InitializationRuleType > | Implementation of a standard feed forward network |
| Cmlpack::ann::FFTConvolution< BorderMode, padLastDim > | Computes the two-dimensional convolution through fft |
| Cmlpack::ann::FullConvolution | |
| Cmlpack::ann::Glimpse< InputDataType, OutputDataType > | The glimpse layer returns a retina-like representation (down-scaled cropped images) of increasing scale around a given location in a given image |
| Cmlpack::ann::HardTanH< InputDataType, OutputDataType > | The Hard Tanh activation function, defined by |
| Cmlpack::ann::IdentityFunction | The identity function, defined by |
| Cmlpack::ann::Join< InputDataType, OutputDataType > | Implementation of the Join module class |
| Cmlpack::ann::KathirvalavakumarSubavathiInitialization | This class is used to initialize the weight matrix with the method proposed by T |
| Cmlpack::ann::LayerTraits< LayerType > | This is a template class that can provide information about various layers |
| Cmlpack::ann::LeakyReLU< InputDataType, OutputDataType > | The LeakyReLU activation function, defined by |
| Cmlpack::ann::Linear< InputDataType, OutputDataType > | Implementation of the Linear layer class |
| Cmlpack::ann::LinearNoBias< InputDataType, OutputDataType > | Implementation of the LinearNoBias class |
| Cmlpack::ann::LogisticFunction | The logistic function, defined by |
| Cmlpack::ann::LogSoftMax< InputDataType, OutputDataType > | Implementation of the log softmax layer |
| Cmlpack::ann::Lookup< InputDataType, OutputDataType > | Implementation of the Lookup class |
| Cmlpack::ann::LSTM< InputDataType, OutputDataType > | An implementation of a lstm network layer |
| Cmlpack::ann::MaxPooling< InputDataType, OutputDataType > | Implementation of the MaxPooling layer |
| Cmlpack::ann::MaxPoolingRule | |
| Cmlpack::ann::MeanPooling< InputDataType, OutputDataType > | Implementation of the MeanPooling |
| Cmlpack::ann::MeanPoolingRule | |
| Cmlpack::ann::MeanSquaredError< InputDataType, OutputDataType > | The mean squared error performance function measures the network's performance according to the mean of squared errors |
| Cmlpack::ann::MultiplyConstant< InputDataType, OutputDataType > | Implementation of the multiply constant layer |
| Cmlpack::ann::NaiveConvolution< BorderMode > | Computes the two-dimensional convolution |
| Cmlpack::ann::NegativeLogLikelihood< InputDataType, OutputDataType > | Implementation of the negative log likelihood layer |
| Cmlpack::ann::NguyenWidrowInitialization | This class is used to initialize the weight matrix with the Nguyen-Widrow method |
| Cmlpack::ann::OivsInitialization< ActivationFunction > | This class is used to initialize the weight matrix with the oivs method |
| Cmlpack::ann::OrthogonalInitialization | This class is used to initialize the weight matrix with the orthogonal matrix initialization |
| Cmlpack::ann::PReLU< InputDataType, OutputDataType > | The PReLU activation function, defined by (where alpha is trainable) |
| Cmlpack::ann::RandomInitialization | This class is used to initialize randomly the weight matrix |
| Cmlpack::ann::RectifierFunction | The rectifier function, defined by |
| Cmlpack::ann::Recurrent< InputDataType, OutputDataType > | Implementation of the RecurrentLayer class |
| Cmlpack::ann::RecurrentAttention< InputDataType, OutputDataType > | This class implements the Recurrent Model for Visual Attention, using a variety of possible layer implementations |
| Cmlpack::ann::ReinforceNormal< InputDataType, OutputDataType > | Implementation of the reinforce normal layer |
| Cmlpack::ann::RNN< OutputLayerType, InitializationRuleType > | Implementation of a standard recurrent neural network container |
| Cmlpack::ann::Select< InputDataType, OutputDataType > | The select module selects the specified column from a given input matrix |
| Cmlpack::ann::Sequential< InputDataType, OutputDataType > | Implementation of the Sequential class |
| Cmlpack::ann::SoftplusFunction | The softplus function, defined by |
| Cmlpack::ann::SoftsignFunction | The softsign function, defined by |
| Cmlpack::ann::SVDConvolution< BorderMode > | Computes the two-dimensional convolution using singular value decomposition |
| Cmlpack::ann::TanhFunction | The tanh function, defined by |
| Cmlpack::ann::ValidConvolution | |
| Cmlpack::ann::VRClassReward< InputDataType, OutputDataType > | Implementation of the variance reduced classification reinforcement layer |
| Cmlpack::ann::ZeroInitialization | This class is used to initialize randomly the weight matrix |
| Cmlpack::Backtrace | Provides a backtrace |
| Cmlpack::Backtrace::Frames | Backtrace datastructure |
| Cmlpack::bound::BallBound< MetricType, VecType > | Ball bound encloses a set of points at a specific distance (radius) from a specific point (center) |
| Cmlpack::bound::BoundTraits< BoundType > | A class to obtain compile-time traits about BoundType classes |
| Cmlpack::bound::BoundTraits< BallBound< MetricType, VecType > > | A specialization of BoundTraits for this bound type |
| Cmlpack::bound::BoundTraits< CellBound< MetricType, ElemType > > | |
| Cmlpack::bound::BoundTraits< HollowBallBound< MetricType, ElemType > > | A specialization of BoundTraits for this bound type |
| Cmlpack::bound::BoundTraits< HRectBound< MetricType, ElemType > > | |
| Cmlpack::bound::CellBound< MetricType, ElemType > | The CellBound class describes a bound that consists of a number of hyperrectangles |
| Cmlpack::bound::HollowBallBound< TMetricType, ElemType > | Hollow ball bound encloses a set of points at a specific distance (radius) from a specific point (center) except points at a specific distance from another point (the center of the hole) |
| Cmlpack::bound::HRectBound< MetricType, ElemType > | Hyper-rectangle bound for an L-metric |
| Cmlpack::bound::meta::IsLMetric< MetricType > | Utility struct where Value is true if and only if the argument is of type LMetric |
| Cmlpack::bound::meta::IsLMetric< metric::LMetric< Power, TakeRoot > > | Specialization for IsLMetric when the argument is of type LMetric |
| Cmlpack::cf::CF | This class implements Collaborative Filtering (CF) |
| Cmlpack::cf::CF::CandidateCmp | Compare two candidates based on the value |
| Cmlpack::cf::DummyClass | This class acts as a dummy class for passing as template parameter |
| Cmlpack::cf::FactorizerTraits< FactorizerType > | Template class for factorizer traits |
| Cmlpack::cf::FactorizerTraits< mlpack::svd::RegularizedSVD<> > | Factorizer traits of Regularized SVD |
| Cmlpack::cf::SVDWrapper< Factorizer > | This class acts as the wrapper for all SVD factorizers which are incompatible with CF module |
| Cmlpack::CLI | Parses the command line for parameters and holds user-specified parameters |
| Cmlpack::data::CustomImputation< T > | A simple custom imputation class |
| Cmlpack::data::DatasetMapper< PolicyType > | Auxiliary information for a dataset, including mappings to/from strings and the datatype of each dimension |
| Cmlpack::data::FirstArrayShim< T > | A first shim for arrays |
| Cmlpack::data::FirstNormalArrayShim< T > | A first shim for arrays without a Serialize() method |
| Cmlpack::data::FirstShim< T > | The first shim: simply holds the object and its name |
| Cmlpack::data::HasSerialize< T > | |
| Cmlpack::data::HasSerialize< T >::check< U, V, W > | |
| Cmlpack::data::HasSerializeFunction< T > | |
| Cmlpack::data::Imputer< T, MapperType, StrategyType > | Given a dataset of a particular datatype, replace user-specified missing value with a variable dependent on the StrategyType and MapperType |
| Cmlpack::data::IncrementPolicy | IncrementPolicy is used as a helper class for DatasetMapper |
| Cmlpack::data::ListwiseDeletion< T > | A complete-case analysis to remove the values containing mappedValue |
| Cmlpack::data::MeanImputation< T > | A simple mean imputation class |
| Cmlpack::data::MedianImputation< T > | This is a class implementation of simple median imputation |
| Cmlpack::data::MissingPolicy | MissingPolicy is used as a helper class for DatasetMapper |
| Cmlpack::data::SecondArrayShim< T > | A shim for objects in an array; this is basically like the SecondShim, but for arrays that hold objects that have Serialize() methods instead of serialize() methods |
| Cmlpack::data::SecondNormalArrayShim< T > | A shim for objects in an array which do not have a Serialize() function |
| Cmlpack::data::SecondShim< T > | The second shim: wrap the call to Serialize() inside of a serialize() function, so that an archive type can call serialize() on a SecondShim object and this gets forwarded correctly to our object's Serialize() function |
| Cmlpack::dbscan::DBSCAN< RangeSearchType, PointSelectionPolicy > | DBSCAN (Density-Based Spatial Clustering of Applications with Noise) is a clustering technique described in the following paper: |
| Cmlpack::dbscan::RandomPointSelection | This class can be used to randomly select the next point to use for DBSCAN |
| Cmlpack::decision_stump::DecisionStump< MatType > | This class implements a decision stump |
| Cmlpack::det::DTree< MatType, TagType > | A density estimation tree is similar to both a decision tree and a space partitioning tree (like a kd-tree) |
| Cmlpack::distribution::DiscreteDistribution | A discrete distribution where the only observations are discrete observations |
| Cmlpack::distribution::GammaDistribution | This class represents the Gamma distribution |
| Cmlpack::distribution::GaussianDistribution | A single multivariate Gaussian distribution |
| Cmlpack::distribution::LaplaceDistribution | The multivariate Laplace distribution centered at 0 has pdf |
| Cmlpack::distribution::RegressionDistribution | A class that represents a univariate conditionally Gaussian distribution |
| Cmlpack::emst::DTBRules< MetricType, TreeType > | |
| Cmlpack::emst::DTBStat | A statistic for use with mlpack trees, which stores the upper bound on distance to nearest neighbors and the component which this node belongs to |
| Cmlpack::emst::DualTreeBoruvka< MetricType, MatType, TreeType > | Performs the MST calculation using the Dual-Tree Boruvka algorithm, using any type of tree |
| Cmlpack::emst::DualTreeBoruvka< MetricType, MatType, TreeType >::SortEdgesHelper | For sorting the edge list after the computation |
| Cmlpack::emst::EdgePair | An edge pair is simply two indices and a distance |
| Cmlpack::emst::UnionFind | A Union-Find data structure |
| Cmlpack::fastmks::FastMKS< KernelType, MatType, TreeType > | An implementation of fast exact max-kernel search |
| Cmlpack::fastmks::FastMKS< KernelType, MatType, TreeType >::CandidateCmp | Compare two candidates based on the value |
| Cmlpack::fastmks::FastMKSModel | A utility struct to contain all the possible FastMKS models, for use by the mlpack_fastmks program |
| Cmlpack::fastmks::FastMKSRules< KernelType, TreeType > | The FastMKSRules class is a template helper class used by FastMKS class when performing exact max-kernel search |
| Cmlpack::fastmks::FastMKSRules< KernelType, TreeType >::CandidateCmp | Compare two candidates based on the value |
| Cmlpack::fastmks::FastMKSStat | The statistic used in trees with FastMKS |
| Cmlpack::gmm::DiagonalConstraint | Force a covariance matrix to be diagonal |
| Cmlpack::gmm::EigenvalueRatioConstraint | Given a vector of eigenvalue ratios, ensure that the covariance matrix always has those eigenvalue ratios |
| Cmlpack::gmm::EMFit< InitialClusteringType, CovarianceConstraintPolicy > | This class contains methods which can fit a GMM to observations using the EM algorithm |
| Cmlpack::gmm::GMM | A Gaussian Mixture Model (GMM) |
| Cmlpack::gmm::NoConstraint | This class enforces no constraint on the covariance matrix |
| Cmlpack::gmm::PositiveDefiniteConstraint | Given a covariance matrix, force the matrix to be positive definite |
| Cmlpack::hmm::HMM< Distribution > | A class that represents a Hidden Markov Model with an arbitrary type of emission distribution |
| Cmlpack::hmm::HMMModel | A serializable HMM model that also stores the type |
| Cmlpack::kernel::CosineDistance | The cosine distance (or cosine similarity) |
| Cmlpack::kernel::EpanechnikovKernel | The Epanechnikov kernel, defined as |
| Cmlpack::kernel::ExampleKernel | An example kernel function |
| Cmlpack::kernel::GaussianKernel | The standard Gaussian kernel |
| Cmlpack::kernel::HyperbolicTangentKernel | Hyperbolic tangent kernel |
| Cmlpack::kernel::KernelTraits< KernelType > | This is a template class that can provide information about various kernels |
| Cmlpack::kernel::KernelTraits< CosineDistance > | Kernel traits for the cosine distance |
| Cmlpack::kernel::KernelTraits< EpanechnikovKernel > | Kernel traits for the Epanechnikov kernel |
| Cmlpack::kernel::KernelTraits< GaussianKernel > | Kernel traits for the Gaussian kernel |
| Cmlpack::kernel::KernelTraits< LaplacianKernel > | Kernel traits of the Laplacian kernel |
| Cmlpack::kernel::KernelTraits< SphericalKernel > | Kernel traits for the spherical kernel |
| Cmlpack::kernel::KernelTraits< TriangularKernel > | Kernel traits for the triangular kernel |
| Cmlpack::kernel::KMeansSelection< ClusteringType, maxIterations > | Implementation of the kmeans sampling scheme |
| Cmlpack::kernel::LaplacianKernel | The standard Laplacian kernel |
| Cmlpack::kernel::LinearKernel | The simple linear kernel (dot product) |
| Cmlpack::kernel::NystroemMethod< KernelType, PointSelectionPolicy > | |
| Cmlpack::kernel::OrderedSelection | |
| Cmlpack::kernel::PolynomialKernel | The simple polynomial kernel |
| Cmlpack::kernel::PSpectrumStringKernel | The p-spectrum string kernel |
| Cmlpack::kernel::RandomSelection | |
| Cmlpack::kernel::SphericalKernel | The spherical kernel, which is 1 when the distance between the two argument points is less than or equal to the bandwidth, or 0 otherwise |
| Cmlpack::kernel::TriangularKernel | The trivially simple triangular kernel, defined by |
| Cmlpack::kmeans::AllowEmptyClusters | Policy which allows K-Means to create empty clusters without any error being reported |
| Cmlpack::kmeans::DualTreeKMeans< MetricType, MatType, TreeType > | An algorithm for an exact Lloyd iteration which simply uses dual-tree nearest-neighbor search to find the nearest centroid for each point in the dataset |
| Cmlpack::kmeans::DualTreeKMeansRules< MetricType, TreeType > | |
| Cmlpack::kmeans::ElkanKMeans< MetricType, MatType > | |
| Cmlpack::kmeans::HamerlyKMeans< MetricType, MatType > | |
| Cmlpack::kmeans::KillEmptyClusters | Policy which allows K-Means to "kill" empty clusters without any error being reported |
| Cmlpack::kmeans::KMeans< MetricType, InitialPartitionPolicy, EmptyClusterPolicy, LloydStepType, MatType > | This class implements K-Means clustering, using a variety of possible implementations of Lloyd's algorithm |
| Cmlpack::kmeans::MaxVarianceNewCluster | When an empty cluster is detected, this class takes the point furthest from the centroid of the cluster with maximum variance as a new cluster |
| Cmlpack::kmeans::NaiveKMeans< MetricType, MatType > | This is an implementation of a single iteration of Lloyd's algorithm for k-means |
| Cmlpack::kmeans::PellegMooreKMeans< MetricType, MatType > | An implementation of Pelleg-Moore's 'blacklist' algorithm for k-means clustering |
| Cmlpack::kmeans::PellegMooreKMeansRules< MetricType, TreeType > | The rules class for the single-tree Pelleg-Moore kd-tree traversal for k-means clustering |
| Cmlpack::kmeans::PellegMooreKMeansStatistic | A statistic for trees which holds the blacklist for Pelleg-Moore k-means clustering (which represents the clusters that cannot possibly own any points in a node) |
| Cmlpack::kmeans::RandomPartition | A very simple partitioner which partitions the data randomly into the number of desired clusters |
| Cmlpack::kmeans::RefinedStart | A refined approach for choosing initial points for k-means clustering |
| Cmlpack::kmeans::SampleInitialization | |
| Cmlpack::kpca::KernelPCA< KernelType, KernelRule > | This class performs kernel principal components analysis (Kernel PCA), for a given kernel |
| Cmlpack::kpca::NaiveKernelRule< KernelType > | |
| Cmlpack::kpca::NystroemKernelRule< KernelType, PointSelectionPolicy > | |
| Cmlpack::lcc::LocalCoordinateCoding | An implementation of Local Coordinate Coding (LCC) that codes data which approximately lives on a manifold using a variation of l1-norm regularized sparse coding; in LCC, the penalty on the absolute value of each point's coefficient for each atom is weighted by the squared distance of that point to that atom |
| Cmlpack::Log | Provides a convenient way to give formatted output |
| Cmlpack::math::ColumnsToBlocks | Transform the columns of the given matrix into a block format |
| Cmlpack::math::RangeType< T > | Simple real-valued range |
| Cmlpack::matrix_completion::MatrixCompletion | This class implements the popular nuclear norm minimization heuristic for matrix completion problems |
| Cmlpack::meanshift::MeanShift< UseKernel, KernelType, MatType > | This class implements mean shift clustering |
| Cmlpack::metric::IPMetric< KernelType > | The inner product metric, IPMetric, takes a given Mercer kernel (KernelType), and when Evaluate() is called, returns the distance between the two points in kernel space: |
| Cmlpack::metric::LMetric< TPower, TTakeRoot > | The L_p metric for arbitrary integer p, with an option to take the root |
| Cmlpack::metric::MahalanobisDistance< TakeRoot > | The Mahalanobis distance, which is essentially a stretched Euclidean distance |
| Cmlpack::mvu::MVU | Meant to provide a good abstraction for users |
| Cmlpack::naive_bayes::NaiveBayesClassifier< MatType > | The simple Naive Bayes classifier |
| Cmlpack::nca::NCA< MetricType, OptimizerType > | An implementation of Neighborhood Components Analysis, both a linear dimensionality reduction technique and a distance learning technique |
| Cmlpack::nca::SoftmaxErrorFunction< MetricType > | The "softmax" stochastic neighbor assignment probability function |
| Cmlpack::neighbor::DrusillaSelect< MatType > | |
| Cmlpack::neighbor::FurthestNeighborSort | This class implements the necessary methods for the SortPolicy template parameter of the NeighborSearch class |
| Cmlpack::neighbor::LSHSearch< SortPolicy > | The LSHSearch class; this class builds a hash on the reference set and uses this hash to compute the distance-approximate nearest-neighbors of the given queries |
| Cmlpack::neighbor::LSHSearch< SortPolicy >::CandidateCmp | Compare two candidates based on the distance |
| Cmlpack::neighbor::NearestNeighborSort | This class implements the necessary methods for the SortPolicy template parameter of the NeighborSearch class |
| Cmlpack::neighbor::NeighborSearch< SortPolicy, MetricType, MatType, TreeType, DualTreeTraversalType, SingleTreeTraversalType > | The NeighborSearch class is a template class for performing distance-based neighbor searches |
| Cmlpack::neighbor::NeighborSearchRules< SortPolicy, MetricType, TreeType > | The NeighborSearchRules class is a template helper class used by NeighborSearch class when performing distance-based neighbor searches |
| Cmlpack::neighbor::NeighborSearchRules< SortPolicy, MetricType, TreeType >::CandidateCmp | Compare two candidates based on the distance |
| Cmlpack::neighbor::NeighborSearchStat< SortPolicy > | Extra data for each node in the tree |
| Cmlpack::neighbor::NSModel< SortPolicy > | The NSModel class provides an easy way to serialize a model, abstracts away the different types of trees, and also reflects the NeighborSearch API |
| Cmlpack::neighbor::NSModelName< SortPolicy > | |
| Cmlpack::neighbor::NSModelName< FurthestNeighborSort > | |
| Cmlpack::neighbor::NSModelName< NearestNeighborSort > | |
| Cmlpack::neighbor::QDAFN< MatType > | |
| Cmlpack::neighbor::RAModel< SortPolicy > | The RAModel class provides an abstraction for the RASearch class, abstracting away the TreeType parameter and allowing it to be specified at runtime in this class |
| Cmlpack::neighbor::RAQueryStat< SortPolicy > | Extra data for each node in the tree |
| Cmlpack::neighbor::RASearch< SortPolicy, MetricType, MatType, TreeType > | The RASearch class: This class provides a generic manner to perform rank-approximate search via random-sampling |
| Cmlpack::neighbor::RASearchRules< SortPolicy, MetricType, TreeType > | The RASearchRules class is a template helper class used by RASearch class when performing rank-approximate search via random-sampling |
| Cmlpack::neighbor::RASearchRules< SortPolicy, MetricType, TreeType >::CandidateCmp | Compare two candidates based on the distance |
| Cmlpack::neighbor::RAUtil | |
| Cmlpack::nn::SparseAutoencoder< OptimizerType > | A sparse autoencoder is a neural network whose aim to learn compressed representations of the data, typically for dimensionality reduction, with a constraint on the activity of the neurons in the network |
| Cmlpack::nn::SparseAutoencoderFunction | This is a class for the sparse autoencoder objective function |
| Cmlpack::optimization::AdaDelta< DecomposableFunctionType > | Adadelta is an optimizer that uses two ideas to improve upon the two main drawbacks of the Adagrad method: |
| Cmlpack::optimization::Adam< DecomposableFunctionType > | Adam is an optimizer that computes individual adaptive learning rates for different parameters from estimates of first and second moments of the gradients |
| Cmlpack::optimization::AugLagrangian< LagrangianFunction > | The AugLagrangian class implements the Augmented Lagrangian method of optimization |
| Cmlpack::optimization::AugLagrangianFunction< LagrangianFunction > | This is a utility class used by AugLagrangian, meant to wrap a LagrangianFunction into a function usable by a simple optimizer like L-BFGS |
| Cmlpack::optimization::AugLagrangianTestFunction | This function is taken from "Practical Mathematical Optimization" (Snyman), section 5.3.8 ("Application of the Augmented Lagrangian Method") |
| Cmlpack::optimization::ExponentialSchedule | The exponential cooling schedule cools the temperature T at every step according to the equation |
| Cmlpack::optimization::GockenbachFunction | This function is taken from M |
| Cmlpack::optimization::GradientDescent< FunctionType > | Gradient Descent is a technique to minimize a function |
| Cmlpack::optimization::L_BFGS< FunctionType > | The generic L-BFGS optimizer, which uses a back-tracking line search algorithm to minimize a function |
| Cmlpack::optimization::LovaszThetaSDP | This function is the Lovasz-Theta semidefinite program, as implemented in the following paper: |
| Cmlpack::optimization::LRSDP< SDPType > | LRSDP is the implementation of Monteiro and Burer's formulation of low-rank semidefinite programs (LR-SDP) |
| Cmlpack::optimization::LRSDPFunction< SDPType > | The objective function that LRSDP is trying to optimize |
| Cmlpack::optimization::MiniBatchSGD< DecomposableFunctionType > | Mini-batch Stochastic Gradient Descent is a technique for minimizing a function which can be expressed as a sum of other functions |
| Cmlpack::optimization::PrimalDualSolver< SDPType > | Interface to a primal dual interior point solver |
| Cmlpack::optimization::RMSprop< DecomposableFunctionType > | RMSprop is an optimizer that utilizes the magnitude of recent gradients to normalize the gradients |
| Cmlpack::optimization::SA< FunctionType, CoolingScheduleType > | Simulated Annealing is an stochastic optimization algorithm which is able to deliver near-optimal results quickly without knowing the gradient of the function being optimized |
| Cmlpack::optimization::SDP< ObjectiveMatrixType > | Specify an SDP in primal form |
| Cmlpack::optimization::SGD< DecomposableFunctionType > | Stochastic Gradient Descent is a technique for minimizing a function which can be expressed as a sum of other functions |
| Cmlpack::optimization::test::GDTestFunction | Very, very simple test function which is the composite of three other functions |
| Cmlpack::optimization::test::GeneralizedRosenbrockFunction | The Generalized Rosenbrock function in n dimensions, defined by f(x) = sum_i^{n - 1} (f(i)(x)) f_i(x) = 100 * (x_i^2 - x_{i + 1})^2 + (1 - x_i)^2 x_0 = [-1.2, 1, -1.2, 1, ...] |
| Cmlpack::optimization::test::RosenbrockFunction | The Rosenbrock function, defined by f(x) = f1(x) + f2(x) f1(x) = 100 (x2 - x1^2)^2 f2(x) = (1 - x1)^2 x_0 = [-1.2, 1] |
| Cmlpack::optimization::test::RosenbrockWoodFunction | The Generalized Rosenbrock function in 4 dimensions with the Wood Function in four dimensions |
| Cmlpack::optimization::test::SGDTestFunction | Very, very simple test function which is the composite of three other functions |
| Cmlpack::optimization::test::WoodFunction | The Wood function, defined by f(x) = f1(x) + f2(x) + f3(x) + f4(x) + f5(x) + f6(x) f1(x) = 100 (x2 - x1^2)^2 f2(x) = (1 - x1)^2 f3(x) = 90 (x4 - x3^2)^2 f4(x) = (1 - x3)^2 f5(x) = 10 (x2 + x4 - 2)^2 f6(x) = (1 / 10) (x2 - x4)^2 x_0 = [-3, -1, -3, -1] |
| Cmlpack::pca::ExactSVDPolicy | Implementation of the exact SVD policy |
| Cmlpack::pca::PCAType< DecompositionPolicy > | This class implements principal components analysis (PCA) |
| Cmlpack::pca::QUICSVDPolicy | Implementation of the QUIC-SVD policy |
| Cmlpack::pca::RandomizedSVDPolicy | Implementation of the randomized SVD policy |
| Cmlpack::perceptron::Perceptron< LearnPolicy, WeightInitializationPolicy, MatType > | This class implements a simple perceptron (i.e., a single layer neural network) |
| Cmlpack::perceptron::RandomInitialization | This class is used to initialize weights for the weightVectors matrix in a random manner |
| Cmlpack::perceptron::SimpleWeightUpdate | |
| Cmlpack::perceptron::ZeroInitialization | This class is used to initialize the matrix weightVectors to zero |
| Cmlpack::radical::Radical | An implementation of RADICAL, an algorithm for independent component analysis (ICA) |
| Cmlpack::range::RangeSearch< MetricType, MatType, TreeType > | The RangeSearch class is a template class for performing range searches |
| Cmlpack::range::RangeSearchRules< MetricType, TreeType > | The RangeSearchRules class is a template helper class used by RangeSearch class when performing range searches |
| Cmlpack::range::RangeSearchStat | Statistic class for RangeSearch, to be set to the StatisticType of the tree type that range search is being performed with |
| Cmlpack::range::RSModel | |
| Cmlpack::range::RSModelName | |
| Cmlpack::regression::LARS | An implementation of LARS, a stage-wise homotopy-based algorithm for l1-regularized linear regression (LASSO) and l1+l2 regularized linear regression (Elastic Net) |
| Cmlpack::regression::LinearRegression | A simple linear regression algorithm using ordinary least squares |
| Cmlpack::regression::LogisticRegression< MatType > | The LogisticRegression class implements an L2-regularized logistic regression model, and supports training with multiple optimizers and classification |
| Cmlpack::regression::LogisticRegressionFunction< MatType > | The log-likelihood function for the logistic regression objective function |
| Cmlpack::regression::SoftmaxRegression< OptimizerType > | Softmax Regression is a classifier which can be used for classification when the data available can take two or more class values |
| Cmlpack::regression::SoftmaxRegressionFunction | |
| Cmlpack::sparse_coding::DataDependentRandomInitializer | A data-dependent random dictionary initializer for SparseCoding |
| Cmlpack::sparse_coding::NothingInitializer | A DictionaryInitializer for SparseCoding which does not initialize anything; it is useful for when the dictionary is already known and will be set with SparseCoding::Dictionary() |
| Cmlpack::sparse_coding::RandomInitializer | A DictionaryInitializer for use with the SparseCoding class |
| Cmlpack::sparse_coding::SparseCoding | An implementation of Sparse Coding with Dictionary Learning that achieves sparsity via an l1-norm regularizer on the codes (LASSO) or an (l1+l2)-norm regularizer on the codes (the Elastic Net) |
| Cmlpack::svd::QUIC_SVD | QUIC-SVD is a matrix factorization technique, which operates in a subspace such that A's approximation in that subspace has minimum error(A being the data matrix) |
| Cmlpack::svd::RandomizedSVD | Randomized SVD is a matrix factorization that is based on randomized matrix approximation techniques, developed in in "Finding structure with randomness:
Probabilistic algorithms for constructing approximate matrix decompositions" |
| Cmlpack::svd::RegularizedSVD< OptimizerType > | Regularized SVD is a matrix factorization technique that seeks to reduce the error on the training set, that is on the examples for which the ratings have been provided by the users |
| Cmlpack::svd::RegularizedSVDFunction | |
| Cmlpack::Timer | The timer class provides a way for mlpack methods to be timed |
| Cmlpack::Timers | |
| Cmlpack::tree::AllCategoricalSplit< FitnessFunction > | The AllCategoricalSplit is a splitting function that will split categorical features into many children: one child for each category |
| Cmlpack::tree::AllCategoricalSplit< FitnessFunction >::AuxiliarySplitInfo< ElemType > | |
| Cmlpack::tree::AxisParallelProjVector | AxisParallelProjVector defines an axis-parallel projection vector |
| Cmlpack::tree::BestBinaryNumericSplit< FitnessFunction > | The BestBinaryNumericSplit is a splitting function for decision trees that will exhaustively search a numeric dimension for the best binary split |
| Cmlpack::tree::BestBinaryNumericSplit< FitnessFunction >::AuxiliarySplitInfo< ElemType > | |
| Cmlpack::tree::BinaryNumericSplit< FitnessFunction, ObservationType > | The BinaryNumericSplit class implements the numeric feature splitting strategy devised by Gama, Rocha, and Medas in the following paper: |
| Cmlpack::tree::BinaryNumericSplitInfo< ObservationType > | |
| Cmlpack::tree::BinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType > | A binary space partitioning tree, such as a KD-tree or a ball tree |
| Cmlpack::tree::BinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType >::BreadthFirstDualTreeTraverser< RuleType > | |
| Cmlpack::tree::BinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType >::DualTreeTraverser< RuleType > | A dual-tree traverser for binary space trees; see dual_tree_traverser.hpp |
| Cmlpack::tree::BinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType >::SingleTreeTraverser< RuleType > | A single-tree traverser for binary space trees; see single_tree_traverser.hpp for implementation |
| Cmlpack::tree::CategoricalSplitInfo | |
| Cmlpack::tree::CompareCosineNode | |
| Cmlpack::tree::CosineTree | |
| Cmlpack::tree::CoverTree< MetricType, StatisticType, MatType, RootPointPolicy > | A cover tree is a tree specifically designed to speed up nearest-neighbor computation in high-dimensional spaces |
| Cmlpack::tree::CoverTree< MetricType, StatisticType, MatType, RootPointPolicy >::DualTreeTraverser< RuleType > | A dual-tree cover tree traverser; see dual_tree_traverser.hpp |
| Cmlpack::tree::CoverTree< MetricType, StatisticType, MatType, RootPointPolicy >::DualTreeTraverser< RuleType >::DualCoverTreeMapEntry | Struct used for traversal |
| Cmlpack::tree::CoverTree< MetricType, StatisticType, MatType, RootPointPolicy >::SingleTreeTraverser< RuleType > | A single-tree cover tree traverser; see single_tree_traverser.hpp for implementation |
| Cmlpack::tree::DiscreteHilbertValue< TreeElemType > | The DiscreteHilbertValue class stores Hilbert values for all of the points in a RectangleTree node, and calculates Hilbert values for new points |
| Cmlpack::tree::EmptyStatistic | Empty statistic if you are not interested in storing statistics in your tree |
| Cmlpack::tree::ExampleTree< MetricType, StatisticType, MatType > | This is not an actual space tree but instead an example tree that exists to show and document all the functions that mlpack trees must implement |
| Cmlpack::tree::FirstPointIsRoot | This class is meant to be used as a choice for the policy class RootPointPolicy of the CoverTree class |
| Cmlpack::tree::GiniGain | The Gini gain, a measure of set purity usable as a fitness function (FitnessFunction) for decision trees |
| Cmlpack::tree::GiniImpurity | |
| Cmlpack::tree::GreedySingleTreeTraverser< TreeType, RuleType > | |
| Cmlpack::tree::HilbertRTreeAuxiliaryInformation< TreeType, HilbertValueType > | |
| Cmlpack::tree::HilbertRTreeDescentHeuristic | This class chooses the best child of a node in a Hilbert R tree when inserting a new point |
| Cmlpack::tree::HilbertRTreeSplit< splitOrder > | The splitting procedure for the Hilbert R tree |
| Cmlpack::tree::HoeffdingCategoricalSplit< FitnessFunction > | This is the standard Hoeffding-bound categorical feature proposed in the paper below: |
| Cmlpack::tree::HoeffdingNumericSplit< FitnessFunction, ObservationType > | The HoeffdingNumericSplit class implements the numeric feature splitting strategy alluded to by Domingos and Hulten in the following paper: |
| Cmlpack::tree::HoeffdingTree< FitnessFunction, NumericSplitType, CategoricalSplitType > | The HoeffdingTree object represents all of the necessary information for a Hoeffding-bound-based decision tree |
| Cmlpack::tree::HoeffdingTreeModel | This class is a serializable Hoeffding tree model that can hold four different types of Hoeffding trees |
| Cmlpack::tree::HyperplaneBase< BoundT, ProjVectorT > | HyperplaneBase defines a splitting hyperplane based on a projection vector and projection value |
| Cmlpack::tree::InformationGain | The standard information gain criterion, used for calculating gain in decision trees |
| Cmlpack::tree::IsSpillTree< TreeType > | |
| Cmlpack::tree::IsSpillTree< tree::SpillTree< MetricType, StatisticType, MatType, HyperplaneType, SplitType > > | |
| Cmlpack::tree::MeanSpaceSplit< MetricType, MatType > | |
| Cmlpack::tree::MeanSplit< BoundType, MatType > | A binary space partitioning tree node is split into its left and right child |
| Cmlpack::tree::MeanSplit< BoundType, MatType >::SplitInfo | An information about the partition |
| Cmlpack::tree::MidpointSpaceSplit< MetricType, MatType > | |
| Cmlpack::tree::MidpointSplit< BoundType, MatType > | A binary space partitioning tree node is split into its left and right child |
| Cmlpack::tree::MidpointSplit< BoundType, MatType >::SplitInfo | A struct that contains an information about the split |
| Cmlpack::tree::MinimalCoverageSweep< SplitPolicy > | The MinimalCoverageSweep class finds a partition along which we can split a node according to the coverage of two resulting nodes |
| Cmlpack::tree::MinimalCoverageSweep< SplitPolicy >::SweepCost< TreeType > | A struct that provides the type of the sweep cost |
| Cmlpack::tree::MinimalSplitsNumberSweep< SplitPolicy > | The MinimalSplitsNumberSweep class finds a partition along which we can split a node according to the number of required splits of the node |
| Cmlpack::tree::MinimalSplitsNumberSweep< SplitPolicy >::SweepCost< typename > | A struct that provides the type of the sweep cost |
| Cmlpack::tree::NoAuxiliaryInformation< TreeType > | |
| Cmlpack::tree::NumericSplitInfo< ObservationType > | |
| Cmlpack::tree::Octree< MetricType, StatisticType, MatType > | |
| Cmlpack::tree::Octree< MetricType, StatisticType, MatType >::DualTreeTraverser< MetricType, StatisticType, MatType > | A dual-tree traverser; see dual_tree_traverser.hpp |
| Cmlpack::tree::Octree< MetricType, StatisticType, MatType >::SingleTreeTraverser< RuleType > | A single-tree traverser; see single_tree_traverser.hpp |
| Cmlpack::tree::Octree< MetricType, StatisticType, MatType >::SplitInfo | This is used for sorting points while splitting |
| Cmlpack::tree::ProjVector | ProjVector defines a general projection vector (not necessarily axis-parallel) |
| Cmlpack::tree::QueueFrame< TreeType, TraversalInfoType > | |
| Cmlpack::tree::RectangleTree< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType > | A rectangle type tree tree, such as an R-tree or X-tree |
| Cmlpack::tree::RectangleTree< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType >::DualTreeTraverser< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType > | A dual tree traverser for rectangle type trees |
| Cmlpack::tree::RectangleTree< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType >::DualTreeTraverser< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType >::NodeAndScore< RuleType > | |
| Cmlpack::tree::RectangleTree< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType >::SingleTreeTraverser< RuleType > | A single traverser for rectangle type trees |
| Cmlpack::tree::RectangleTree< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType >::SingleTreeTraverser< RuleType >::NodeAndScore | |
| Cmlpack::tree::RPlusPlusTreeAuxiliaryInformation< TreeType > | |
| Cmlpack::tree::RPlusPlusTreeDescentHeuristic | |
| Cmlpack::tree::RPlusPlusTreeSplitPolicy | The RPlusPlusTreeSplitPolicy helps to determine the subtree into which we should insert a child of an intermediate node that is being split |
| Cmlpack::tree::RPlusTreeDescentHeuristic | |
| Cmlpack::tree::RPlusTreeSplit< SplitPolicyType, SweepType > | The RPlusTreeSplit class performs the split process of a node on overflow |
| Cmlpack::tree::RPlusTreeSplitPolicy | The RPlusPlusTreeSplitPolicy helps to determine the subtree into which we should insert a child of an intermediate node that is being split |
| Cmlpack::tree::RPTreeMaxSplit< BoundType, MatType > | This class splits a node by a random hyperplane |
| Cmlpack::tree::RPTreeMaxSplit< BoundType, MatType >::SplitInfo | An information about the partition |
| Cmlpack::tree::RPTreeMeanSplit< BoundType, MatType > | This class splits a binary space tree |
| Cmlpack::tree::RPTreeMeanSplit< BoundType, MatType >::SplitInfo | An information about the partition |
| Cmlpack::tree::RStarTreeDescentHeuristic | When descending a RectangleTree to insert a point, we need to have a way to choose a child node when the point isn't enclosed by any of them |
| Cmlpack::tree::RStarTreeSplit | A Rectangle Tree has new points inserted at the bottom |
| Cmlpack::tree::RTreeDescentHeuristic | When descending a RectangleTree to insert a point, we need to have a way to choose a child node when the point isn't enclosed by any of them |
| Cmlpack::tree::RTreeSplit | A Rectangle Tree has new points inserted at the bottom |
| Cmlpack::tree::SpaceSplit< MetricType, MatType > | |
| Cmlpack::tree::SpillTree< MetricType, StatisticType, MatType, HyperplaneType, SplitType > | A hybrid spill tree is a variant of binary space trees in which the children of a node can "spill over" each other, and contain shared datapoints |
| Cmlpack::tree::SpillTree< MetricType, StatisticType, MatType, HyperplaneType, SplitType >::SpillDualTreeTraverser< MetricType, StatisticType, MatType, HyperplaneType, SplitType > | A generic dual-tree traverser for hybrid spill trees; see spill_dual_tree_traverser.hpp for implementation |
| Cmlpack::tree::SpillTree< MetricType, StatisticType, MatType, HyperplaneType, SplitType >::SpillSingleTreeTraverser< MetricType, StatisticType, MatType, HyperplaneType, SplitType > | A generic single-tree traverser for hybrid spill trees; see spill_single_tree_traverser.hpp for implementation |
| Cmlpack::tree::TraversalInfo< TreeType > | The TraversalInfo class holds traversal information which is used in dual-tree (and single-tree) traversals |
| Cmlpack::tree::TreeTraits< TreeType > | The TreeTraits class provides compile-time information on the characteristics of a given tree type |
| Cmlpack::tree::TreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, bound::BallBound, SplitType > > | This is a specialization of the TreeType class to the BallTree tree type |
| Cmlpack::tree::TreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, bound::CellBound, SplitType > > | This is a specialization of the TreeType class to the UBTree tree type |
| Cmlpack::tree::TreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, bound::HollowBallBound, SplitType > > | This is a specialization of the TreeType class to an arbitrary tree with HollowBallBound (currently only the vantage point tree is supported) |
| Cmlpack::tree::TreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, BoundType, RPTreeMaxSplit > > | This is a specialization of the TreeType class to the max-split random projection tree |
| Cmlpack::tree::TreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, BoundType, RPTreeMeanSplit > > | This is a specialization of the TreeType class to the mean-split random projection tree |
| Cmlpack::tree::TreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType > > | This is a specialization of the TreeTraits class to the BinarySpaceTree tree type |
| Cmlpack::tree::TreeTraits< CoverTree< MetricType, StatisticType, MatType, RootPointPolicy > > | The specialization of the TreeTraits class for the CoverTree tree type |
| Cmlpack::tree::TreeTraits< Octree< MetricType, StatisticType, MatType > > | This is a specialization of the TreeTraits class to the Octree tree type |
| Cmlpack::tree::TreeTraits< RectangleTree< MetricType, StatisticType, MatType, RPlusTreeSplit< SplitPolicyType, SweepType >, DescentType, AuxiliaryInformationType > > | Since the R+/R++ tree can not have overlapping children, we should define traits for the R+/R++ tree |
| Cmlpack::tree::TreeTraits< RectangleTree< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType > > | This is a specialization of the TreeType class to the RectangleTree tree type |
| Cmlpack::tree::TreeTraits< SpillTree< MetricType, StatisticType, MatType, HyperplaneType, SplitType > > | This is a specialization of the TreeType class to the SpillTree tree type |
| Cmlpack::tree::UBTreeSplit< BoundType, MatType > | Split a node into two parts according to the median address of points contained in the node |
| Cmlpack::tree::VantagePointSplit< BoundType, MatType, MaxNumSamples > | The class splits a binary space partitioning tree node according to the median distance to the vantage point |
| Cmlpack::tree::VantagePointSplit< BoundType, MatType, MaxNumSamples >::SplitInfo | A struct that contains an information about the split |
| Cmlpack::tree::XTreeAuxiliaryInformation< TreeType > | The XTreeAuxiliaryInformation class provides information specific to X trees for each node in a RectangleTree |
| Cmlpack::tree::XTreeAuxiliaryInformation< TreeType >::SplitHistoryStruct | The X tree requires that the tree records it's "split history" |
| Cmlpack::tree::XTreeSplit | A Rectangle Tree has new points inserted at the bottom |
| Cmlpack::util::CLIDeleter | Extremely simple class whose only job is to delete the existing CLI object at the end of execution |
| Cmlpack::util::IsStdVector< T > | Metaprogramming structure for vector detection |
| Cmlpack::util::IsStdVector< std::vector< T, A > > | Metaprogramming structure for vector detection |
| Cmlpack::util::NullOutStream | Used for Log::Debug when not compiled with debugging symbols |
| Cmlpack::util::Option< N > | A static object whose constructor registers a parameter with the CLI class |
| Cmlpack::util::ParamData | This structure holds all of the information about a single parameter, including its value (which is set when ParseCommandLine() is called) |
| Cmlpack::util::ParameterType< T > | Utility struct to return the type that boost::program_options should accept for a given input type |
| Cmlpack::util::ParameterType< arma::Mat< eT > > | For matrix types, boost::program_options will accept a std::string, not an arma::mat (since it is not clear how to specify a matrix on the command-line) |
| Cmlpack::util::ParameterType< std::tuple< mlpack::data::DatasetMapper< PolicyType >, arma::Mat< eT > > > | For matrix+dataset info types, we should accept a std::string |
| Cmlpack::util::ParameterTypeDeducer< HasSerialize, T > | |
| Cmlpack::util::ParameterTypeDeducer< true, T > | |
| Cmlpack::util::PrefixedOutStream | Allows us to output to an ostream with a prefix at the beginning of each line, in the same way we would output to cout or cerr |
| Cmlpack::util::ProgramDoc | A static object whose constructor registers program documentation with the CLI class |
| ►Cmlpack::neighbor::NeighborSearchStat< neighbor::NearestNeighborSort > | |
| Cmlpack::kmeans::DualTreeKMeansStatistic | |
| ►CtemplateAuxiliarySplitInfo< ElemType > | |
| Cmlpack::tree::DecisionTree< FitnessFunction, NumericSplitType, CategoricalSplitType, ElemType, NoRecursion > | This class implements a generic decision tree learner |
| Cmlpack::math::RangeType< double > | |
| Cmlpack::math::RangeType< ElemType > | |
| Cmlpack::neighbor::RASearch< tree::HilbertRTree > | |
| Cmlpack::neighbor::RASearch< tree::KDTree > | |
| Cmlpack::neighbor::RASearch< tree::Octree > | |
| Cmlpack::neighbor::RASearch< tree::RPlusPlusTree > | |
| Cmlpack::neighbor::RASearch< tree::RPlusTree > | |
| Cmlpack::neighbor::RASearch< tree::RStarTree > | |
| Cmlpack::neighbor::RASearch< tree::RTree > | |
| Cmlpack::neighbor::RASearch< tree::StandardCoverTree > | |
| Cmlpack::neighbor::RASearch< tree::UBTree > | |
| Cmlpack::neighbor::RASearch< tree::XTree > | |
| Cmlpack::optimization::SDP< arma::sp_mat > | |
| ►CT | |
| Cmlpack::data::PointerShim< T > | A shim for pointers |
1.8.11
