mlpack 3.4.2
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12]
 Ctemplate AuxiliarySplitInfo
 CBernoulliDistribution< arma::mat >
 Ctemplate AuxiliarySplitInfo
 Cversion< mlpack::adaboost::AdaBoost< WeakLearnerType, MatType > >
 Cversion< mlpack::ann::AddMerge< InputDataType, OutputDataType, CustomLayers... > >
 Cversion< mlpack::ann::AtrousConvolution< ForwardConvolutionRule, BackwardConvolutionRule, GradientConvolutionRule, InputDataType, OutputDataType > >
 Cversion< mlpack::ann::BRNN< OutputLayerType, MergeLayerType, MergeOutputType, InitializationRuleType, CustomLayer... > >
 Cversion< mlpack::ann::Convolution< ForwardConvolutionRule, BackwardConvolutionRule, GradientConvolutionRule, InputDataType, OutputDataType > >
 Cversion< mlpack::ann::FFN< OutputLayerType, InitializationRuleType, CustomLayer... > >
 Cversion< mlpack::ann::RNN< OutputLayerType, InitializationRuleType, CustomLayer... > >
 Cversion< mlpack::ann::Sequential< InputDataType, OutputDataType, Residual, CustomLayers... > >
 Cversion< mlpack::ann::TransposedConvolution< ForwardConvolutionRule, BackwardConvolutionRule, GradientConvolutionRule, InputDataType, OutputDataType > >
 Cversion< mlpack::kde::KDE< KernelType, MetricType, MatType, TreeType, DualTreeTraversalType, SingleTreeTraversalType > >
 Cstatic_visitor
 CCVBase< MLAlgorithm, arma::mat, typename MetaInfoExtractor< MLAlgorithm, arma::mat >::PredictionsType, typename MetaInfoExtractor< MLAlgorithm, arma::mat, typename MetaInfoExtractor< MLAlgorithm, arma::mat >::PredictionsType >::WeightsType >
 CFFN< EmptyLoss<>, GaussianInitialization >
 CFFN< MeanSquaredError<>, GaussianInitialization >
 CHMM< distribution::RegressionDistribution >
 CHRectBound< metric::EuclideanDistance, ElemType >
 CHyperplaneBase< MetricType >
 CInitHMMModel
 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 > >
 CLMetric< 2, true >
 CMetaInfoExtractor< MLAlgorithm, arma::mat >
 CMetaInfoExtractor< MLAlgorithm, arma::mat, typename MetaInfoExtractor< MLAlgorithm, arma::mat >::PredictionsType >
 CAdaBoost< WeakLearnerType, MatType >The AdaBoost class
 CAdaBoostModelThe model to save to disk
 CAMF< TerminationPolicyType, InitializationRuleType, UpdateRuleType >This class implements AMF (alternating matrix factorization) on the given matrix V
 CAverageInitializationThis initialization rule initializes matrix W and H to root of the average of V, perturbed with uniform noise
 CCompleteIncrementalTermination< TerminationPolicy >This class acts as a wrapper for basic termination policies to be used by SVDCompleteIncrementalLearning
 CGivenInitializationThis initialization rule for AMF simply fills the W and H matrices with the matrices given to the constructor of this object
 CIncompleteIncrementalTermination< TerminationPolicy >This class acts as a wrapper for basic termination policies to be used by SVDIncompleteIncrementalLearning
 CMaxIterationTerminationThis termination policy only terminates when the maximum number of iterations has been reached
 CMergeInitialization< WInitializationRuleType, HInitializationRuleType >This initialization rule for AMF simply takes in two initialization rules, and initialize W with the first rule and H with the second rule
 CNMFALSUpdateThis class implements a method titled 'Alternating Least Squares' described in the following paper:
 CNMFMultiplicativeDistanceUpdateThe multiplicative distance update rules for matrices W and H
 CNMFMultiplicativeDivergenceUpdateThis follows a method described in the paper 'Algorithms for Non-negative
 CRandomAcolInitialization< columnsToAverage >This class initializes the W matrix of the AMF algorithm by averaging p randomly chosen columns of V
 CRandomInitializationThis initialization rule for AMF simply fills the W and H matrices with uniform random noise in [0, 1]
 CSimpleResidueTerminationThis class implements a simple residue-based termination policy
 CSimpleToleranceTermination< MatType >This class implements residue tolerance termination policy
 CSVDBatchLearningThis class implements SVD batch learning with momentum
 CSVDCompleteIncrementalLearning< MatType >This class computes SVD using complete incremental batch learning, as described in the following paper:
 CSVDCompleteIncrementalLearning< arma::sp_mat >TODO : Merge this template specialized function for sparse matrix using common row_col_iterator
 CSVDIncompleteIncrementalLearningThis class computes SVD using incomplete incremental batch learning, as described in the following paper:
 CValidationRMSETermination< MatType >This class implements validation termination policy based on RMSE index
 CAdaptiveMaxPooling< InputDataType, OutputDataType >Implementation of the AdaptiveMaxPooling layer
 CAdaptiveMeanPooling< InputDataType, OutputDataType >Implementation of the AdaptiveMeanPooling
 CAdd< InputDataType, OutputDataType >Implementation of the Add module class
 CAddMerge< InputDataType, OutputDataType, CustomLayers >Implementation of the AddMerge module class
 CAlphaDropout< InputDataType, OutputDataType >The alpha - dropout layer is a regularizer that randomly with probability 'ratio' sets input values to alphaDash
 CAtrousConvolution< ForwardConvolutionRule, BackwardConvolutionRule, GradientConvolutionRule, InputDataType, OutputDataType >Implementation of the Atrous Convolution class
 CAddTaskGenerator of instances of the binary addition task
 CCopyTaskGenerator of instances of the binary sequence copy task
 CSortTaskGenerator of instances of the sequence sort task
 CBaseLayer< ActivationFunction, InputDataType, OutputDataType >Implementation of the base layer
 CBatchNorm< InputDataType, OutputDataType >Declaration of the Batch Normalization layer class
 CBernoulliDistribution< DataType >Multiple independent Bernoulli distributions
 CBilinearInterpolation< InputDataType, OutputDataType >Definition and Implementation of the Bilinear Interpolation Layer
 CBinaryRBMFor more information, see the following paper:
 CBRNN< OutputLayerType, MergeLayerType, MergeOutputType, InitializationRuleType, CustomLayers >Implementation of a standard bidirectional recurrent neural network container
 CCELU< InputDataType, OutputDataType >The CELU activation function, defined by
 CConcat< InputDataType, OutputDataType, CustomLayers >Implementation of the Concat class
 CConcatenate< InputDataType, OutputDataType >Implementation of the Concatenate module class
 CConcatPerformance< OutputLayerType, InputDataType, OutputDataType >Implementation of the concat performance class
 CConstant< InputDataType, OutputDataType >Implementation of the constant layer
 CConstInitializationThis class is used to initialize weight matrix with constant values
 CConvolution< ForwardConvolutionRule, BackwardConvolutionRule, GradientConvolutionRule, InputDataType, OutputDataType >Implementation of the Convolution class
 CCosineEmbeddingLoss< InputDataType, OutputDataType >Cosine Embedding Loss function is used for measuring whether two inputs are similar or dissimilar, using the cosine distance, and is typically used for learning nonlinear embeddings or semi-supervised learning
 CCReLU< InputDataType, OutputDataType >A concatenated ReLU has two outputs, one ReLU and one negative ReLU, concatenated together
 CCrossEntropyError< InputDataType, OutputDataType >The cross-entropy performance function measures the network's performance according to the cross-entropy between the input and target distributions
 CDCGANFor more information, see the following paper:
 CDiceLoss< InputDataType, OutputDataType >The dice loss performance function measures the network's performance according to the dice coefficient between the input and target distributions
 CDropConnect< 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)
 CDropout< 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) rather than during test time so as to keep the expected sum same
 CEarthMoverDistance< InputDataType, OutputDataType >The earth mover distance function measures the network's performance according to the Kantorovich-Rubinstein duality approximation
 CElishFunctionThe ELiSH function, defined by
 CElliotFunctionThe Elliot function, defined by
 CELU< InputDataType, OutputDataType >The ELU activation function, defined by
 CEmptyLoss< InputDataType, OutputDataType >The empty loss does nothing, letting the user calculate the loss outside the model
 CFastLSTM< InputDataType, OutputDataType >An implementation of a faster version of the Fast LSTM network layer
 CFFN< OutputLayerType, InitializationRuleType, CustomLayers >Implementation of a standard feed forward network
 CFFTConvolution< BorderMode, padLastDim >Computes the two-dimensional convolution through fft
 CFlexibleReLU< InputDataType, OutputDataType >The FlexibleReLU activation function, defined by
 CFullConvolution
 CGAN< Model, InitializationRuleType, Noise, PolicyType >The implementation of the standard GAN module
 CGaussianFunctionThe gaussian function, defined by
 CGaussianInitializationThis class is used to initialize weigth matrix with a gaussian
 CGELUFunctionThe GELU function, defined by
 CGlimpse< 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
 CGlorotInitializationType< Uniform >This class is used to initialize the weight matrix with the Glorot Initialization method
 CGRU< InputDataType, OutputDataType >An implementation of a gru network layer
 CHardShrink< InputDataType, OutputDataType >Hard Shrink operator is defined as,
 CHardSigmoidFunctionThe hard sigmoid function, defined by
 CHardTanH< InputDataType, OutputDataType >The Hard Tanh activation function, defined by
 CHeInitializationThis class is used to initialize weight matrix with the He initialization rule given by He et
 CHighway< InputDataType, OutputDataType, CustomLayers >Implementation of the Highway layer
 CHingeEmbeddingLoss< InputDataType, OutputDataType >The Hinge Embedding loss function is often used to compute the loss between y_true and y_pred
 CHuberLoss< InputDataType, OutputDataType >The Huber loss is a loss function used in robust regression, that is less sensitive to outliers in data than the squared error loss
 CIdentityFunctionThe identity function, defined by
 CInitTraits< InitRuleType >This is a template class that can provide information about various initialization methods
 CInitTraits< KathirvalavakumarSubavathiInitialization >Initialization traits of the kathirvalavakumar subavath initialization rule
 CInitTraits< NguyenWidrowInitialization >Initialization traits of the Nguyen-Widrow initialization rule
 CInvQuadFunctionThe Inverse Quadratic function, defined by
 CJoin< InputDataType, OutputDataType >Implementation of the Join module class
 CKathirvalavakumarSubavathiInitializationThis class is used to initialize the weight matrix with the method proposed by T
 CKLDivergence< InputDataType, OutputDataType >The Kullback–Leibler divergence is often used for continuous distributions (direct regression)
 CL1Loss< InputDataType, OutputDataType >The L1 loss is a loss function that measures the mean absolute error (MAE) between each element in the input x and target y
 CLayerNorm< InputDataType, OutputDataType >Declaration of the Layer Normalization class
 CLayerTraits< LayerType >This is a template class that can provide information about various layers
 CLeakyReLU< InputDataType, OutputDataType >The LeakyReLU activation function, defined by
 CLecunNormalInitializationThis class is used to initialize weight matrix with the Lecun Normalization initialization rule
 CLinear< InputDataType, OutputDataType, RegularizerType >Implementation of the Linear layer class
 CLinear3D< InputDataType, OutputDataType, RegularizerType >Implementation of the Linear3D layer class
 CLinearNoBias< InputDataType, OutputDataType, RegularizerType >Implementation of the LinearNoBias class
 CLiSHTFunctionThe LiSHT function, defined by
 CLogCoshLoss< InputDataType, OutputDataType >The Log-Hyperbolic-Cosine loss function is often used to improve variational auto encoder
 CLogisticFunctionThe logistic function, defined by
 CLogSoftMax< InputDataType, OutputDataType >Implementation of the log softmax layer
 CLookup< InputDataType, OutputDataType >The Lookup class stores word embeddings and retrieves them using tokens
 CLRegularizer< TPower >The L_p regularizer for arbitrary integer p
 CLSTM< InputDataType, OutputDataType >Implementation of the LSTM module class
 CMarginRankingLoss< InputDataType, OutputDataType >Margin ranking loss measures the loss given inputs and a label vector with values of 1 or -1
 CMaxPooling< InputDataType, OutputDataType >Implementation of the MaxPooling layer
 CMaxPoolingRule
 CMeanAbsolutePercentageError< InputDataType, OutputDataType >The mean absolute percentage error performance function measures the network's performance according to the mean of the absolute difference between input and target divided by target
 CMeanBiasError< InputDataType, OutputDataType >The mean bias error performance function measures the network's performance according to the mean of errors
 CMeanPooling< InputDataType, OutputDataType >Implementation of the MeanPooling
 CMeanPoolingRule
 CMeanSquaredError< InputDataType, OutputDataType >The mean squared error performance function measures the network's performance according to the mean of squared errors
 CMeanSquaredLogarithmicError< InputDataType, OutputDataType >The mean squared logarithmic error performance function measures the network's performance according to the mean of squared logarithmic errors
 CMiniBatchDiscrimination< InputDataType, OutputDataType >Implementation of the MiniBatchDiscrimination layer
 CMishFunctionThe Mish function, defined by
 CMultiheadAttention< InputDataType, OutputDataType, RegularizerType >Multihead Attention allows the model to jointly attend to information from different representation subspaces at different positions
 CMultiplyConstant< InputDataType, OutputDataType >Implementation of the multiply constant layer
 CMultiplyMerge< InputDataType, OutputDataType, CustomLayers >Implementation of the MultiplyMerge module class
 CMultiQuadFunctionThe Multi Quadratic function, defined by
 CNaiveConvolution< BorderMode >Computes the two-dimensional convolution
 CNegativeLogLikelihood< InputDataType, OutputDataType >Implementation of the negative log likelihood layer
 CNetworkInitialization< InitializationRuleType, CustomLayers >This class is used to initialize the network with the given initialization rule
 CNguyenWidrowInitializationThis class is used to initialize the weight matrix with the Nguyen-Widrow method
 CNoisyLinear< InputDataType, OutputDataType >Implementation of the NoisyLinear layer class
 CNoRegularizerImplementation of the NoRegularizer
 CNormalDistribution< DataType >Implementation of the Normal Distribution function
 COivsInitialization< ActivationFunction >This class is used to initialize the weight matrix with the oivs method
 COrthogonalInitializationThis class is used to initialize the weight matrix with the orthogonal matrix initialization
 COrthogonalRegularizerImplementation of the OrthogonalRegularizer
 CPadding< InputDataType, OutputDataType >Implementation of the Padding module class
 CPoisson1FunctionThe Poisson one function, defined by
 CPoissonNLLLoss< InputDataType, OutputDataType >Implementation of the Poisson negative log likelihood loss
 CPositionalEncoding< InputDataType, OutputDataType >Positional Encoding injects some information about the relative or absolute position of the tokens in the sequence
 CPReLU< InputDataType, OutputDataType >The PReLU activation function, defined by (where alpha is trainable)
 CQuadraticFunctionThe Quadratic function, defined by
 CRandomInitializationThis class is used to initialize randomly the weight matrix
 CRBF< InputDataType, OutputDataType, Activation >Implementation of the Radial Basis Function layer
 CRBM< InitializationRuleType, DataType, PolicyType >The implementation of the RBM module
 CReconstructionLoss< InputDataType, OutputDataType, DistType >The reconstruction loss performance function measures the network's performance equal to the negative log probability of the target with the input distribution
 CRectifierFunctionThe rectifier function, defined by
 CRecurrent< InputDataType, OutputDataType, CustomLayers >Implementation of the RecurrentLayer class
 CRecurrentAttention< InputDataType, OutputDataType >This class implements the Recurrent Model for Visual Attention, using a variety of possible layer implementations
 CReinforceNormal< InputDataType, OutputDataType >Implementation of the reinforce normal layer
 CReparametrization< InputDataType, OutputDataType >Implementation of the Reparametrization layer class
 CRNN< OutputLayerType, InitializationRuleType, CustomLayers >Implementation of a standard recurrent neural network container
 CSelect< InputDataType, OutputDataType >The select module selects the specified column from a given input matrix
 CSequential< InputDataType, OutputDataType, Residual, CustomLayers >Implementation of the Sequential class
 CSigmoidCrossEntropyError< InputDataType, OutputDataType >The SigmoidCrossEntropyError performance function measures the network's performance according to the cross-entropy function between the input and target distributions
 CSoftMarginLoss< InputDataType, OutputDataType >
 CSoftmax< InputDataType, OutputDataType >Implementation of the Softmax layer
 CSoftmin< InputDataType, OutputDataType >Implementation of the Softmin layer
 CSoftplusFunctionThe softplus function, defined by
 CSoftShrink< InputDataType, OutputDataType >Soft Shrink operator is defined as,
 CSoftsignFunctionThe softsign function, defined by
 CSpatialDropout< InputDataType, OutputDataType >Implementation of the SpatialDropout layer
 CSpikeSlabRBMFor more information, see the following paper:
 CSplineFunctionThe Spline function, defined by
 CStandardGANFor more information, see the following paper:
 CSubview< InputDataType, OutputDataType >Implementation of the subview layer
 CSVDConvolution< BorderMode >Computes the two-dimensional convolution using singular value decomposition
 CSwishFunctionThe swish function, defined by
 CTanhFunctionThe tanh function, defined by
 CTransposedConvolution< ForwardConvolutionRule, BackwardConvolutionRule, GradientConvolutionRule, InputDataType, OutputDataType >Implementation of the Transposed Convolution class
 CValidConvolution
 CVirtualBatchNorm< InputDataType, OutputDataType >Declaration of the VirtualBatchNorm layer class
 CVRClassReward< InputDataType, OutputDataType >Implementation of the variance reduced classification reinforcement layer
 CWeightNorm< InputDataType, OutputDataType, CustomLayers >Declaration of the WeightNorm layer class
 CWGANFor more information, see the following paper:
 CWGANGPFor more information, see the following paper:
 CBacktraceProvides a backtrace
 CCLIOption< N >A static object whose constructor registers a parameter with the IO class
 CParameterType< T >Utility struct to return the type that CLI11 should accept for a given input type
 CParameterType< arma::Col< eT > >For vector types, CLI11 will accept a std::string, not an arma::Col<eT> (since it is not clear how to specify a vector on the command-line)
 CParameterType< arma::Mat< eT > >For matrix types, CLI11 will accept a std::string, not an arma::mat (since it is not clear how to specify a matrix on the command-line)
 CParameterType< arma::Row< eT > >For row vector types, CLI11 will accept a std::string, not an arma::Row<eT> (since it is not clear how to specify a vector on the command-line)
 CParameterType< std::tuple< mlpack::data::DatasetMapper< PolicyType, std::string >, arma::Mat< eT > > >For matrix+dataset info types, we should accept a std::string
 CParameterTypeDeducer< HasSerialize, T >
 CParameterTypeDeducer< true, T >
 CGoOption< T >The Go option class
 CJuliaOption< T >The Julia option class
 CBindingInfoUsed by the Markdown documentation generator to store multiple documentation objects, indexed by both the binding name (i.e
 CExampleWrapper
 CLongDescriptionWrapper
 CMDOption< T >The Markdown option class
 CProgramNameWrapper
 CSeeAlsoWrapper
 CShortDescriptionWrapper
 CPyOption< T >The Python option class
 CROption< T >The R option class
 CTestOption< N >A static object whose constructor registers a parameter with the IO class
 CBallBound< MetricType, VecType >Ball bound encloses a set of points at a specific distance (radius) from a specific point (center)
 CBoundTraits< BoundType >A class to obtain compile-time traits about BoundType classes
 CBoundTraits< BallBound< MetricType, VecType > >A specialization of BoundTraits for this bound type
 CBoundTraits< CellBound< MetricType, ElemType > >
 CBoundTraits< HollowBallBound< MetricType, ElemType > >A specialization of BoundTraits for this bound type
 CBoundTraits< HRectBound< MetricType, ElemType > >
 CCellBound< MetricType, ElemType >The CellBound class describes a bound that consists of a number of hyperrectangles
 CHollowBallBound< 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)
 CHRectBound< MetricType, ElemType >Hyper-rectangle bound for an L-metric
 CIsLMetric< MetricType >Utility struct where Value is true if and only if the argument is of type LMetric
 CIsLMetric< metric::LMetric< Power, TakeRoot > >Specialization for IsLMetric when the argument is of type LMetric
 CAverageInterpolationThis class performs average interpolation to generate interpolation weights for neighborhood-based collaborative filtering
 CBatchSVDPolicyImplementation of the Batch SVD policy to act as a wrapper when accessing Batch SVD from within CFType
 CBiasSVDPolicyImplementation of the Bias SVD policy to act as a wrapper when accessing Bias SVD from within CFType
 CCFModelThe model to save to disk
 CCFType< DecompositionPolicy, NormalizationType >This class implements Collaborative Filtering (CF)
 CCombinedNormalization< NormalizationTypes >This normalization class performs a sequence of normalization methods on raw ratings
 CCosineSearchNearest neighbor search with cosine distance
 CDummyClassThis class acts as a dummy class for passing as template parameter
 CItemMeanNormalizationThis normalization class performs item mean normalization on raw ratings
 CLMetricSearch< TPower >Nearest neighbor search with L_p distance
 CNMFPolicyImplementation of the NMF policy to act as a wrapper when accessing NMF from within CFType
 CNoNormalizationThis normalization class doesn't perform any normalization
 COverallMeanNormalizationThis normalization class performs overall mean normalization on raw ratings
 CPearsonSearchNearest neighbor search with pearson distance (or furthest neighbor search with pearson correlation)
 CRandomizedSVDPolicyImplementation of the Randomized SVD policy to act as a wrapper when accessing Randomized SVD from within CFType
 CRegressionInterpolationImplementation of regression-based interpolation method
 CRegSVDPolicyImplementation of the Regularized SVD policy to act as a wrapper when accessing Regularized SVD from within CFType
 CSimilarityInterpolationWith SimilarityInterpolation, interpolation weights are based on similarities between query user and its neighbors
 CSVDCompletePolicyImplementation of the SVD complete incremental policy to act as a wrapper when accessing SVD complete decomposition from within CFType
 CSVDIncompletePolicyImplementation of the SVD incomplete incremental to act as a wrapper when accessing SVD incomplete incremental from within CFType
 CSVDPlusPlusPolicyImplementation of the SVDPlusPlus policy to act as a wrapper when accessing SVDPlusPlus from within CFType
 CSVDWrapper< Factorizer >This class acts as the wrapper for all SVD factorizers which are incompatible with CF module
 CUserMeanNormalizationThis normalization class performs user mean normalization on raw ratings
 CZScoreNormalizationThis normalization class performs z-score normalization on raw ratings
 CAccuracyThe Accuracy is a metric of performance for classification algorithms that is equal to a proportion of correctly labeled test items among all ones for given test items
 CCVBase< MLAlgorithm, MatType, PredictionsType, WeightsType >An auxiliary class for cross-validation
 CF1< AS, PositiveClass >F1 is a metric of performance for classification algorithms that for binary classification is equal to $ 2 * precision * recall / (precision + recall) $
 CKFoldCV< MLAlgorithm, Metric, MatType, PredictionsType, WeightsType >The class KFoldCV implements k-fold cross-validation for regression and classification algorithms
 CMetaInfoExtractor< MLAlgorithm, MT, PT, WT >MetaInfoExtractor is a tool for extracting meta information about a given machine learning algorithm
 CMSEThe MeanSquaredError is a metric of performance for regression algorithms that is equal to the mean squared error between predicted values and ground truth (correct) values for given test items
 CNotFoundMethodForm
 CPrecision< AS, PositiveClass >Precision is a metric of performance for classification algorithms that for binary classification is equal to $ tp / (tp + fp) $, where $ tp $ and $ fp $ are the numbers of true positives and false positives respectively
 CR2ScoreThe R2 Score is a metric of performance for regression algorithms that represents the proportion of variance (here y) that has been explained by the independent variables in the model
 CRecall< AS, PositiveClass >Recall is a metric of performance for classification algorithms that for binary classification is equal to $ tp / (tp + fn) $, where $ tp $ and $ fn $ are the numbers of true positives and false negatives respectively
 CSelectMethodForm< MLAlgorithm, HMFs >A type function that selects a right method form
 CSelectMethodForm< MLAlgorithm >
 CSelectMethodForm< MLAlgorithm >::From< Forms >
 CSelectMethodForm< MLAlgorithm, HasMethodForm, HMFs... >
 CSelectMethodForm< MLAlgorithm, HasMethodForm, HMFs... >::From< Forms >
 CSilhouetteScoreThe Silhouette Score is a metric of performance for clustering that represents the quality of clusters made as a result
 CSimpleCV< MLAlgorithm, Metric, MatType, PredictionsType, WeightsType >SimpleCV splits data into two sets - training and validation sets - and then runs training on the training set and evaluates performance on the validation set
 CTrainForm< MatType, PredictionsType, WeightsType, DatasetInfo, NumClasses >A wrapper struct for holding a Train form
 CTrainFormBase4< PT, WT, T1, T2 >
 CTrainFormBase5< PT, WT, T1, T2, T3 >
 CTrainFormBase6< PT, WT, T1, T2, T3, T4 >
 CTrainFormBase7< PT, WT, T1, T2, T3, T4, T5 >
 CBagOfWordsEncodingPolicyDefinition of the BagOfWordsEncodingPolicy class
 CCharExtractThe class is used to split a string into characters
 CCustomImputation< T >A simple custom imputation class
 CDatasetMapper< PolicyType, InputType >Auxiliary information for a dataset, including mappings to/from strings (or other types) and the datatype of each dimension
 CDictionaryEncodingPolicyDicitonaryEnocdingPolicy is used as a helper class for StringEncoding
 CHasSerialize< T >
 CHasSerialize< T >::check< U, V, W >
 CHasSerializeFunction< T >
 CImageInfoImplements meta-data of images required by data::Load and data::Save for loading and saving images into arma::Mat
 CImputer< T, MapperType, StrategyType >Given a dataset of a particular datatype, replace user-specified missing value with a variable dependent on the StrategyType and MapperType
 CIncrementPolicyIncrementPolicy is used as a helper class for DatasetMapper
 CListwiseDeletion< T >A complete-case analysis to remove the values containing mappedValue
 CLoadCSVLoad the csv file.This class use boost::spirit to implement the parser, please refer to following link http://theboostcpplibraries.com/boost.spirit for quick review
 CMaxAbsScalerA simple MaxAbs Scaler class
 CMeanImputation< T >A simple mean imputation class
 CMeanNormalizationA simple Mean Normalization class
 CMedianImputation< T >This is a class implementation of simple median imputation
 CMinMaxScalerA simple MinMax Scaler class
 CMissingPolicyMissingPolicy is used as a helper class for DatasetMapper
 CPCAWhiteningA simple PCAWhitening class
 CScalingModelThe model to save to disk
 CSplitByAnyOfTokenizes a string using a set of delimiters
 CStandardScalerA simple Standard Scaler class
 CStringEncoding< EncodingPolicyType, DictionaryType >The class translates a set of strings into numbers using various encoding algorithms
 CStringEncodingDictionary< Token >This class provides a dictionary interface for the purpose of string encoding
 CStringEncodingDictionary< boost::string_view >
 CStringEncodingDictionary< int >
 CStringEncodingPolicyTraits< PolicyType >This is a template struct that provides some information about various encoding policies
 CStringEncodingPolicyTraits< DictionaryEncodingPolicy >The specialization provides some information about the dictionary encoding policy
 CTfIdfEncodingPolicyDefinition of the TfIdfEncodingPolicy class
 CZCAWhiteningA simple ZCAWhitening class
 CDBSCAN< RangeSearchType, PointSelectionPolicy >DBSCAN (Density-Based Spatial Clustering of Applications with Noise) is a clustering technique described in the following paper:
 COrderedPointSelectionThis class can be used to sequentially select the next point to use for DBSCAN
 CRandomPointSelectionThis class can be used to randomly select the next point to use for DBSCAN
 CDecisionStump< MatType >This class implements a decision stump
 CDTree< MatType, TagType >A density estimation tree is similar to both a decision tree and a space partitioning tree (like a kd-tree)
 CPathCacherThis class is responsible for caching the path to each node of the tree
 CDiagonalGaussianDistributionA single multivariate Gaussian distribution with diagonal covariance
 CDiscreteDistributionA discrete distribution where the only observations are discrete observations
 CGammaDistributionThis class represents the Gamma distribution
 CGaussianDistributionA single multivariate Gaussian distribution
 CLaplaceDistributionThe multivariate Laplace distribution centered at 0 has pdf
 CRegressionDistributionA class that represents a univariate conditionally Gaussian distribution
 CDTBRules< MetricType, TreeType >
 CDTBStatA statistic for use with mlpack trees, which stores the upper bound on distance to nearest neighbors and the component which this node belongs to
 CDualTreeBoruvka< MetricType, MatType, TreeType >Performs the MST calculation using the Dual-Tree Boruvka algorithm, using any type of tree
 CEdgePairAn edge pair is simply two indices and a distance
 CUnionFindA Union-Find data structure
 CFastMKS< KernelType, MatType, TreeType >An implementation of fast exact max-kernel search
 CFastMKSModelA utility struct to contain all the possible FastMKS models, for use by the mlpack_fastmks program
 CFastMKSRules< KernelType, TreeType >The FastMKSRules class is a template helper class used by FastMKS class when performing exact max-kernel search
 CFastMKSStatThe statistic used in trees with FastMKS
 CDiagonalConstraintForce a covariance matrix to be diagonal
 CDiagonalGMMA Diagonal Gaussian Mixture Model
 CEigenvalueRatioConstraintGiven a vector of eigenvalue ratios, ensure that the covariance matrix always has those eigenvalue ratios
 CEMFit< InitialClusteringType, CovarianceConstraintPolicy, Distribution >This class contains methods which can fit a GMM to observations using the EM algorithm
 CGMMA Gaussian Mixture Model (GMM)
 CNoConstraintThis class enforces no constraint on the covariance matrix
 CPositiveDefiniteConstraintGiven a covariance matrix, force the matrix to be positive definite
 CHMM< Distribution >A class that represents a Hidden Markov Model with an arbitrary type of emission distribution
 CHMMModelA serializable HMM model that also stores the type
 CCVFunction< CVType, MLAlgorithm, TotalArgs, BoundArgs >This wrapper serves for adapting the interface of the cross-validation classes to the one that can be utilized by the mlpack optimizers
 CDeduceHyperParameterTypes< Args >A type function for deducing types of hyper-parameters from types of arguments in the Optimize method in HyperParameterTuner
 CDeduceHyperParameterTypes< Args >::ResultHolder< HPTypes >
 CDeduceHyperParameterTypes< PreFixedArg< T >, Args... >Defining DeduceHyperParameterTypes for the case when not all argument types have been processed, and the next one is the type of an argument that should be fixed
 CDeduceHyperParameterTypes< PreFixedArg< T >, Args... >::ResultHolder< HPTypes >
 CDeduceHyperParameterTypes< T, Args... >Defining DeduceHyperParameterTypes for the case when not all argument types have been processed, and the next one (T) is a collection type or an arithmetic type
 CDeduceHyperParameterTypes< T, Args... >::IsCollectionType< Type >A type function to check whether Type is a collection type (for that it should define value_type)
 CDeduceHyperParameterTypes< T, Args... >::ResultHolder< HPTypes >
 CDeduceHyperParameterTypes< T, Args... >::ResultHPType< ArgumentType, IsArithmetic >A type function to deduce the result hyper-parameter type for ArgumentType
 CDeduceHyperParameterTypes< T, Args... >::ResultHPType< ArithmeticType, true >
 CDeduceHyperParameterTypes< T, Args... >::ResultHPType< CollectionType, false >
 CFixedArg< T, I >A struct for storing information about a fixed argument
 CHyperParameterTuner< MLAlgorithm, Metric, CV, OptimizerType, MatType, PredictionsType, WeightsType >The class HyperParameterTuner for the given MLAlgorithm utilizes the provided Optimizer to find the values of hyper-parameters that optimize the value of the given Metric
 CIsPreFixedArg< T >A type function for checking whether the given type is PreFixedArg
 CPreFixedArg< T >A struct for marking arguments as ones that should be fixed (it can be useful for the Optimize method of HyperParameterTuner)
 CPreFixedArg< T & >The specialization of the template for references
 CIOParses the command line for parameters and holds user-specified parameters
 CKDE< KernelType, MetricType, MatType, TreeType, DualTreeTraversalType, SingleTreeTraversalType >The KDE class is a template class for performing Kernel Density Estimations
 CKDECleanRules< TreeType >A dual-tree traversal Rules class for cleaning used trees before performing kernel density estimation
 CKDEDefaultParamsKDEDefaultParams contains the default input parameter values for KDE
 CKDEModel
 CKDERules< MetricType, KernelType, TreeType >A dual-tree traversal Rules class for kernel density estimation
 CKDEStatExtra data for each node in the tree for the task of kernel density estimation
 CKernelNormalizerKernelNormalizer holds a set of methods to normalize estimations applying in each case the appropiate kernel normalizer function
 CCauchyKernelThe Cauchy kernel
 CCosineDistanceThe cosine distance (or cosine similarity)
 CEpanechnikovKernelThe Epanechnikov kernel, defined as
 CExampleKernelAn example kernel function
 CGaussianKernelThe standard Gaussian kernel
 CHyperbolicTangentKernelHyperbolic tangent kernel
 CKernelTraits< KernelType >This is a template class that can provide information about various kernels
 CKernelTraits< CauchyKernel >Kernel traits for the Cauchy kernel
 CKernelTraits< CosineDistance >Kernel traits for the cosine distance
 CKernelTraits< EpanechnikovKernel >Kernel traits for the Epanechnikov kernel
 CKernelTraits< GaussianKernel >Kernel traits for the Gaussian kernel
 CKernelTraits< LaplacianKernel >Kernel traits of the Laplacian kernel
 CKernelTraits< SphericalKernel >Kernel traits for the spherical kernel
 CKernelTraits< TriangularKernel >Kernel traits for the triangular kernel
 CKMeansSelection< ClusteringType, maxIterations >Implementation of the kmeans sampling scheme
 CLaplacianKernelThe standard Laplacian kernel
 CLinearKernelThe simple linear kernel (dot product)
 CNystroemMethod< KernelType, PointSelectionPolicy >
 COrderedSelection
 CPolynomialKernelThe simple polynomial kernel
 CPSpectrumStringKernelThe p-spectrum string kernel
 CRandomSelection
 CSphericalKernelThe spherical kernel, which is 1 when the distance between the two argument points is less than or equal to the bandwidth, or 0 otherwise
 CTriangularKernelThe trivially simple triangular kernel, defined by
 CAllowEmptyClustersPolicy which allows K-Means to create empty clusters without any error being reported
 CDualTreeKMeans< 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
 CDualTreeKMeansRules< MetricType, TreeType >
 CElkanKMeans< MetricType, MatType >
 CHamerlyKMeans< MetricType, MatType >
 CKillEmptyClustersPolicy which allows K-Means to "kill" empty clusters without any error being reported
 CKMeans< MetricType, InitialPartitionPolicy, EmptyClusterPolicy, LloydStepType, MatType >This class implements K-Means clustering, using a variety of possible implementations of Lloyd's algorithm
 CMaxVarianceNewClusterWhen an empty cluster is detected, this class takes the point furthest from the centroid of the cluster with maximum variance as a new cluster
 CNaiveKMeans< MetricType, MatType >This is an implementation of a single iteration of Lloyd's algorithm for k-means
 CPellegMooreKMeans< MetricType, MatType >An implementation of Pelleg-Moore's 'blacklist' algorithm for k-means clustering
 CPellegMooreKMeansRules< MetricType, TreeType >The rules class for the single-tree Pelleg-Moore kd-tree traversal for k-means clustering
 CPellegMooreKMeansStatisticA 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)
 CRandomPartitionA very simple partitioner which partitions the data randomly into the number of desired clusters
 CRefinedStartA refined approach for choosing initial points for k-means clustering
 CSampleInitialization
 CKernelPCA< KernelType, KernelRule >This class performs kernel principal components analysis (Kernel PCA), for a given kernel
 CNaiveKernelRule< KernelType >
 CNystroemKernelRule< KernelType, PointSelectionPolicy >
 CLocalCoordinateCodingAn 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
 CConstraints< MetricType >Interface for generating distance based constraints on a given dataset, provided corresponding true labels and a quantity parameter (k) are specified
 CLMNN< MetricType, OptimizerType >An implementation of Large Margin nearest neighbor metric learning technique
 CLMNNFunction< MetricType >The Large Margin Nearest Neighbors function
 CLogProvides a convenient way to give formatted output
 CColumnsToBlocksTransform the columns of the given matrix into a block format
 CRangeType< T >Simple real-valued range
 CMatrixCompletionThis class implements the popular nuclear norm minimization heuristic for matrix completion problems
 CMeanShift< UseKernel, KernelType, MatType >This class implements mean shift clustering
 CBLEU< ElemType, PrecisionType >BLEU, or the Bilingual Evaluation Understudy, is an algorithm for evaluating the quality of text which has been machine translated from one natural language to another
 CIoU< UseCoordinates >Definition of Intersection over Union metric
 CIPMetric< 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:
 CLMetric< TPower, TTakeRoot >The L_p metric for arbitrary integer p, with an option to take the root
 CMahalanobisDistance< TakeRoot >The Mahalanobis distance, which is essentially a stretched Euclidean distance
 CNMS< UseCoordinates >Definition of Non Maximal Supression
 CMVUMeant to provide a good abstraction for users
 CNaiveBayesClassifier< ModelMatType >The simple Naive Bayes classifier
 CNCA< MetricType, OptimizerType >An implementation of Neighborhood Components Analysis, both a linear dimensionality reduction technique and a distance learning technique
 CSoftmaxErrorFunction< MetricType >The "softmax" stochastic neighbor assignment probability function
 CDrusillaSelect< MatType >
 CFurthestNSThis class implements the necessary methods for the SortPolicy template parameter of the NeighborSearch class
 CLSHSearch< SortPolicy, MatType >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
 CNearestNSThis class implements the necessary methods for the SortPolicy template parameter of the NeighborSearch class
 CNeighborSearch< SortPolicy, MetricType, MatType, TreeType, DualTreeTraversalType, SingleTreeTraversalType >The NeighborSearch class is a template class for performing distance-based neighbor searches
 CNeighborSearchRules< SortPolicy, MetricType, TreeType >The NeighborSearchRules class is a template helper class used by NeighborSearch class when performing distance-based neighbor searches
 CNeighborSearchRules< SortPolicy, MetricType, TreeType >::CandidateCmpCompare two candidates based on the distance
 CNeighborSearchStat< SortPolicy >Extra data for each node in the tree
 CNSModel< 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
 CQDAFN< MatType >
 CRAModel< 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
 CRAQueryStat< SortPolicy >Extra data for each node in the tree
 CRASearch< SortPolicy, MetricType, MatType, TreeType >The RASearch class: This class provides a generic manner to perform rank-approximate search via random-sampling
 CRASearchRules< SortPolicy, MetricType, TreeType >The RASearchRules class is a template helper class used by RASearch class when performing rank-approximate search via random-sampling
 CRAUtil
 CSparseAutoencoderA 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
 CSparseAutoencoderFunctionThis is a class for the sparse autoencoder objective function
 CExactSVDPolicyImplementation of the exact SVD policy
 CPCA< DecompositionPolicy >This class implements principal components analysis (PCA)
 CQUICSVDPolicyImplementation of the QUIC-SVD policy
 CRandomizedBlockKrylovSVDPolicyImplementation of the randomized block krylov SVD policy
 CRandomizedSVDPolicyImplementation of the randomized SVD policy
 CPerceptron< LearnPolicy, WeightInitializationPolicy, MatType >This class implements a simple perceptron (i.e., a single layer neural network)
 CRandomInitializationThis class is used to initialize weights for the weightVectors matrix in a random manner
 CSimpleWeightUpdate
 CZeroInitializationThis class is used to initialize the matrix weightVectors to zero
 CRadicalAn implementation of RADICAL, an algorithm for independent component analysis (ICA)
 CRangeSearch< MetricType, MatType, TreeType >The RangeSearch class is a template class for performing range searches
 CRangeSearchRules< MetricType, TreeType >The RangeSearchRules class is a template helper class used by RangeSearch class when performing range searches
 CRangeSearchStatStatistic class for RangeSearch, to be set to the StatisticType of the tree type that range search is being performed with
 CRSModel
 CBayesianLinearRegressionA Bayesian approach to the maximum likelihood estimation of the parameters $ \omega $ of the linear regression model
 CLARSAn implementation of LARS, a stage-wise homotopy-based algorithm for l1-regularized linear regression (LASSO) and l1+l2 regularized linear regression (Elastic Net)
 CLinearRegressionA simple linear regression algorithm using ordinary least squares
 CLogisticRegression< MatType >The LogisticRegression class implements an L2-regularized logistic regression model, and supports training with multiple optimizers and classification
 CLogisticRegressionFunction< MatType >The log-likelihood function for the logistic regression objective function
 CSoftmaxRegressionSoftmax Regression is a classifier which can be used for classification when the data available can take two or more class values
 CSoftmaxRegressionFunction
 CAcrobotImplementation of Acrobot game
 CAcrobot::Action
 CAcrobot::State
 CAggregatedPolicy< PolicyType >
 CAsyncLearning< WorkerType, EnvironmentType, NetworkType, UpdaterType, PolicyType >Wrapper of various asynchronous learning algorithms, e.g
 CCartPoleImplementation of Cart Pole task
 CCartPole::ActionImplementation of action of Cart Pole
 CCartPole::StateImplementation of the state of Cart Pole
 CCategoricalDQN< OutputLayerType, InitType, NetworkType >Implementation of the Categorical Deep Q-Learning network
 CContinuousActionEnvTo use the dummy environment, one may start by specifying the state and action dimensions
 CContinuousActionEnv::ActionImplementation of continuous action
 CContinuousActionEnv::StateImplementation of state of the dummy environment
 CContinuousDoublePoleCartImplementation of Continuous Double Pole Cart Balancing task
 CContinuousDoublePoleCart::ActionImplementation of action of Continuous Double Pole Cart
 CContinuousDoublePoleCart::StateImplementation of the state of Continuous Double Pole Cart
 CContinuousMountainCarImplementation of Continuous Mountain Car task
 CContinuousMountainCar::ActionImplementation of action of Continuous Mountain Car
 CContinuousMountainCar::StateImplementation of state of Continuous Mountain Car
 CDiscreteActionEnvTo use the dummy environment, one may start by specifying the state and action dimensions
 CDiscreteActionEnv::ActionImplementation of discrete action
 CDiscreteActionEnv::StateImplementation of state of the dummy environment
 CDoublePoleCartImplementation of Double Pole Cart Balancing task
 CDoublePoleCart::ActionImplementation of action of Double Pole Cart
 CDoublePoleCart::StateImplementation of the state of Double Pole Cart
 CDuelingDQN< OutputLayerType, InitType, CompleteNetworkType, FeatureNetworkType, AdvantageNetworkType, ValueNetworkType >Implementation of the Dueling Deep Q-Learning network
 CGreedyPolicy< EnvironmentType >Implementation for epsilon greedy policy
 CMountainCarImplementation of Mountain Car task
 CMountainCar::ActionImplementation of action of Mountain Car
 CMountainCar::StateImplementation of state of Mountain Car
 CNStepQLearningWorker< EnvironmentType, NetworkType, UpdaterType, PolicyType >Forward declaration of NStepQLearningWorker
 COneStepQLearningWorker< EnvironmentType, NetworkType, UpdaterType, PolicyType >Forward declaration of OneStepQLearningWorker
 COneStepSarsaWorker< EnvironmentType, NetworkType, UpdaterType, PolicyType >Forward declaration of OneStepSarsaWorker
 CPendulumImplementation of Pendulum task
 CPendulum::ActionImplementation of action of Pendulum
 CPendulum::StateImplementation of state of Pendulum
 CPrioritizedReplay< EnvironmentType >Implementation of prioritized experience replay
 CPrioritizedReplay< EnvironmentType >::Transition
 CQLearning< EnvironmentType, NetworkType, UpdaterType, PolicyType, ReplayType >Implementation of various Q-Learning algorithms, such as DQN, double DQN
 CRandomReplay< EnvironmentType >Implementation of random experience replay
 CRandomReplay< EnvironmentType >::Transition
 CRewardClipping< EnvironmentType >Interface for clipping the reward to some value between the specified maximum and minimum value (Clipping here is implemented as $ g_{\text{clipped}} = \max(g_{\text{min}}, \min(g_{\text{min}}, g))) $.)
 CSAC< EnvironmentType, QNetworkType, PolicyNetworkType, UpdaterType, ReplayType >Implementation of Soft Actor-Critic, a model-free off-policy actor-critic based deep reinforcement learning algorithm
 CSimpleDQN< OutputLayerType, InitType, NetworkType >
 CSumTree< T >Implementation of SumTree
 CTrainingConfig
 CMethodFormDetector< Class, MethodForm, AdditionalArgsCount >
 CMethodFormDetector< Class, MethodForm, 0 >
 CMethodFormDetector< Class, MethodForm, 1 >
 CMethodFormDetector< Class, MethodForm, 2 >
 CMethodFormDetector< Class, MethodForm, 3 >
 CMethodFormDetector< Class, MethodForm, 4 >
 CMethodFormDetector< Class, MethodForm, 5 >
 CMethodFormDetector< Class, MethodForm, 6 >
 CMethodFormDetector< Class, MethodForm, 7 >
 CDataDependentRandomInitializerA data-dependent random dictionary initializer for SparseCoding
 CNothingInitializerA 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()
 CRandomInitializerA DictionaryInitializer for use with the SparseCoding class
 CSparseCodingAn 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)
 CBiasSVD< OptimizerType >Bias SVD is an improvement on Regularized SVD which is a matrix factorization techniques
 CBiasSVDFunction< MatType >This class contains methods which are used to calculate the cost of BiasSVD's objective function, to calculate gradient of parameters with respect to the objective function, etc
 CQUIC_SVDQUIC-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)
 CRandomizedBlockKrylovSVDRandomized block krylov SVD is a matrix factorization that is based on randomized matrix approximation techniques, developed in in "Randomized Block Krylov Methods for Stronger and Faster Approximate Singular Value Decomposition"
 CRandomizedSVDRandomized 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"
 CRegularizedSVD< 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
 CRegularizedSVDFunction< MatType >The data is stored in a matrix of type MatType, so that this class can be used with both dense and sparse matrix types
 CSVDPlusPlus< OptimizerType >SVD++ is a matrix decomposition tenique used in collaborative filtering
 CSVDPlusPlusFunction< MatType >This class contains methods which are used to calculate the cost of SVD++'s objective function, to calculate gradient of parameters with respect to the objective function, etc
 CLinearSVM< MatType >The LinearSVM class implements an L2-regularized support vector machine model, and supports training with multiple optimizers and classification
 CLinearSVMFunction< MatType >The hinge loss function for the linear SVM objective function
 CTimerThe timer class provides a way for mlpack methods to be timed
 CTimers
 CAllCategoricalSplit< FitnessFunction >The AllCategoricalSplit is a splitting function that will split categorical features into many children: one child for each category
 CAllCategoricalSplit< FitnessFunction >::AuxiliarySplitInfo< ElemType >
 CAllDimensionSelectThis dimension selection policy allows any dimension to be selected for splitting
 CAxisParallelProjVectorAxisParallelProjVector defines an axis-parallel projection vector
 CBestBinaryNumericSplit< FitnessFunction >The BestBinaryNumericSplit is a splitting function for decision trees that will exhaustively search a numeric dimension for the best binary split
 CBestBinaryNumericSplit< FitnessFunction >::AuxiliarySplitInfo< ElemType >
 CBinaryNumericSplit< FitnessFunction, ObservationType >The BinaryNumericSplit class implements the numeric feature splitting strategy devised by Gama, Rocha, and Medas in the following paper:
 CBinaryNumericSplitInfo< ObservationType >
 CBinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType >A binary space partitioning tree, such as a KD-tree or a ball tree
 CBinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType >::BreadthFirstDualTreeTraverser< RuleType >
 CBinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType >::DualTreeTraverser< RuleType >A dual-tree traverser for binary space trees; see dual_tree_traverser.hpp
 CBinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType >::SingleTreeTraverser< RuleType >A single-tree traverser for binary space trees; see single_tree_traverser.hpp for implementation
 CCategoricalSplitInfo
 CCompareCosineNode
 CCosineTree
 CCoverTree< MetricType, StatisticType, MatType, RootPointPolicy >A cover tree is a tree specifically designed to speed up nearest-neighbor computation in high-dimensional spaces
 CCoverTree< MetricType, StatisticType, MatType, RootPointPolicy >::DualTreeTraverser< RuleType >A dual-tree cover tree traverser; see dual_tree_traverser.hpp
 CCoverTree< MetricType, StatisticType, MatType, RootPointPolicy >::SingleTreeTraverser< RuleType >A single-tree cover tree traverser; see single_tree_traverser.hpp for implementation
 CDiscreteHilbertValue< TreeElemType >The DiscreteHilbertValue class stores Hilbert values for all of the points in a RectangleTree node, and calculates Hilbert values for new points
 CEmptyStatisticEmpty statistic if you are not interested in storing statistics in your tree
 CExampleTree< 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
 CFirstPointIsRootThis class is meant to be used as a choice for the policy class RootPointPolicy of the CoverTree class
 CGiniGainThe Gini gain, a measure of set purity usable as a fitness function (FitnessFunction) for decision trees
 CGiniImpurity
 CGreedySingleTreeTraverser< TreeType, RuleType >
 CHilbertRTreeAuxiliaryInformation< TreeType, HilbertValueType >
 CHilbertRTreeDescentHeuristicThis class chooses the best child of a node in a Hilbert R tree when inserting a new point
 CHilbertRTreeSplit< splitOrder >The splitting procedure for the Hilbert R tree
 CHoeffdingCategoricalSplit< FitnessFunction >This is the standard Hoeffding-bound categorical feature proposed in the paper below:
 CHoeffdingInformationGain
 CHoeffdingNumericSplit< FitnessFunction, ObservationType >The HoeffdingNumericSplit class implements the numeric feature splitting strategy alluded to by Domingos and Hulten in the following paper:
 CHoeffdingTree< FitnessFunction, NumericSplitType, CategoricalSplitType >The HoeffdingTree object represents all of the necessary information for a Hoeffding-bound-based decision tree
 CHoeffdingTreeModelThis class is a serializable Hoeffding tree model that can hold four different types of Hoeffding trees
 CHyperplaneBase< BoundT, ProjVectorT >HyperplaneBase defines a splitting hyperplane based on a projection vector and projection value
 CInformationGainThe standard information gain criterion, used for calculating gain in decision trees
 CIsSpillTree< TreeType >
 CIsSpillTree< tree::SpillTree< MetricType, StatisticType, MatType, HyperplaneType, SplitType > >
 CMeanSpaceSplit< MetricType, MatType >
 CMeanSplit< BoundType, MatType >A binary space partitioning tree node is split into its left and right child
 CMeanSplit< BoundType, MatType >::SplitInfoAn information about the partition
 CMidpointSpaceSplit< MetricType, MatType >
 CMidpointSplit< BoundType, MatType >A binary space partitioning tree node is split into its left and right child
 CMidpointSplit< BoundType, MatType >::SplitInfoA struct that contains an information about the split
 CMinimalCoverageSweep< SplitPolicy >The MinimalCoverageSweep class finds a partition along which we can split a node according to the coverage of two resulting nodes
 CMinimalCoverageSweep< SplitPolicy >::SweepCost< TreeType >A struct that provides the type of the sweep cost
 CMinimalSplitsNumberSweep< SplitPolicy >The MinimalSplitsNumberSweep class finds a partition along which we can split a node according to the number of required splits of the node
 CMinimalSplitsNumberSweep< SplitPolicy >::SweepCost< typename >A struct that provides the type of the sweep cost
 CMultipleRandomDimensionSelectThis dimension selection policy allows the selection from a few random dimensions
 CNoAuxiliaryInformation< TreeType >
 CNumericSplitInfo< ObservationType >
 COctree< MetricType, StatisticType, MatType >
 COctree< MetricType, StatisticType, MatType >::DualTreeTraverser< MetricType, StatisticType, MatType >A dual-tree traverser; see dual_tree_traverser.hpp
 COctree< MetricType, StatisticType, MatType >::SingleTreeTraverser< RuleType >A single-tree traverser; see single_tree_traverser.hpp
 COctree< MetricType, StatisticType, MatType >::SplitType::SplitInfo
 CProjVectorProjVector defines a general projection vector (not necessarily axis-parallel)
 CQueueFrame< TreeType, TraversalInfoType >
 CRandomDimensionSelectThis dimension selection policy only selects one single random dimension
 CRandomForest< FitnessFunction, DimensionSelectionType, NumericSplitType, CategoricalSplitType, ElemType >
 CRectangleTree< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType >A rectangle type tree tree, such as an R-tree or X-tree
 CRectangleTree< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType >::DualTreeTraverser< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType >A dual tree traverser for rectangle type trees
 CRectangleTree< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType >::SingleTreeTraverser< RuleType >A single traverser for rectangle type trees
 CRPlusPlusTreeAuxiliaryInformation< TreeType >
 CRPlusPlusTreeDescentHeuristic
 CRPlusPlusTreeSplitPolicyThe RPlusPlusTreeSplitPolicy helps to determine the subtree into which we should insert a child of an intermediate node that is being split
 CRPlusTreeDescentHeuristic
 CRPlusTreeSplit< SplitPolicyType, SweepType >The RPlusTreeSplit class performs the split process of a node on overflow
 CRPlusTreeSplitPolicyThe RPlusPlusTreeSplitPolicy helps to determine the subtree into which we should insert a child of an intermediate node that is being split
 CRPTreeMaxSplit< BoundType, MatType >This class splits a node by a random hyperplane
 CRPTreeMaxSplit< BoundType, MatType >::SplitInfoAn information about the partition
 CRPTreeMeanSplit< BoundType, MatType >This class splits a binary space tree
 CRPTreeMeanSplit< BoundType, MatType >::SplitInfoAn information about the partition
 CRStarTreeDescentHeuristicWhen 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
 CRStarTreeSplitA Rectangle Tree has new points inserted at the bottom
 CRTreeDescentHeuristicWhen 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
 CRTreeSplitA Rectangle Tree has new points inserted at the bottom
 CSpaceSplit< MetricType, MatType >
 CSpillTree< 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
 CSpillTree< 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
 CSpillTree< 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
 CTraversalInfo< TreeType >The TraversalInfo class holds traversal information which is used in dual-tree (and single-tree) traversals
 CTreeTraits< TreeType >The TreeTraits class provides compile-time information on the characteristics of a given tree type
 CTreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, bound::BallBound, SplitType > >This is a specialization of the TreeType class to the BallTree tree type
 CTreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, bound::CellBound, SplitType > >This is a specialization of the TreeType class to the UBTree tree type
 CTreeTraits< 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)
 CTreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, BoundType, RPTreeMaxSplit > >This is a specialization of the TreeType class to the max-split random projection tree
 CTreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, BoundType, RPTreeMeanSplit > >This is a specialization of the TreeType class to the mean-split random projection tree
 CTreeTraits< BinarySpaceTree< MetricType, StatisticType, MatType, BoundType, SplitType > >This is a specialization of the TreeTraits class to the BinarySpaceTree tree type
 CTreeTraits< CoverTree< MetricType, StatisticType, MatType, RootPointPolicy > >The specialization of the TreeTraits class for the CoverTree tree type
 CTreeTraits< Octree< MetricType, StatisticType, MatType > >This is a specialization of the TreeTraits class to the Octree tree type
 CTreeTraits< 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
 CTreeTraits< RectangleTree< MetricType, StatisticType, MatType, SplitType, DescentType, AuxiliaryInformationType > >This is a specialization of the TreeType class to the RectangleTree tree type
 CTreeTraits< SpillTree< MetricType, StatisticType, MatType, HyperplaneType, SplitType > >This is a specialization of the TreeType class to the SpillTree tree type
 CUBTreeSplit< BoundType, MatType >Split a node into two parts according to the median address of points contained in the node
 CVantagePointSplit< BoundType, MatType, MaxNumSamples >The class splits a binary space partitioning tree node according to the median distance to the vantage point
 CVantagePointSplit< BoundType, MatType, MaxNumSamples >::SplitInfoA struct that contains an information about the split
 CXTreeAuxiliaryInformation< TreeType >The XTreeAuxiliaryInformation class provides information specific to X trees for each node in a RectangleTree
 CXTreeAuxiliaryInformation< TreeType >::SplitHistoryStructThe X tree requires that the tree records it's "split history"
 CXTreeSplitA Rectangle Tree has new points inserted at the bottom
 CBindingDetailsThis structure holds all of the information about bindings documentation
 CExample
 CIsStdVector< T >Metaprogramming structure for vector detection
 CIsStdVector< std::vector< T, A > >Metaprogramming structure for vector detection
 CLongDescription
 CNullOutStreamUsed for Log::Debug when not compiled with debugging symbols
 CParamDataThis structure holds all of the information about a single parameter, including its value (which is set when ParseCommandLine() is called)
 CPrefixedOutStreamAllows 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
 CProgramName
 CSeeAlso
 CShortDescription
 CNeighborSearch< neighbor::NearestNeighborSort, metric::LMetric< TPower, true > >
 CNeighborSearchStat< neighbor::NearestNeighborSort >
 CSequential<>
 Ctrue_type
 CTrainFormBase4< PT, void, const MT &, const PT & >
 CTrainFormBase5< PT, void, const MT &, const data::DatasetInfo &, const PT & >
 CTrainFormBase5< PT, void, const MT &, const PT &, const size_t >
 CTrainFormBase5< PT, WT, const MT &, const PT &, const WT & >
 CTrainFormBase6< PT, void, const MT &, const data::DatasetInfo &, const PT &, const size_t >
 CTrainFormBase6< PT, WT, const MT &, const data::DatasetInfo &, const PT &, const WT & >
 CTrainFormBase6< PT, WT, const MT &, const PT &, const size_t, const WT & >
 CTrainFormBase7< PT, WT, const MT &, const data::DatasetInfo &, const PT &, const size_t, const WT & >
 CTrainHMMModel