SHOGUN
4.1.0

►NEigen  
CLDLT  
CMap  
CMatrix  
CStride  
►Nshogun  All of classes and functions are contained in the shogun namespace 
►Nlinalg  
►Nimplementation  
►Nspecial_purpose  
Ccross_entropy  
Ccross_entropy< Backend::EIGEN3, Matrix >  
Clogistic  
Clogistic< Backend::EIGEN3, Matrix >  
Cmultiply_by_logistic_derivative  
Cmultiply_by_logistic_derivative< Backend::EIGEN3, Matrix >  
Cmultiply_by_rectified_linear_derivative  
Cmultiply_by_rectified_linear_derivative< Backend::EIGEN3, Matrix >  
Crectified_linear  
Crectified_linear< Backend::EIGEN3, Matrix >  
Csoftmax  
Csoftmax< Backend::EIGEN3, Matrix >  
Csquared_error  
Csquared_error< Backend::EIGEN3, Matrix >  
Cadd  Generic class which is specialized for different backends to perform addition 
Cadd< Backend::EIGEN3, Matrix >  Partial specialization of add for the Eigen3 backend 
Cadd< Backend::NATIVE, Matrix >  Partial specialization of add for the Native backend 
Capply  Generic class which is specialized for different backends to perform apply 
Capply< Backend::EIGEN3, Matrix, Vector >  Partial specialization of apply for the Eigen3 backend 
Ccolwise_sum  Generic class colwise_sum which provides a static compute method. This class is specialized for different types of matrices and backend, providing a means to deal with various matrices directly without having to convert 
Ccolwise_sum< Backend::EIGEN3, Matrix >  Specialization of generic colwise_sum which works with SGMatrix and uses Eigen3 as backend for computing sum 
Cconvolve  
Cconvolve< Backend::EIGEN3, Matrix >  
Cdot  Generic class dot which provides a static compute method. This class is specialized for different types of vectors and backend, providing a mean to deal with various vectors directly without having to convert 
Cdot< Backend::EIGEN3, Vector >  Specialization of generic dot for the Eigen3 backend 
Cdot< Backend::NATIVE, Vector >  Specialization of generic dot for the Native backend 
Celementwise_product  
Celementwise_product< Backend::EIGEN3, Matrix >  
Celementwise_square  Generic class square which provides a static compute method. This class is specialized for different types of matrices and backend, providing a mean to deal with various matrices directly without having to convert 
Celementwise_square< Backend::EIGEN3, Matrix >  Partial specialization of generic elementwise_square for the Eigen3 backend 
Celementwise_unary_operation  Template struct elementwise_unary_operation. This struct is specialized for computing elementwise operations for both matrices and vectors of CPU (SGMatrix/SGVector) or GPU (CGPUMatrix/CGPUVector) 
Celementwise_unary_operation< Backend::EIGEN3, Operand, ReturnType, UnaryOp >  Specialization for elementwise_unary_operation with EIGEN3 backend. The operand types MUST be of CPU types (SGMatrix/SGVector) 
Celementwise_unary_operation< Backend::NATIVE, Operand, ReturnType, UnaryOp >  Specialization for elementwise_unary_operation with NATIVE backend. The operand types MUST be of CPU types (SGMatrix/SGVector) 
Cmatrix_product  
Cmatrix_product< Backend::EIGEN3, Matrix >  
Cmax  Generic class which is specialized for different backends to perform the max operation 
Cmax< Backend::EIGEN3, Matrix >  Specialization of max for the Eigen3 backend 
Cmax< Backend::NATIVE, Matrix >  Specialization of add for the Native backend 
Crowwise_sum  Generic class rowwise_sum which provides a static compute method. This class is specialized for different types of matrices and backend, providing a means to deal with various matrices directly without having to convert 
Crowwise_sum< Backend::EIGEN3, Matrix >  Specialization of generic rowwise_sum which works with SGMatrix and uses Eigen3 as backend for computing sum 
Cscale  
Cscale< Backend::EIGEN3, Matrix >  
Cscale< Backend::NATIVE, Matrix >  
Cset_rows_const  
Cset_rows_const< Backend::EIGEN3, Matrix, Vector >  
Csum  Generic class sum which provides a static compute method. This class is specialized for different types of matrices and backend, providing a means to deal with various matrices directly without having to convert 
Csum< Backend::EIGEN3, Matrix >  Specialization of generic sum which works with SGMatrix and uses Eigen3 as backend for computing sum 
Csum_symmetric  Generic class sum symmetric which provides a static compute method. This class is specialized for different types of matrices and backend, providing a means to deal with various matrices directly without having to convert 
Csum_symmetric< Backend::EIGEN3, Matrix >  Specialization of generic sum symmetric which works with SGMatrix and uses Eigen3 as backend for computing sum 
Cvector_sum  Generic class vector_sum which provides a static compute method. This class is specialized for different types of vectors and backend, providing a mean to deal with various vectors directly without having to convert 
Cvector_sum< Backend::EIGEN3, Vector >  Specialization of generic vector_sum for the Eigen3 backend 
Cvector_sum< Backend::NATIVE, Vector >  Specialization of generic vector_sum for the Native backend 
►Nocl  
CParameter  Struct Parameter for wrapping up parameters to custom OpenCL operation strings. Supports string type, Cstyle string type and all basic types of parameters 
►Noperations  
Cocl_operation  Class ocl_operation for elementwise unary OpenCL operations for GPUtypes (CGPUMatrix/CGPUVector) 
Csin  
Csin< complex128_t >  
►Nutil  
Callocate_result  Template struct allocate_result for allocating objects of return type for elementwise operations. This generic version takes care of the vector types supported by Shogun (SGVector and CGPUVector) 
Callocate_result< SGMatrix< T >, SGMatrix< ST > >  Specialization for allocate_result when return type is SGMatrix. Works with different scalar types as well. T defines the scalar type for the operand and whereas ST is the scalar type for the result of the elementwise operation 
CBlock  Generic class Block which wraps a matrix class and contains block specific information, providing a uniform way to deal with matrix blocks for all supported backend matrices 
C_IterInfo  Struct that contains current state of the iteration for iterative linear solvers 
CAdaDeltaUpdater  The class implements the AdaDelta method 
CAdaGradUpdater  The class implements the adaptive gradient updater 
CAdaptMomentumCorrection  This implements the adaptive momentum correction method 
Cbmrm_ll  
CBmrmStatistics  
CC45TreeNodeData  Structure to store data of a node of C4.5 tree. This can be used as a template type in TreeMachineNode class. Ex: C4.5 algorithm uses nodes of type CTreeMachineNode<C45TreeNodeData> 
CCAbsoluteDeviationLoss  CAbsoluteDeviationLoss implements the absolute deviation loss function. \(L(y_i,f(x_i)) = \mod{y_if(x_i)}\) 
CCAccuracyMeasure  Class AccuracyMeasure used to measure accuracy of 2class classifier 
CCAlphabet  The class Alphabet implements an alphabet and alphabet utility functions 
CCANOVAKernel  ANOVA (ANalysis Of VAriances) kernel 
CCApproxJointDiagonalizer  Class ApproxJointDiagonalizer defines an Approximate Joint Diagonalizer (AJD) interface 
CCARTreeNodeData  Structure to store data of a node of CART. This can be used as a template type in TreeMachineNode class. CART algorithm uses nodes of type CTreeMachineNode<CARTreeNodeData> 
CCAttenuatedEuclideanDistance  Class AttenuatedEuclideanDistance 
CCAttributeFeatures  Implements attributed features, that is in the simplest case a number of (attribute, value) pairs 
CCAUCKernel  The AUC kernel can be used to maximize the area under the receiver operator characteristic curve (AUC) instead of margin in SVM training 
CCAutoencoder  Represents a single layer neural autoencoder 
CCAveragedPerceptron  Class Averaged Perceptron implements the standard linear (online) algorithm. Averaged perceptron is the simple extension of Perceptron 
CCAvgDiagKernelNormalizer  Normalize the kernel by either a constant or the average value of the diagonal elements (depending on argument c of the constructor) 
CCBaggingMachine  : Bagging algorithm i.e. bootstrap aggregating 
CCBAHSIC  Class CBAHSIC, that extends CKernelDependenceMaximization and uses HSIC [1] to compute dependence measures for feature selection using a backward elimination approach as described in [1]. This class serves as a convenience class that initializes the CDependenceMaximization::m_estimator with an instance of CHSIC and allows only shogun::BACKWARD_ELIMINATION algorithm to use which is set internally. Therefore, trying to use other algorithms by set_algorithm() will not work. Plese see the class documentation of CHSIC and [2] for more details on mathematical description of HSIC 
CCBalancedConditionalProbabilityTree  
CCBallTree  This class implements Ball tree. The ball tree is contructed using the topdown approach. cf. ftp://ftp.icsi.berkeley.edu/pub/techreports/1989/tr89063.pdf 
CCBALMeasure  Class BALMeasure used to measure balanced error of 2class classifier 
CCBaseMulticlassMachine  
CCBesselKernel  Class Bessel kernel 
CCBinaryClassEvaluation  The class TwoClassEvaluation, a base class used to evaluate binary classification labels 
CCBinaryFile  A Binary file access class 
CCBinaryLabels  Binary Labels for binary classification 
CCBinaryStream  Memory mapped emulation via binary streams (files) 
CCBinaryTreeMachineNode  The node of the tree structure forming a TreeMachine The node contains pointer to its parent and pointers to its 2 children: left child and right child. The node also contains data which can be of any type and has to be specified using template specifier 
CCBinnedDotFeatures  The class BinnedDotFeatures contains a 01 conversion of features into bins 
CCBitString  String class embedding a string in a compact bit representation 
CCBrayCurtisDistance  Class BrayCurtis distance 
CCC45ClassifierTree  Class C45ClassifierTree implements the C4.5 algorithm for decision tree learning. The algorithm steps are briefy explained below : 
CCCache  Template class Cache implements a simple cache 
CCCanberraMetric  Class CanberraMetric 
CCCanberraWordDistance  Class CanberraWordDistance 
CCCARTree  This class implements the Classification And Regression Trees algorithm by Breiman et al for decision tree learning. A CART tree is a binary decision tree that is constructed by splitting a node into two child nodes repeatedly, beginning with the root node that contains the whole dataset. TREE GROWING PROCESS : During the tree growing process, we recursively split a node into left child and right child so that the resulting nodes are "purest". We do this until any of the stopping criteria is met. To find the best split, we scan through all possible splits in all predictive attributes. The best split is one that maximises some splitting criterion. For classification tasks, ie. when the dependent attribute is categorical, the Gini index is used. For regression tasks, ie. when the dependent variable is continuous, least squares deviation is used. The algorithm uses two stopping criteria : if node becomes completely "pure", ie. all its members have identical dependent variable, or all of them have identical predictive attributes (independent variables). 
CCCauchyKernel  Cauchy kernel 
CCCCSOSVM  CCSOSVM 
CCCGMShiftedFamilySolver  Class that uses conjugate gradient method for solving a shifted linear system family where the linear opeator is real valued and symmetric positive definite, the vector is real valued, but the shifts are complex 
CCCHAIDTree  This class implements the CHAID algorithm proposed by Kass (1980) for decision tree learning. CHAID consists of three steps: merging, splitting and stopping. A tree is grown by repeatedly using these three steps on each node starting from the root node. CHAID accepts nominal or ordinal categorical predictors only. If predictors are continuous, they have to be transformed into ordinal predictors before tree growing. CONVERTING CONTINUOUS PREDICTORS TO ORDINAL : Continuous predictors are converted to ordinal by binning. The number of bins (K) has to be supplied by the user. Given K, a predictor is split in such a way that all the bins get the same number (more or less) of distinct predictor values. The maximum feature value in each bin is used as a breakpoint. MERGING : During the merging step, allowable pairs of categories of a predictor are evaluated for similarity. If the similarity of a pair is above a threshold, the categories constituting the pair are merged into a single category. The process is repeated until there is no pair left having high similarity between its categories. Similarity between categories is evaluated using the p_value SPLITTING : The splitting step selects which predictor to be used to best split the node. Selection is accomplished by comparing the adjusted p_value associated with each predictor. The predictor that has the smallest adjusted p_value is chosen for splitting the node. STOPPING : The tree growing process stops if any of the following conditions is satisfied : 
CCChebyshewMetric  Class ChebyshewMetric 
CCChi2Kernel  The Chi2 kernel operating on realvalued vectors computes the chisquared distance between sets of histograms 
CCChiSquareDistance  Class ChiSquareDistance 
CCCircularBuffer  Implementation of circular buffer This buffer has logical structure such as queue (FIFO). But this queue is cyclic: tape, ends of which are connected, just instead tape there is block of physical memory. So, if you push big block of data it can be situated both at the end and the begin of buffer's memory 
CCCircularKernel  Circular kernel 
CCClusteringAccuracy  Clustering accuracy 
CCClusteringEvaluation  The base class used to evaluate clustering 
CCClusteringMutualInformation  Clustering (normalized) mutual information 
CCCombinationRule  CombinationRule abstract class The CombinationRule defines an interface to how to combine the classification or regression outputs of an ensemble of Machines 
CCCombinedDotFeatures  Features that allow stacking of a number of DotFeatures 
CCCombinedFeatures  The class CombinedFeatures is used to combine a number of of feature objects into a single CombinedFeatures object 
CCCombinedKernel  The Combined kernel is used to combine a number of kernels into a single CombinedKernel object by linear combination 
CCCommUlongStringKernel  The CommUlongString kernel may be used to compute the spectrum kernel from strings that have been mapped into unsigned 64bit integers 
CCCommWordStringKernel  The CommWordString kernel may be used to compute the spectrum kernel from strings that have been mapped into unsigned 16bit integers 
CCCompressor  Compression library for compressing and decompressing buffers using one of the standard compression algorithms: 
CCConditionalProbabilityTree  
CCConjugateGradientSolver  Class that uses conjugate gradient method of solving a linear system involving a real valued linear operator and vector. Useful for large sparse systems involving sparse symmetric and positivedefinite matrices 
CCConjugateOrthogonalCGSolver  Class that uses conjugate orthogonal conjugate gradient method of solving a linear system involving a complex valued linear operator and vector. Useful for large sparse systems involving sparse symmetric matrices that are not Herimitian 
CCConstKernel  The Constant Kernel returns a constant for all elements 
CCConstMean  The Const mean function class 
CCContingencyTableEvaluation  The class ContingencyTableEvaluation a base class used to evaluate 2class classification with TP, FP, TN, FN rates 
CCConverter  Class Converter used to convert data 
CCConvolutionalFeatureMap  Handles convolution and gradient calculation for a single feature map in a convolutional neural network 
CCCosineDistance  Class CosineDistance 
CCCplex  Class CCplex to encapsulate access to the commercial cplex general purpose optimizer 
CCCPLEXSVM  CplexSVM a SVM solver implementation based on cplex (unfinished) 
CCCrossCorrelationMeasure  Class CrossCorrelationMeasure used to measure cross correlation coefficient of 2class classifier 
CCCrossValidation  Base class for crossvalidation evaluation. Given a learning machine, a splitting strategy, an evaluation criterium, features and correspnding labels, this provides an interface for crossvalidation. Results may be retrieved using the evaluate method. A number of repetitions may be specified for obtaining more accurate results. The arithmetic mean of different runs is returned along with confidence intervals, if a pvalue is specified. Default number of runs is one, confidence interval combutation is disabled 
CCCrossValidationMKLStorage  Class for storing MKL weights in every fold of crossvalidation 
CCCrossValidationMulticlassStorage  Class for storing multiclass evaluation information in every fold of crossvalidation 
CCCrossValidationOutput  Class for managing individual folds in crossvalidation 
CCCrossValidationPrintOutput  Class for outputting crossvalidation intermediate results to the standard output. Simply prints all messages it gets 
CCCrossValidationResult  Type to encapsulate the results of an evaluation run. May contain confidence interval (if conf_int_alpha!=0). m_conf_int_alpha is the probability for an error, i.e. the value does not lie in the confidence interval 
CCCrossValidationSplitting  Implementation of normal crossvalidation on the base of CSplittingStrategy. Produces subset index sets of equal size (at most one difference) 
CCCSVFile  Class CSVFile used to read data from commaseparated values (CSV) files. See http://en.wikipedia.org/wiki/Commaseparated_values 
CCCustomDistance  The Custom Distance allows for custom user provided distance matrices 
CCCustomKernel  The Custom Kernel allows for custom user provided kernel matrices 
CCCustomMahalanobisDistance  Class CustomMahalanobisDistance used to compute the distance between feature vectors \( \vec{x_i} \) and \( \vec{x_j} \) as \( (\vec{x_i}  \vec{x_j})^T \mathbf{M} (\vec{x_i}  \vec{x_j}) \), given the matrix \( \mathbf{M} \) which will be referred to as Mahalanobis matrix 
CCData  Dummy data holder 
CCDataGenerator  Class that is able to generate various data samples, which may be used for examples in SHOGUN 
CCDecompressString  Preprocessor that decompresses compressed strings 
CCDeepAutoencoder  Represents a mutilayer autoencoder 
CCDeepBeliefNetwork  A Deep Belief Network 
CCDelimiterTokenizer  The class CDelimiterTokenizer is used to tokenize a SGVector<char> into tokens using custom chars as delimiters. One can set the delimiters to use by setting to 1 the appropriate index of the public field delimiters. Eg. to set as delimiter the character ':', one should do: tokenizer>delimiters[':'] = 1; 
CCDenseDistance  Template class DenseDistance 
CCDenseExactLogJob  Class that represents the job of applying the log of a CDenseMatrixOperator on a real vector 
CCDenseFeatures  The class DenseFeatures implements dense feature matrices 
CCDenseLabels  Dense integer or floating point labels 
CCDenseMatrixExactLog  Class that generates jobs for computing logarithm of a dense matrix linear operator 
CCDenseMatrixOperator  Class that represents a densematrix linear operator. It computes matrixvector product \(Ax\) in its apply method, \(A\in\mathbb{C}^{m\times n},A:\mathbb{C}^{n}\rightarrow \mathbb{C}^{m}\) being the matrix operator and \(x\in\mathbb{C}^{n}\) being the vector. The result is a vector \(y\in\mathbb{C}^{m}\) 
CCDensePreprocessor  Template class DensePreprocessor, base class for preprocessors (cf. CPreprocessor) that apply to CDenseFeatures (i.e. rectangular dense matrices) 
CCDenseSubSamplesFeatures  
CCDenseSubsetFeatures  
CCDependenceMaximization  Class CDependenceMaximization, base class for all feature selection preprocessors which select a subset of features that shows maximum dependence between the features and the labels. This is done via an implementation of CIndependenceTest, m_estimator inside compute_measures() (see class documentation of CFeatureSelection), which performs a statistical test for a given feature \(\mathbf{X}_i\) from the set of features \(\mathbf{X}\), and the labels \(\mathbf{Y}\). The test checks \[ \textbf{H}_0 : P\left(\mathbf{X}\setminus \mathbf{X}_i, \mathbf{Y}\right) =P\left(\mathbf{X}\setminus \mathbf{X}_i\right)P\left(\mathbf{Y}\right) \] The test statistic is then used as a measure which signifies the independence between the rest of the features and the labels  higher the value of the test statistic, greater the dependency between the rest of the features and the class labels, and therefore lesser significant the current feature becomes. Therefore, highest scoring features are removed. The removal policy thus can only be shogun::N_LARGEST and shogun::PERCENTILE_LARGEST and it can be set via set_policy() call. remove_feats() method handles the removal of features based on the specified policy 
CCDiagKernel  The Diagonal Kernel returns a constant for the diagonal and zero otherwise 
CCDiceKernelNormalizer  DiceKernelNormalizer performs kernel normalization inspired by the Dice coefficient (see http://en.wikipedia.org/wiki/Dice's_coefficient) 
CCDifferentiableFunction  An abstract class that describes a differentiable function used for GradientEvaluation 
CCDiffusionMaps  Class DiffusionMaps used to preprocess given data using Diffusion Maps dimensionality reduction technique as described in 
CCDimensionReductionPreprocessor  Class DimensionReductionPreprocessor, a base class for preprocessors used to lower the dimensionality of given simple features (dense matrices) 
CCDirectEigenSolver  Class that computes eigenvalues of a real valued, selfadjoint dense matrix linear operator using Eigen3 
CCDirectLinearSolverComplex  Class that provides a solve method for complex densematrix linear systems 
CCDirectSparseLinearSolver  Class that provides a solve method for real sparsematrix linear systems using LLT 
CCDiscreteDistribution  This is the base interface class for all discrete distributions 
CCDisjointSet  Class CDisjointSet data structure for linking graph nodes It's easy to identify connected graph, acyclic graph, roots of forest etc. please refer to http://en.wikipedia.org/wiki/Disjointset_data_structure 
CCDistance  Class Distance, a base class for all the distances used in the Shogun toolbox 
CCDistanceKernel  The Distance kernel takes a distance as input 
CCDistanceMachine  A generic DistanceMachine interface 
CCDistantSegmentsKernel  The distant segments kernel is a string kernel, which counts the number of substrings, socalled segments, at a certain distance from each other 
CCDistribution  Base class Distribution from which all methods implementing a distribution are derived 
CCDixonQTestRejectionStrategy  Simplified version of Dixon's Q test outlier based rejection strategy. Statistic values are taken from http://www.vias.org/tmdatanaleng/cc_outlier_tests_dixon.html 
CCDomainAdaptationMulticlassLibLinear  Domain adaptation multiclass LibLinear wrapper Source domain is assumed to b 
CCDomainAdaptationSVM  Class DomainAdaptationSVM 
CCDomainAdaptationSVMLinear  Class DomainAdaptationSVMLinear 
CCDotFeatures  Features that support dot products among other operations 
CCDotKernel  Template class DotKernel is the base class for kernels working on DotFeatures 
CCDualLibQPBMSOSVM  Class DualLibQPBMSOSVM that uses Bundle Methods for Regularized Risk Minimization algorithms for structured output (SO) problems [1] presented in [2] 
CCDualVariationalGaussianLikelihood  Class that models dual variational likelihood 
CCDummyFeatures  The class DummyFeatures implements features that only know the number of feature objects (but don't actually contain any) 
CCDynamicArray  Template Dynamic array class that creates an array that can be used like a list or an array 
CCDynamicObjectArray  Dynamic array class for CSGObject pointers that creates an array that can be used like a list or an array 
CCDynInt  Integer type of dynamic size 
CCDynProg  Dynamic Programming Class 
CCECOCAEDDecoder  
CCECOCDecoder  
CCECOCDiscriminantEncoder  
CCECOCEDDecoder  
CCECOCEncoder  ECOCEncoder produce an ECOC codebook 
CCECOCForestEncoder  
CCECOCHDDecoder  
CCECOCIHDDecoder  
CCECOCLLBDecoder  
CCECOCOVOEncoder  
CCECOCOVREncoder  
CCECOCRandomDenseEncoder  
CCECOCRandomSparseEncoder  
CCECOCSimpleDecoder  
CCECOCStrategy  
CCECOCUtil  
CCEigenSolver  Abstract base class that provides an abstract compute method for computing eigenvalues of a real valued, selfadjoint linear operator. It also provides method for getting min and max eigenvalues 
CCEMBase  This is the base class for Expectation Maximization (EM). EM for various purposes can be derived from this base class. This is a template class having a template member called data which can be used to store all parameters used and results calculated by the expectation and maximization steps of EM 
CCEmbeddingConverter  Class EmbeddingConverter (part of the Efficient Dimensionality Reduction Toolkit) used to construct embeddings of features, e.g. construct dense numeric embedding of string features 
CCEMMixtureModel  This is the implementation of EM specialized for Mixture models 
CCEPInferenceMethod  Class of the Expectation Propagation (EP) posterior approximation inference method 
CCErrorRateMeasure  Class ErrorRateMeasure used to measure error rate of 2class classifier 
CCEuclideanDistance  Class EuclideanDistance 
CCEvaluation  Class Evaluation, a base class for other classes used to evaluate labels, e.g. accuracy of classification or mean squared error of regression 
CCEvaluationResult  Abstract class that contains the result generated by the MachineEvaluation class 
CCExactInferenceMethod  The Gaussian exact form inference method class 
CCExplicitSpecFeatures  Features that compute the Spectrum Kernel feature space explicitly 
CCExponentialARDKernel  Exponential Kernel with Automatic Relevance Detection computed on CDotFeatures 
CCExponentialKernel  The Exponential Kernel, closely related to the Gaussian Kernel computed on CDotFeatures 
CCExponentialLoss  CExponentialLoss implements the exponential loss function. \(L(y_i,f(x_i)) = \exp^{y_if(x_i)}\) 
CCF1Measure  Class F1Measure used to measure F1 score of 2class classifier 
CCFactor  Class CFactor A factor is defined on a clique in the factor graph. Each factor can have its own data, either dense, sparse or shared data. Note that currently this class is table factor oriented 
CCFactorAnalysis  The Factor Analysis class is used to embed data using Factor Analysis algorithm 
CCFactorDataSource  Class CFactorDataSource Source for factor data. In some cases, the same data can be shared by many factors 
CCFactorGraph  Class CFactorGraph a factor graph is a structured input in general 
CCFactorGraphDataGenerator  Class CFactorGraphDataGenerator Create factor graph data for multiple unit tests 
CCFactorGraphFeatures  CFactorGraphFeatures maintains an array of factor graphs, each graph is a sample, i.e. an instance of structured input 
CCFactorGraphLabels  Class FactorGraphLabels used e.g. in the application of Structured Output (SO) learning with the FactorGraphModel. Each of the labels is represented by a graph. Each label is of type CFactorGraphObservation and all of them are stored in a CDynamicObjectArray 
CCFactorGraphModel  CFactorGraphModel defines a model in terms of CFactorGraph and CMAPInference, where parameters are associated with factor types, in the model. There is a mapping vector records the locations of local factor parameters in the global parameter vector 
CCFactorGraphObservation  Class CFactorGraphObservation is used as the structured output 
CCFactorType  Class CFactorType defines the way of factor parameterization 
CCFastICA  Class FastICA 
CCFeatureBlockLogisticRegression  Class FeatureBlockLogisticRegression, a linear binary logistic loss classifier for problems with complex feature relations. Currently two feature relations are supported  feature group (done via CIndexBlockGroup) and feature tree (done via CIndexTree). Handling of feature relations is done via L1/Lq (for groups) and L1/L2 (for trees) regularization 
CCFeatures  The class Features is the base class of all feature objects 
CCFeatureSelection  Template class CFeatureSelection, base class for all feature selection preprocessors which select a subset of features (dimensions in the feature matrix) to achieve a specified number of dimensions, m_target_dim from a given set of features. This class showcases all feature selection algorithms via a generic interface. Supported algorithms are specified by the enum EFeatureSelectionAlgorithm which can be set via set_algorithm() call. Supported wrapper algorithms are 
CCFFDiag  Class FFDiag 
CCFFSep  Class FFSep 
CCFile  A File access base class 
CCFirstElementKernelNormalizer  Normalize the kernel by a constant obtained from the first element of the kernel matrix, i.e. \( c=k({\bf x},{\bf x})\) 
CCFisherLDA  Preprocessor FisherLDA attempts to model the difference between the classes of data by performing linear discriminant analysis on input feature vectors/matrices. When the init method in FisherLDA is called with proper feature matrix X(say N number of vectors and D feature dimensions) supplied via apply_to_feature_matrix or apply_to_feature_vector methods, this creates a transformation whose outputs are the reduced TDimensional & classspecific distribution (where T<= number of unique classes1). The transformation matrix is essentially a DxT matrix, the columns of which correspond to the specified number of eigenvectors which maximizes the ratio of between class matrix to within class matrix 
CCFITCInferenceMethod  The Fully Independent Conditional Training inference method class 
CCFixedDegreeStringKernel  The FixedDegree String kernel takes as input two strings of same size and counts the number of matches of length d 
CCFKFeatures  The class FKFeatures implements Fischer kernel features obtained from two Hidden Markov models 
CCFunction  Class of a function of one variable 
CCFWSOSVM  Class CFWSOSVM solves SOSVM using FrankWolfe algorithm [1] 
CCGaussian  Gaussian distribution interface 
CCGaussianARDKernel  Gaussian Kernel with Automatic Relevance Detection computed on CDotFeatures 
CCGaussianARDSparseKernel  Gaussian Kernel with Automatic Relevance Detection with supporting Sparse inference 
CCGaussianBlobsDataGenerator  
CCGaussianDistribution  Dense version of the wellknown Gaussian probability distribution, defined as \[ \mathcal{N}_x(\mu,\Sigma)= \frac{1}{\sqrt{2\pi\Sigma}} \exp\left(\frac{1}{2}(x\mu)^T\Sigma^{1}(x\mu)\right) \] 
CCGaussianKernel  The well known Gaussian kernel (swiss army knife for SVMs) computed on CDotFeatures 
CCGaussianLikelihood  Class that models Gaussian likelihood 
CCGaussianMatchStringKernel  The class GaussianMatchStringKernel computes a variant of the Gaussian kernel on strings of same length 
CCGaussianNaiveBayes  Class GaussianNaiveBayes, a Gaussian Naive Bayes classifier 
CCGaussianProcessClassification  Class GaussianProcessClassification implements binary and multiclass classification based on Gaussian Processes 
CCGaussianProcessMachine  A base class for Gaussian Processes 
CCGaussianProcessRegression  Class GaussianProcessRegression implements regression based on Gaussian Processes 
CCGaussianShiftKernel  An experimental kernel inspired by the WeightedDegreePositionStringKernel and the Gaussian kernel 
CCGaussianShortRealKernel  The well known Gaussian kernel (swiss army knife for SVMs) on dense shortreal valued features 
CCGCArray  Template class GCArray implements a garbage collecting static array 
►CCGEMPLP  
CParameter  
CCGeodesicMetric  Class GeodesicMetric 
CCGMM  Gaussian Mixture Model interface 
CCGMNPLib  Class GMNPLib Library of solvers for Generalized Minimal Norm Problem (GMNP) 
CCGMNPSVM  Class GMNPSVM implements a one vs. rest MultiClass SVM 
CCGNPPLib  Class GNPPLib, a Library of solvers for Generalized Nearest Point Problem (GNPP) 
CCGNPPSVM  Class GNPPSVM 
CCGPBTSVM  Class GPBTSVM 
CCGradientCriterion  Simple class which specifies the direction of gradient search 
CCGradientEvaluation  Class evaluates a machine using its associated differentiable function for the function value and its gradient with respect to parameters 
CCGradientModelSelection  Model selection class which searches for the best model by a gradientsearch 
CCGradientResult  Container class that returns results from GradientEvaluation. It contains the function value as well as its gradient 
CCGraphCut  
CCGridSearchModelSelection  Model selection class which searches for the best model by a grid search. See CModelSelection for details 
CCGUIClassifier  UI classifier 
CCGUIConverter  UI converter 
CCGUIDistance  UI distance 
CCGUIFeatures  UI features 
CCGUIHMM  UI HMM (Hidden Markov Model) 
CCGUIKernel  UI kernel 
CCGUILabels  UI labels 
CCGUIMath  UI math 
CCGUIPluginEstimate  UI estimate 
CCGUIPreprocessor  UI preprocessor 
CCGUIStructure  UI structure 
CCGUITime  UI time 
CCHAIDTreeNodeData  Structure to store data of a node of CHAID. This can be used as a template type in TreeMachineNode class. CHAID algorithm uses nodes of type CTreeMachineNode<CHAIDTreeNodeData> 
CCHammingWordDistance  Class HammingWordDistance 
CCHash  Collection of Hashing Functions 
CCHashedDenseFeatures  This class is identical to the CDenseFeatures class except that it hashes each dimension to a new feature space 
CCHashedDocConverter  This class can be used to convert a document collection contained in a CStringFeatures<char> object where each document is stored as a single vector into a hashed BagofWords representation. Like in the standard BagofWords representation, this class considers each document as a collection of tokens, which are then hashed into a new feature space of a specified dimension. This class is very flexible and allows the user to specify the tokenizer used to tokenize each document, specify whether the results should be normalized with regards to the sqrt of the document size, as well as to specify whether he wants to combine different tokens. The latter implements a kskip ngrams approach, meaning that you can combine up to n tokens, while skipping up to k. Eg. for the tokens ["a", "b", "c", "d"], with n_grams = 2 and skips = 2, one would get the following combinations : ["a", "ab", "ac" (skipped 1), "ad" (skipped 2), "b", "bc", "bd" (skipped 1), "c", "cd", "d"] 
CCHashedDocDotFeatures  This class can be used to provide onthefly vectorization of a document collection. Like in the standard BagofWords representation, this class considers each document as a collection of tokens, which are then hashed into a new feature space of a specified dimension. This class is very flexible and allows the user to specify the tokenizer used to tokenize each document, specify whether the results should be normalized with regards to the sqrt of the document size, as well as to specify whether he wants to combine different tokens. The latter implements a kskip ngrams approach, meaning that you can combine up to n tokens, while skipping up to k. Eg. for the tokens ["a", "b", "c", "d"], with n_grams = 2 and skips = 2, one would get the following combinations : ["a", "ab", "ac" (skipped 1), "ad" (skipped 2), "b", "bc", "bd" (skipped 1), "c", "cd", "d"] 
CCHashedMultilabelModel  Class CHashedMultilabelModel represents application specific model and contains application dependent logic for solving multilabel classification with feature hashing within a generic SO framework. We hash the feature of each class with a separate seed and put them in the same feature space (exploded feature space) 
CCHashedSparseFeatures  This class is identical to the CDenseFeatures class except that it hashes each dimension to a new feature space 
CCHashedWDFeatures  Features that compute the Weighted Degreee Kernel feature space explicitly 
CCHashedWDFeaturesTransposed  Features that compute the Weighted Degreee Kernel feature space explicitly 
CCHessianLocallyLinearEmbedding  Class HessianLocallyLinearEmbedding used to preprocess data using Hessian Locally Linear Embedding algorithm as described in 
CCHierarchical  Agglomerative hierarchical single linkage clustering 
CCHierarchicalMultilabelModel  Class CHierarchicalMultilabelModel represents application specific model and contains application dependent logic for solving hierarchical multilabel classification[1] within a generic SO framework 
CCHingeLoss  CHingeLoss implements the hinge loss function 
CCHistogram  Class Histogram computes a histogram over all 16bit unsigned integers in the features 
CCHistogramIntersectionKernel  The HistogramIntersection kernel operating on realvalued vectors computes the histogram intersection distance between sets of histograms. Note: the current implementation assumes positive values for the histograms, and input vectors should sum to 1 
CCHistogramWordStringKernel  The HistogramWordString computes the TOP kernel on inhomogeneous Markov Chains 
CCHMM  Hidden Markov Model 
CCHMSVMModel  Class CHMSVMModel that represents the application specific model and contains the application dependent logic to solve Hidden Markov Support Vector Machines (HMSVM) type of problems within a generic SO framework 
CCHomogeneousKernelMap  Preprocessor HomogeneousKernelMap performs homogeneous kernel maps as described in 
CCHSIC  This class implements the Hilbert Schmidtd Independence Criterion based independence test as described in [1] 
CCHuberLoss  CHuberLoss implements the Huber loss function. It behaves like SquaredLoss function at values below Huber delta and like absolute deviation at values greater than the delta 
CCHypothesisTest  Hypothesis test base class. Provides an interface for statistical hypothesis testing via three methods: compute_statistic(), compute_p_value() and compute_threshold(). The second computes a pvalue for the statistic computed by the first method. The pvalue represents the position of the statistic in the nulldistribution, i.e. the distribution of the statistic population given the nullhypothesis is true. (1position = pvalue). The third method, compute_threshold(), computes a threshold for a given test level which is needed to reject the nullhypothesis 
CCICAConverter  Class ICAConverter Base class for ICA algorithms 
CCID3ClassifierTree  Class ID3ClassifierTree, implements classifier tree for discrete feature values using the ID3 algorithm. The training algorithm implemented is as follows : 
CCIdentityKernelNormalizer  Identity Kernel Normalization, i.e. no normalization is applied 
CCImplicitWeightedSpecFeatures  Features that compute the Weighted Spectrum Kernel feature space explicitly 
CCIndependenceTest  Provides an interface for performing the independence test. Given samples \(Z=\{(x_i,y_i)\}_{i=1}^m\) from the joint distribution \(\textbf{P}_{xy}\), does the joint distribution factorize as \(\textbf{P}_{xy}=\textbf{P}_x\textbf{P}_y\), i.e. product of the marginals? The nullhypothesis says yes, i.e. no dependence, the alternative hypothesis says no 
CCIndependentComputationEngine  Abstract base class for solving multiple independent instances of CIndependentJob. It has one method, submit_job, which may add the job to an internal queue and might block if there is yet not space in the queue. After jobs are submitted, it might not yet be ready. wait_for_all waits until all jobs are completed, which must be called to guarantee that all jobs are finished 
CCIndependentJob  Abstract base for general computation jobs to be registered in CIndependentComputationEngine. compute method produces a job result and submits it to the internal JobResultAggregator. Each set of jobs that form a result will share the same job result aggregator 
CCIndexBlock  Class IndexBlock used to represent contiguous indices of one group (e.g. block of related features) 
CCIndexBlockGroup  Class IndexBlockGroup used to represent groupbased feature relation 
CCIndexBlockRelation  Class IndexBlockRelation 
CCIndexBlockTree  Class IndexBlockTree used to represent tree guided feature relation 
CCIndexFeatures  The class IndexFeatures implements features that contain the index of the features. This features used in the CCustomKernel::init to make the subset of the kernel matrix. Initial CIndexFeature of row_idx and col_idx, pass them to the CCustomKernel::init(row_idx, col_idx), then use CCustomKernel::get_kernel_matrix() will get the sub kernel matrix specified by the row_idx and col_idx 
CCIndirectObject  Array class that accesses elements indirectly via an index array 
CCIndividualJobResultAggregator  Class that aggregates vector job results in each submit_result call of jobs generated from rational approximation of linear operator function times a vector. finalize extracts the imaginary part of that aggregation, applies the linear operator to the aggregation, performs a dot product with the sample vector, multiplies with the constant multiplier (see CRationalApproximation) and stores the result as CScalarResult 
CCInferenceMethod  The Inference Method base class 
CCIntegration  Class that contains certain methods related to numerical integration 
CCIntronList  Class IntronList 
CCInverseMultiQuadricKernel  InverseMultiQuadricKernel 
CCIOBuffer  An I/O buffer class 
CCIsomap  The Isomap class is used to embed data using Isomap algorithm as described in: 
CCIterativeLinearSolver  Abstract template base for all iterative linear solvers such as conjugate gradient (CG) solvers. provides interface for setting the iteration limit, relative/absolute tolerence. solve method is abstract 
CCIterativeShiftedLinearFamilySolver  Abstract template base for CG based solvers to the solution of shifted linear systems of the form \((A+\sigma)x=b\) for several values of \(\sigma\) simultaneously, using only as many matrixvector operations as the solution of a single system requires. This class adds another interface to the basic iterative linear solver that takes the shifts, \(\sigma\), and also weights, \(\alpha\), and returns the summation \(\sum_{i} \alpha_{i}x_{i}\), where \(x_{i}\) is the solution of the system \((A+\sigma_{i})x_{i}=b\) 
CCJacobiEllipticFunctions  Class that contains methods for computing Jacobi elliptic functions related to complex analysis. These functions are inverse of the elliptic integral of first kind, i.e. \[ u(k,m)=\int_{0}^{k}\frac{dt}{\sqrt{(1t^{2})(1m^{2}t^{2})}} =\int_{0}^{\varphi}\frac{d\theta}{\sqrt{(1m^{2}sin^{2}\theta)}} \] where \(k=sin\varphi\), \(t=sin\theta\) and parameter \(m, 0\le m \le 1\) is called modulus. Three main Jacobi elliptic functions are defined as \(sn(u,m)=k=sin\theta\), \(cn(u,m)=cos\theta=\sqrt{1sn(u,m)^{2}}\) and \(dn(u,m)=\sqrt{1m^{2}sn(u,m)^{2}}\). For \(k=1\), i.e. \(\varphi=\frac{\pi}{2}\), \(u(1,m)=K(m)\) is known as the complete elliptic integral of first kind. Similarly, \(u(1,m'))= K'(m')\), \(m'=\sqrt{1m^{2}}\) is called the complementary complete elliptic integral of first kind. Jacobi functions are double periodic with quardratic periods \(K\) and \(K'\) 
CCJade  Class Jade 
CCJADiag  Class JADiag 
CCJADiagOrth  Class JADiagOrth 
CCJediDiag  Class Jedi 
CCJediSep  Class JediSep 
CCJensenMetric  Class JensenMetric 
CCJensenShannonKernel  The JensenShannon kernel operating on realvalued vectors computes the JensenShannon distance between the features. Often used in computer vision 
CCJLCoverTreePoint  Class Point to use with John Langford's CoverTree. This class must have some assoficated functions defined (distance, parse_points and print, see below) so it can be used with the CoverTree implementation 
CCJobResult  Base class that stores the result of an independent job 
CCJobResultAggregator  Abstract base class that provides an interface for computing an aggeregation of the job results of independent computation jobs as they are submitted and also for finalizing the aggregation 
CCKDTree  This class implements KDTree. cf. http://www.autonlab.org/autonweb/14665/version/2/part/5/data/mooretutorial.pdf 
CCKernel  The Kernel base class 
CCKernelDensity  This class implements the kernel density estimation technique. Kernel density estimation is a nonparametric way to estimate an unknown pdf. The pdf at a query point given finite training samples is calculated using the following formula : \ \(pdf(x')= \frac{1}{nh} \sum_{i=1}^n K(\frac{xx_i}{h})\) \ K() in the above formula is called the kernel function and is controlled by the parameter h called kernel bandwidth. Presently, this class supports only Gaussian kernel which can be used with either Euclidean distance or Manhattan distance. This class makes use of 2 tree structures KDtree and Ball tree for fast calculation. KDtrees are faster than ball trees at lower dimensions. In case of high dimensional data, ball tree tends to outperform KDtree. By default, the class used is Ball tree 
CCKernelDependenceMaximization  Class CKernelDependenceMaximization, that uses an implementation of CKernelIndependenceTest to compute dependence measures for feature selection. Different kernels are used for labels and data. For the sake of computational convenience, the precompute() method is overridden to precompute the kernel for labels and save as an instance of CCustomKernel 
CCKernelDistance  The Kernel distance takes a distance as input 
CCKernelIndependenceTest  Kernel independence test base class. Provides an interface for performing an independence test. Given samples \(Z=\{(x_i,y_i)\}_{i=1}^m\) from the joint distribution \(\textbf{P}_{xy}\), does the joint distribution factorize as \(\textbf{P}_{xy}=\textbf{P}_x\textbf{P}_y\), i.e. product of the marginals? 
CCKernelLocallyLinearEmbedding  Class KernelLocallyLinearEmbedding used to construct embeddings of data using kernel formulation of Locally Linear Embedding algorithm as described in 
CCKernelMachine  A generic KernelMachine interface 
CCKernelMeanMatching  Kernel Mean Matching 
CCKernelMulticlassMachine  Generic kernel multiclass 
CCKernelNormalizer  The class Kernel Normalizer defines a function to postprocess kernel values 
CCKernelPCA  Preprocessor KernelPCA performs kernel principal component analysis 
CCKernelRidgeRegression  Class KernelRidgeRegression implements Kernel Ridge Regression  a regularized least square method for classification and regression 
CCKernelSelection  Base class for kernel selection for kernel twosample test statistic implementations (e.g. MMD). Provides abstract methods for selecting kernels and computing criteria or kernel weights for the implemented method. In order to implement new methods for kernel selection, simply write a new implementation of this class 
CCKernelStructuredOutputMachine  
CCKernelTwoSampleTest  Kernel two sample test base class. Provides an interface for performing a twosample test using a kernel, i.e. Given samples from two distributions \(p\) and \(q\), the nullhypothesis is: \(H_0: p=q\), the alternative hypothesis: \(H_1: p\neq q\) 
CCKLApproxDiagonalInferenceMethod  The KL approximation inference method class 
CCKLCholeskyInferenceMethod  The KL approximation inference method class 
CCKLCovarianceInferenceMethod  The KL approximation inference method class 
CCKLDualInferenceMethod  The dual KL approximation inference method class 
CCKLInferenceMethod  The KL approximation inference method class 
CCKLLowerTriangularInferenceMethod  The KL approximation inference method class 
CCKMeans  KMeans clustering, partitions the data into k (apriori specified) clusters 
CCKMeansLloydImpl  
CCKMeansMiniBatchImpl  
CCKNN  Class KNN, an implementation of the standard knearest neigbor classifier 
CCKNNHeap  This class implements a specialized version of max heap structure. This heap specializes in storing the least k values seen so far along with the indices (or id) of the entities with which the values are associated. On calling the push method, it is automatically checked, if the new value supplied, is among the least k distances seen so far. Also, in case the heap is full already, the max among the stored values is automatically thrown out as the new value finds its proper place in the heap 
CCLabels  The class Labels models labels, i.e. class assignments of objects 
CCLabelsFactory  The helper class to specialize base class instances of labels 
CCLanczosEigenSolver  Class that computes eigenvalues of a real valued, selfadjoint linear operator using Lanczos algorithm 
CCLaplacianEigenmaps  Class LaplacianEigenmaps used to construct embeddings of data using Laplacian Eigenmaps algorithm as described in: 
CCLaplacianInferenceBase  The Laplace approximation inference method base class 
CCLaRank  LaRank multiclass SVM machine 
CCLatentFeatures  Latent Features class The class if for representing features for latent learning, e.g. LatentSVM. It's basically a very generic way of storing features of any (userdefined) form based on CData 
CCLatentLabels  Abstract class for latent labels As latent labels always depends on the given application, this class only defines the API that the user has to implement for latent labels 
CCLatentModel  Abstract class CLatentModel It represents the application specific model and contains most of the application dependent logic to solve latent variable based problems 
CCLatentSOSVM  Class Latent Structured Output SVM, an structured output based machine for classification problems with latent variables 
CCLatentSVM  LatentSVM class Latent SVM implementation based on [1]. For optimization this implementation uses SVMOcas 
CCLBPPyrDotFeatures  Implements Local Binary Patterns with Scale Pyramids as dot features for a set of images. Expects the images to be loaded in a CDenseFeatures object 
CCLDA  Class LDA implements regularized Linear Discriminant Analysis 
CCLeastAngleRegression  Class for Least Angle Regression, can be used to solve LASSO 
CCLeastSquaresRegression  Class to perform Least Squares Regression 
CCLibLinear  This class provides an interface to the LibLinear library for large scale linear learning focusing on SVM [1]. This is the classification interface. For regression, see CLibLinearRegression. There is also an online version, see COnlineLibLinear 
CCLibLinearMTL  Class to implement LibLinear 
CCLibLinearRegression  This class provides an interface to the LibLinear library for large scale linear learning focusing on SVM [1]. This is the regression interface. For classification, see CLibLinear 
CCLibSVM  LibSVM 
CCLibSVMFile  Read sparse real valued features in svm light format e.g. 1 1:10.0 2:100.2 1000:1.3 with 1 == (optional) label and dim 1  value 10.0 dim 2  value 100.2 dim 1000  value 1.3 
CCLibSVMOneClass  Class LibSVMOneClass 
CCLibSVR  Class LibSVR, performs support vector regression using LibSVM 
CCLikelihoodModel  The Likelihood model base class 
CCLinearHMM  The class LinearHMM is for learning Higher Order Markov chains 
CCLinearKernel  Computes the standard linear kernel on CDotFeatures 
CCLinearLatentMachine  Abstract implementaion of Linear Machine with latent variable This is the base implementation of all linear machines with latent variable 
CCLinearLocalTangentSpaceAlignment  Class LinearLocalTangentSpaceAlignment converter used to construct embeddings as described in: 
CCLinearMachine  Class LinearMachine is a generic interface for all kinds of linear machines like classifiers 
CCLinearMulticlassMachine  Generic linear multiclass machine 
CCLinearOperator  Abstract template base class that represents a linear operator, e.g. a matrix 
CCLinearRidgeRegression  Class LinearRidgeRegression implements Ridge Regression  a regularized least square method for classification and regression 
CCLinearSolver  Abstract template base class that provides an abstract solve method for linear systems, that takes a linear operator \(A\), a vector \(b\), solves the system \(Ax=b\) and returns the vector \(x\) 
CCLinearStringKernel  Computes the standard linear kernel on dense char valued features 
CCLinearStructuredOutputMachine  
CCLinearTimeMMD  This class implements the linear time Maximum Mean Statistic as described in [1] for streaming data (see CStreamingMMD for description) 
CCLineReader  Class for buffered reading from a ascii file 
CCList  Class List implements a doubly connected list for lowlevelobjects 
CCListElement  Class ListElement, defines how an element of the the list looks like 
CCLMNN  Class LMNN that implements the distance metric learning technique Large Margin Nearest Neighbour (LMNN) described in 
CCLMNNStatistics  Class LMNNStatistics used to give access to intermediate results obtained training LMNN 
CCLocalAlignmentStringKernel  The LocalAlignmentString kernel compares two sequences through all possible local alignments between the two sequences 
CCLocalityImprovedStringKernel  The LocalityImprovedString kernel is inspired by the polynomial kernel. Comparing neighboring characters it puts emphasize on local features 
CCLocalityPreservingProjections  Class LocalityPreservingProjections used to compute embeddings of data using Locality Preserving Projections method as described in 
CCLocallyLinearEmbedding  Class LocallyLinearEmbedding used to embed data using Locally Linear Embedding algorithm described in 
CCLocalTangentSpaceAlignment  Class LocalTangentSpaceAlignment used to embed data using Local Tangent Space Alignment (LTSA) algorithm as described in: 
CCLock  Class Lock used for synchronization in concurrent programs 
CCLogDetEstimator  Class to create unbiased estimators of \(log(\leftC\right)= trace(log(C))\). For each estimate, it samples trace vectors (one by one) and calls submit_jobs of COperatorFunction, stores the resulting job result aggregator instances, calls wait_for_all of CIndependentComputationEngine to ensure that the job result aggregators are all up to date. Then simply computes running averages over the estimates 
CCLogitDVGLikelihood  Class that models dual variational logit likelihood 
CCLogitLikelihood  Class that models Logit likelihood 
CCLogitVGLikelihood  Class that models Logit likelihood and uses numerical integration to approximate the following variational expection of log likelihood \[ \sum_{{i=1}^n}{E_{q(f_i{\mu}_i,{\sigma}^2_i)}[logP(y_if_i)]} \] 
CCLogitVGPiecewiseBoundLikelihood  Class that models Logit likelihood and uses variational piecewise bound to approximate the following variational expection of log likelihood \[ \sum_{{i=1}^n}{E_{q(f_i{\mu}_i,{\sigma}^2_i)}[logP(y_if_i)]} \] where \[ p(y_if_i) = \frac{exp(y_i*f_i)}{1+exp(f_i)}, y_i \in \{0,1\} \] 
CCLogKernel  Log kernel 
CCLogLoss  CLogLoss implements the logarithmic loss function 
CCLogLossMargin  Class CLogLossMargin implements a marginbased loglikelihood loss function 
CCLogPlusOne  Preprocessor LogPlusOne does what the name says, it adds one to a dense real valued vector and takes the logarithm of each component of it 
CCLogRationalApproximationCGM  Implementaion of rational approximation of a operatorfunction times vector where the operator function is log of a linear operator. Each complex system generated from the shifts due to rational approximation of opertor log times vector expression are solved at once with a shifted linearfamily solver by the computation engine. generate_jobs generates one job per sample 
CCLogRationalApproximationIndividual  Implementaion of rational approximation of a operatorfunction times vector where the operator function is log of a densematrix. Each complex system generated from the shifts due to rational approximation of opertor log times vector expression are solved individually with a complex linear solver by the computation engine. generate_jobs generates num_shifts number of jobs per trace sample 
CCLOOCrossValidationSplitting  Implementation of Leave one out crossvalidation on the base of CCrossValidationSplitting. Produces subset index sets consisting of one element,for each label 
CCLoss  Class which collects generic mathematical functions 
CCLossFunction  Class CLossFunction is the base class of all loss functions 
CCLPBoost  Class LPBoost trains a linear classifier called Linear Programming Machine, i.e. a SVM using a \(\ell_1\) norm regularizer 
CCLPM  Class LPM trains a linear classifier called Linear Programming Machine, i.e. a SVM using a \(\ell_1\) norm regularizer 
CCMachine  A generic learning machine interface 
CCMachineEvaluation  Machine Evaluation is an abstract class that evaluates a machine according to some criterion 
CCMahalanobisDistance  Class MahalanobisDistance 
CCMajorityVote  CMajorityVote is a CWeightedMajorityVote combiner, where each Machine's weight in the ensemble is 1.0 
CCManhattanMetric  Class ManhattanMetric 
CCManhattanWordDistance  Class ManhattanWordDistance 
CCManifoldSculpting  Class CManifoldSculpting used to embed data using manifold sculpting embedding algorithm 
CCMap  Class CMap, a map based on the hashtable. w: http://en.wikipedia.org/wiki/Hash_table 
CCMAPInference  Class CMAPInference performs MAP inference on a factor graph. Briefly, given a factor graph model, with features \(\bold{x}\), the prediction is obtained by \( {\arg\max} _{\bold{y}} P(\bold{Y} = \bold{y}  \bold{x}; \bold{w}) \) 
CCMAPInferImpl  Class CMAPInferImpl abstract class of MAP inference implementation 
CCMatchWordStringKernel  The class MatchWordStringKernel computes a variant of the polynomial kernel on strings of same length converted to a word alphabet 
►CCMath  Class which collects generic mathematical functions 
CIndexSorter  
CCMatrixFeatures  Class CMatrixFeatures used to represent data whose feature vectors are better represented with matrices rather than with unidimensional arrays or vectors. Optionally, it can be restricted that all the feature vectors have the same number of features. Set the attribute num_features different to zero to use this restriction. Allow feature vectors with different number of features by setting num_features equal to zero (default behaviour) 
CCMatrixOperations  The helper class is used for Laplace and KL methods 
CCMatrixOperator  Abstract base class that represents a matrix linear operator. It provides an interface to computes matrixvector product \(Ax\) in its apply method, \(A\in\mathbb{C}^{m\times n},A:\mathbb{C}^{n} \rightarrow \mathbb{C}^{m}\) being the matrix operator and \(x\in \mathbb{C}^{n}\) being the vector. The result is a vector \(y\in \mathbb{C}^{m}\) 
CCMCLDA  Class MCLDA implements multiclass Linear Discriminant Analysis 
CCMeanAbsoluteError  Class MeanAbsoluteError used to compute an error of regression model 
CCMeanFunction  An abstract class of the mean function 
CCMeanRule  CMeanRule simply averages the outputs of the Machines in the ensemble 
CCMeanShiftDataGenerator  
CCMeanSquaredError  Class MeanSquaredError used to compute an error of regression model 
CCMeanSquaredLogError  Class CMeanSquaredLogError used to compute an error of regression model 
CCMemoryMappedFile  Memory mapped file 
CCMinimizerContext  
CCMinkowskiMetric  Class MinkowskiMetric 
CCMixtureModel  This is the generic class for mixture models. The final distribution is a mixture of various simple distributions supplied by the user 
CCMKL  Multiple Kernel Learning 
CCMKLClassification  Multiple Kernel Learning for twoclassclassification 
CCMKLMulticlass  MKLMulticlass is a class for L1norm Multiclass MKL 
CCMKLOneClass  Multiple Kernel Learning for oneclassclassification 
CCMKLRegression  Multiple Kernel Learning for regression 
CCMMDKernelSelection  Base class for kernel selection for MMDbased twosample test statistic implementations. Provides abstract methods for selecting kernels and computing criteria or kernel weights for the implemented method. In order to implement new methods for kernel selection, simply write a new implementation of this class 
CCMMDKernelSelectionComb  Base class for kernel selection of combined kernels. Given an MMD instance whose underlying kernel is a combined one, this class provides an interface to select weights of this combined kernel 
CCMMDKernelSelectionCombMaxL2  Implementation of maximum MMD kernel selection for combined kernel. This class selects a combination of baseline kernels that maximises the the MMD for a combined kernel based on a L2regularization approach. This boils down to solve the convex program \[ \min_\beta \{\beta^T \beta \quad \text{s.t.}\quad \beta^T \eta=1, \beta\succeq 0\}, \] where \(\eta\) is a vector whose elements are the MMDs of the baseline kernels 
CCMMDKernelSelectionCombOpt  Implementation of optimal kernel selection for combined kernel. This class selects a combination of baseline kernels that maximises the ratio of the MMD and its standard deviation for a combined kernel. This boils down to solve the convex program \[ \min_\beta \{\beta^T (Q+\lambda_m) \beta \quad \text{s.t.}\quad \beta^T \eta=1, \beta\succeq 0\}, \] where \(\eta\) is a vector whose elements are the MMDs of the baseline kernels and \(Q\) is a linear time estimate of the covariance of \(\eta\) 
CCMMDKernelSelectionMax  Kernel selection class that selects the single kernel that maximises the MMD statistic. Works for CQuadraticTimeMMD and CLinearTimeMMD. This leads to a heuristic that is better than the standard median heuristic for Gaussian kernels. However, it comes with no guarantees 
CCMMDKernelSelectionMedian  Implements MMD kernel selection for a number of Gaussian baseline kernels via selecting the one with a bandwidth parameter that is closest to the median of all pairwise distances in the underlying data. Therefore, it only works for data to which a GaussianKernel can be applied, which are grouped under the class CDotFeatures in SHOGUN 
CCMMDKernelSelectionOpt  Implements optimal kernel selection for single kernels. Given a number of baseline kernels, this method selects the one that minimizes the type II error for a given type I error for a twosample test. This only works for the CLinearTimeMMD statistic 
CCModelSelection  Abstract base class for model selection 
CCModelSelectionParameters  Class to select parameters and their ranges for model selection. The structure is organized as a tree with different kinds of nodes, depending on the values of its member variables of name and CSGObject 
CCMPDSVM  Class MPDSVM 
CCMulticlassAccuracy  The class MulticlassAccuracy used to compute accuracy of multiclass classification 
CCMulticlassLabels  Multiclass Labels for multiclass classification 
CCMulticlassLibLinear  Multiclass LibLinear wrapper. Uses CrammerSinger formulation and gradient descent optimization algorithm implemented in the LibLinear library. Regularized bias support is added using stacking bias 'feature' to hyperplanes normal vectors 
CCMulticlassLibSVM  Class LibSVMMultiClass. Does one vs one classification 
CCMulticlassLogisticRegression  Multiclass logistic regression 
CCMulticlassMachine  Experimental abstract generic multiclass machine class 
CCMulticlassModel  Class CMulticlassModel that represents the application specific model and contains the application dependent logic to solve multiclass classification within a generic SO framework 
CCMulticlassOCAS  Multiclass OCAS wrapper 
CCMulticlassOneVsOneStrategy  Multiclass one vs one strategy used to train generic multiclass machines for Kclass problems with building votingbased ensemble of K*(K1) binary classifiers multiclass probabilistic outputs can be obtained by using the heuristics described in [1] 
CCMulticlassOneVsRestStrategy  Multiclass one vs rest strategy used to train generic multiclass machines for Kclass problems with building ensemble of K binary classifiers 
CCMulticlassOVREvaluation  The class MulticlassOVREvaluation used to compute evaluation parameters of multiclass classification via binary OvR decomposition and given binary evaluation technique 
CCMulticlassSOLabels  Class CMulticlassSOLabels to be used in the application of Structured Output (SO) learning to multiclass classification. Each of the labels is represented by a real number and it is required that the values of the labels are in the set {0, 1, ..., num_classes1}. Each label is of type CRealNumber and all of them are stored in a CDynamicObjectArray 
CCMulticlassStrategy  Class MulticlassStrategy used to construct generic multiclass classifiers with ensembles of binary classifiers 
CCMulticlassSVM  Class MultiClassSVM 
CCMulticlassTreeGuidedLogisticRegression  Multiclass tree guided logistic regression 
CCMultidimensionalScaling  Class Multidimensionalscaling is used to perform multidimensional scaling (capable of landmark approximation if requested) 
CCMultilabelAccuracy  Class CMultilabelAccuracy used to compute accuracy of multilabel classification 
CCMultilabelCLRModel  Class MultilabelCLRModel represents application specific model and contains application dependent logic for solving multilabel classification using Calibrated Label Ranking (CLR) [1] method within a generic SO framework 
CCMultilabelLabels  Multilabel Labels for multilabel classification 
CCMultilabelModel  Class CMultilabelModel represents application specific model and contains application dependent logic for solving multilabel classification within a generic SO framework 
CCMultilabelSOLabels  Class CMultilabelSOLabels used in the application of Structured Output (SO) learning to Multilabel Classification. Labels are subsets of {0, 1, ..., num_classes1}. Each of the label if of type CSparseMultilabel and all of them are stored in a CDynamicObjectArray 
CCMultiLaplacianInferenceMethod  The Laplace approximation inference method class for multi classification 
CCMultiquadricKernel  MultiquadricKernel 
CCMultitaskClusteredLogisticRegression  Class MultitaskClusteredLogisticRegression, a classifier for multitask problems. Supports only task group relations. Based on solver ported from the MALSAR library. Assumes task in group are related with a clustered structure 
CCMultitaskKernelMaskNormalizer  The MultitaskKernel allows Multitask Learning via a modified kernel function 
CCMultitaskKernelMaskPairNormalizer  The MultitaskKernel allows Multitask Learning via a modified kernel function 
CCMultitaskKernelMklNormalizer  Baseclass for parameterized Kernel Normalizers 
CCMultitaskKernelNormalizer  The MultitaskKernel allows Multitask Learning via a modified kernel function 
CCMultitaskKernelPlifNormalizer  The MultitaskKernel allows learning a piecewise linear function (PLIF) via MKL 
CCMultitaskKernelTreeNormalizer  The MultitaskKernel allows Multitask Learning via a modified kernel function based on taxonomy 
►CCMultitaskL12LogisticRegression  Class MultitaskL12LogisticRegression, a classifier for multitask problems. Supports only task group relations. Based on solver ported from the MALSAR library 
CSelf  
CCMultitaskLeastSquaresRegression  Class Multitask Least Squares Regression, a machine to solve regression problems with a few tasks related via group or tree. Based on L1/Lq regression for groups and L1/L2 for trees 
CCMultitaskLinearMachine  Class MultitaskLinearMachine, a base class for linear multitask classifiers 
CCMultitaskLogisticRegression  Class Multitask Logistic Regression used to solve classification problems with a few tasks related via group or tree. Based on L1/Lq regression for groups and L1/L2 for trees 
CCMultitaskROCEvaluation  Class MultitaskROCEvalution used to evaluate ROC (Receiver Operating Characteristic) and an area under ROC curve (auROC) of each task separately 
CCMultitaskTraceLogisticRegression  Class MultitaskTraceLogisticRegression, a classifier for multitask problems. Supports only task group relations. Based on solver ported from the MALSAR library 
CCNativeMulticlassMachine  Experimental abstract native multiclass machine class 
CCNbodyTree  This class implements genaralized tree for Nbody problems like kNN, kernel density estimation, 2 point correlation 
CCNearestCentroid  Class NearestCentroid, an implementation of Nearest Shrunk Centroid classifier 
CCNeighborhoodPreservingEmbedding  NeighborhoodPreservingEmbedding converter used to construct embeddings as described in: 
CCNeuralConvolutionalLayer  Main component in convolutional neural networks 
CCNeuralInputLayer  Represents an input layer. The layer can be either connected to all the input features that a network receives (default) or connected to just a small part of those features 
CCNeuralLayer  Base class for neural network layers 
CCNeuralLayers  A class to construct neural layers 
CCNeuralLeakyRectifiedLinearLayer  Neural layer with leaky rectified linear neurons 
CCNeuralLinearLayer  Neural layer with linear neurons, with an identity activation function. can be used as a hidden layer or an output layer 
CCNeuralLogisticLayer  Neural layer with linear neurons, with a logistic activation function. can be used as a hidden layer or an output layer 
CCNeuralNetwork  A generic multilayer neural network 
CCNeuralRectifiedLinearLayer  Neural layer with rectified linear neurons 
CCNeuralSoftmaxLayer  Neural layer with linear neurons, with a softmax activation function. can be only be used as an output layer. Cross entropy error measure is used 
CCNewtonSVM  NewtonSVM, In this Implementation linear SVM is trained in its primal form using Newtonlike iterations. This Implementation is ported from the Olivier Chapelles fast newton based SVM solver, Which could be found here :http://mloss.org/software/view/30/ For further information on this implementation of SVM refer to this paper: http://www.kyb.mpg.de/publications/attachments/neco_%5B0%5D.pdf 
CCNGramTokenizer  The class CNGramTokenizer is used to tokenize a SGVector<char> into ngrams 
CCNOCCO  This class implements the NOrmalized Cross Covariance Operator (NOCCO) based independence test as described in [1] 
CCNode  A CNode is an element of a CTaxonomy, which is used to describe hierarchical structure between tasks 
CCNormalSampler  Class that provides a sample method for Gaussian samples 
CCNormOne  Preprocessor NormOne, normalizes vectors to have norm 1 
CCNumericalVGLikelihood  Class that models likelihood and uses numerical integration to approximate the following variational expection of log likelihood \[ \sum_{{i=1}^n}{E_{q(f_i{\mu}_i,{\sigma}^2_i)}[logP(y_if_i)]} \] 
CCOligoStringKernel  This class offers access to the Oligo Kernel introduced by Meinicke et al. in 2004 
CConditionalProbabilityTreeNodeData  Struct to store data of node of conditional probability tree 
CCOnlineLibLinear  Class implementing a purely online version of CLibLinear, using the L2R_L1LOSS_SVC_DUAL solver only 
CCOnlineLinearMachine  Class OnlineLinearMachine is a generic interface for linear machines like classifiers which work through online algorithms 
CCOnlineSVMSGD  Class OnlineSVMSGD 
CConstLearningRate  This implements the const learning rate class for a descentbased minimizer 
CCOperatorFunction  Abstract template base class for computing \(s^{T} f(C) s\) for a linear operator C and a vector s. submit_jobs method creates a bunch of jobs needed to solve for this particular \(s\) and attaches one unique job aggregator to each of them, then submits them all to the computation engine 
CCParameterCombination  Class that holds ONE combination of parameters for a learning machine. The structure is organized as a tree. Every node may hold a name or an instance of a Parameter class. Nodes may have children. The nodes are organized in such way, that every parameter of a model for model selection has one node and subparameters are stored in subnodes. Using a tree of this class, parameters of models may easily be set. There are these types of nodes: 
CCParser  Class for reading from a string 
CCPCA  Preprocessor PCA performs principial component analysis on input feature vectors/matrices. When the init method in PCA is called with proper feature matrix X (with say N number of vectors and D feature dimension), a transformation matrix is computed and stored internally. This transformation matrix is then used to transform all Ddimensional feature vectors or feature matrices (with D feature dimensions) supplied via apply_to_feature_matrix or apply_to_feature_vector methods. This tranformation outputs the TDimensional approximation of all these input vectors and matrices (where T<=min(D,N)). The transformation matrix is essentially a DxT matrix, the columns of which correspond to the eigenvectors of the covariance matrix(XX') having top T eigenvalues 
CCPerceptron  Class Perceptron implements the standard linear (online) perceptron 
CCPeriodicKernel  The periodic kernel as described in The Kernel Cookbook by David Duvenaud: http://people.seas.harvard.edu/~dduvenaud/cookbook/ 
CCPlif  Class Plif 
CCPlifArray  Class PlifArray 
CCPlifBase  Class PlifBase 
CCPlifMatrix  Store plif arrays for all transitions in the model 
CCPluginEstimate  Class PluginEstimate 
CCPNorm  Preprocessor PNorm, normalizes vectors to have pnorm 
CCPolyFeatures  Implement DotFeatures for the polynomial kernel 
CCPolyKernel  Computes the standard polynomial kernel on CDotFeatures 
CCPolyMatchStringKernel  The class PolyMatchStringKernel computes a variant of the polynomial kernel on strings of same length 
CCPolyMatchWordStringKernel  The class PolyMatchWordStringKernel computes a variant of the polynomial kernel on wordfeatures 
CCPositionalPWM  Positional PWM 
CCPowerKernel  Power kernel 
CCPRCEvaluation  Class PRCEvaluation used to evaluate PRC (Precision Recall Curve) and an area under PRC curve (auPRC) 
CCPrecisionMeasure  Class PrecisionMeasure used to measure precision of 2class classifier 
CCPreprocessor  Class Preprocessor defines a preprocessor interface 
CCProbabilityDistribution  A base class for representing ndimensional probability distribution over the real numbers (64bit) for which various statistics can be computed and which can be sampled 
CCProbitLikelihood  Class that models Probit likelihood 
CCProbitVGLikelihood  Class that models Probit likelihood and uses numerical integration to approximate the following variational expection of log likelihood \[ \sum_{{i=1}^n}{E_{q(f_i{\mu}_i,{\sigma}^2_i)}[logP(y_if_i)]} \] 
CCProductKernel  The Product kernel is used to combine a number of kernels into a single ProductKernel object by element multiplication 
CCProtobufFile  Class for work with binary file in protobuf format 
CCPruneVarSubMean  Preprocessor PruneVarSubMean will substract the mean and remove features that have zero variance 
CCPyramidChi2  Pyramid Kernel over Chi2 matched histograms 
CCQDA  Class QDA implements Quadratic Discriminant Analysis 
CCQDiag  Class QDiag 
CCQPBSVMLib  Class QPBSVMLib 
CCQuadraticTimeMMD  This class implements the quadratic time Maximum Mean Statistic as described in [1]. The MMD is the distance of two probability distributions \(p\) and \(q\) in a RKHS which we denote by \[ \hat{\eta_k}=\text{MMD}[\mathcal{F},p,q]^2=\textbf{E}_{x,x'} \left[ k(x,x')\right]2\textbf{E}_{x,y}\left[ k(x,y)\right] +\textbf{E}_{y,y'}\left[ k(y,y')\right]=\mu_p  \mu_q^2_\mathcal{F} \] 
CCRandom  : Pseudo random number geneartor 
CCRandomCARTree  This class implements randomized CART algorithm used in the tree growing process of candidate trees in Random Forests algorithm. The tree growing process is different from the original CART algorithm because of the input attributes which are considered for each node split. In randomized CART, a few (fixed number) attributes are randomly chosen from all available attributes while deciding the best split. This is unlike the original CART where all available attributes are considered while deciding the best split 
CCRandomConditionalProbabilityTree  
CCRandomForest  This class implements the Random Forests algorithm. In Random Forests algorithm, we train a number of randomized CART trees (see class CRandomCARTree) using the supplied training data. The number of trees to be trained is a parameter (called number of bags) controlled by the user. Test feature vectors are classified/regressed by combining the outputs of all these trained candidate trees using a combination rule (see class CCombinationRule). The feature for calculating outofbox error is also provided to help determine the appropriate number of bags. The evaluatin criteria for calculating this outofbox error is specified by the user (see class CEvaluation) 
CCRandomFourierDotFeatures  This class implements the random fourier features for the DotFeatures framework. Basically upon the object creation it computes the random coefficients, namely w and b, that are needed for this method and then every time a vector is required it is computed based on the following formula z(x) = sqrt(2/D) * cos(w'*x + b), where D is the number of samples that are used 
CCRandomFourierGaussPreproc  Preprocessor CRandomFourierGaussPreproc implements Random Fourier Features for the Gauss kernel a la Ali Rahimi and Ben Recht Nips2007 after preprocessing the features using them in a linear kernel approximates a gaussian kernel 
CCRandomKitchenSinksDotFeatures  Class that implements the Random Kitchen Sinks (RKS) for the DotFeatures as mentioned in http://books.nips.cc/papers/files/nips21/NIPS2008_0885.pdf 
CCRandomSearchModelSelection  Model selection class which searches for the best model by a random search. See CModelSelection for details 
CCRationalApproximation  Abstract base class of the rational approximation of a function of a linear operator (A) times vector (v) using Cauchy's integral formula  \[f(\text{A})\text{v}=\oint_{\Gamma}f(z)(z\text{I}\text{A})^{1} \text{v}dz\] Computes eigenvalues of linear operator and uses Jacobi elliptic functions and conformal maps [2] for quadrature rule for discretizing the contour integral and computes complex shifts, weights and constant multiplier of the rational approximation of the above expression as \[f(\text{A})\text{v}\approx \eta\text{A}\Im\left(\sum_{l=1}^{N}\alpha_{l} (\text{A}\sigma_{l}\text{I})^{1}\text{v}\right)\] where \(\alpha_{l},\sigma_{l}\in\mathbb{C}\) are respectively the shifts and weights of the linear systems generated from the rational approximation, and \(\eta\in\mathbb{R}\) is the constant multiplier, equals to \(\frac{8K(\lambda_{m}\lambda_{M})^{\frac{1}{4}}}{k\pi N}\) 
CCRationalApproximationCGMJob  Implementation of independent jobs that solves one whole family of shifted systems in rational approximation of linear operator function times a vector using CGM linear solver. compute calls submit_results of the aggregator with CScalarResult (see CRationalApproximation) 
CCRationalApproximationIndividualJob  Implementation of independent job that solves one of the family of shifted systems in rational approximation of linear operator function times a vector using a direct linear solver. The shift is moved inside the operator. compute calls submit_results of the aggregator with CVectorResult which is the solution vector for that shift multiplied by complex weight (See CRationalApproximation) 
CCRationalQuadraticKernel  Rational Quadratic kernel 
CCRBM  A Restricted Boltzmann Machine 
CCRealDistance  Class RealDistance 
CCRealFileFeatures  The class RealFileFeatures implements a dense doubleprecision floating point matrix from a file 
CCRealNumber  Class CRealNumber to be used in the application of Structured Output (SO) learning to multiclass classification. Even though it is likely that it does not make sense to consider real numbers as structured data, it has been made in this way because the basic type to use in structured labels needs to inherit from CStructuredData 
CCRecallMeasure  Class RecallMeasure used to measure recall of 2class classifier 
CCRegressionLabels  Real Labels are realvalued labels 
CCRegulatoryModulesStringKernel  The Regulaty Modules kernel, based on the WD kernel, as published in Schultheiss et al., Bioinformatics (2009) on regulatory sequences 
CCRejectionStrategy  Base rejection strategy class 
CCRelaxedTree  
CCRescaleFeatures  Preprocessor RescaleFeautres is rescaling the range of features to make the features independent of each other and aims to scale the range in [0, 1] or [1, 1] 
CCResultSet  
CCRidgeKernelNormalizer  Normalize the kernel by adding a constant term to its diagonal. This aids kernels to become positive definite (even though they are not  often caused by numerical problems) 
CCROCEvaluation  Class ROCEvalution used to evaluate ROC (Receiver Operating Characteristic) and an area under ROC curve (auROC) 
CCSalzbergWordStringKernel  The SalzbergWordString kernel implements the Salzberg kernel 
CCScalarResult  Base class that stores the result of an independent job when the result is a scalar 
CCScatterKernelNormalizer  Scatter kernel normalizer 
CCScatterSVM  ScatterSVM  Multiclass SVM 
CCSegmentLoss  Class IntronList 
CCSequence  Class CSequence to be used in the application of Structured Output (SO) learning to Hidden Markov Support Vector Machines (HMSVM) 
CCSequenceLabels  Class CSequenceLabels used e.g. in the application of Structured Output (SO) learning to Hidden Markov Support Vector Machines (HMSVM). Each of the labels is represented by a sequence of integers. Each label is of type CSequence and all of them are stored in a CDynamicObjectArray 
CCSerialComputationEngine  Class that computes multiple independent instances of computation jobs sequentially 
CCSerializableAsciiFile  Serializable ascii file 
►CCSerializableFile  Serializable file 
CTSerializableReader  Serializable reader 
CCSet  Class CSet, a set based on the hashtable. w: http://en.wikipedia.org/wiki/Hash_table 
CCSGDQN  Class SGDQN 
CCSGObject  Class SGObject is the base class of all shogun objects 
CCShareBoost  
CCSigmoidKernel  The standard Sigmoid kernel computed on dense real valued features 
CCSignal  Class Signal implements signal handling to e.g. allow ctrl+c to cancel a long running process 
CCSimpleFile  Template class SimpleFile to read and write from files 
CCSimpleLocalityImprovedStringKernel  SimpleLocalityImprovedString kernel, is a ``simplified'' and better performing version of the Locality improved kernel 
CCSingleFITCLaplacianBase  The Fully Independent Conditional Training inference base class for Laplace and regression for 1D labels (1D regression and binary classification) 
CCSingleFITCLaplacianInferenceMethod  The SingleFITCLaplace approximation inference method class for regression and binary Classification. Note that the number of inducing points (m) is usually far less than the number of input points (n). (the time complexity is computed based on the assumption m < n) 
CCSingleFITCLaplacianInferenceMethodWithLBFGS  The Laplace approximation FITC inference method with LBFGS class for regression and binary classification 
CCSingleLaplacianInferenceMethod  The SingleLaplace approximation inference method class for regression and binary Classification 
CCSingleLaplacianInferenceMethodWithLBFGS  The Laplace approximation inference method with LBFGS class for regression and binary classification 
CCSingleSparseInferenceBase  The sparse inference base class for classification and regression for 1D labels (1D regression and binary classification) 
CCSmoothHingeLoss  CSmoothHingeLoss implements the smooth hinge loss function 
CCSNPFeatures  Features that compute the Weighted Degreee Kernel feature space explicitly 
CCSNPStringKernel  The class SNPStringKernel computes a variant of the polynomial kernel on strings of same length 
CCSOBI  Class SOBI 
CCSoftMaxLikelihood  Class that models SoftMax likelihood 
CCSortUlongString  Preprocessor SortUlongString, sorts the indivual strings in ascending order 
CCSortWordString  Preprocessor SortWordString, sorts the indivual strings in ascending order 
CCSOSVMHelper  Class CSOSVMHelper contains helper functions to compute primal objectives, dual objectives, average training losses, duality gaps etc. These values will be recorded to check convergence. This class is inspired by the matlab implementation of the block coordinate FrankWolfe SOSVM solver [1] 
CCSparseDistance  Template class SparseDistance 
CCSparseEuclideanDistance  Class SparseEucldeanDistance 
CCSparseFeatures  Template class SparseFeatures implements sparse matrices 
CCSparseInferenceBase  The Fully Independent Conditional Training inference base class 
CCSparseInverseCovariance  Used to estimate inverse covariance matrix using graphical lasso 
CCSparseKernel  Template class SparseKernel, is the base class of kernels working on sparse features 
CCSparseMatrixOperator  Class that represents a sparsematrix linear operator. It computes matrixvector product \(Ax\) in its apply method, \(A\in\mathbb{C}^{m\times n},A:\mathbb{C}^{n}\rightarrow \mathbb{C}^{m}\) being the matrix operator and \(x\in\mathbb{C}^{n}\) being the vector. The result is a vector \(y\in\mathbb{C}^{m}\) 
CCSparseMultilabel  Class CSparseMultilabel to be used in the application of Structured Output (SO) learning to Multilabel classification 
CCSparsePolyFeatures  Implement DotFeatures for the polynomial kernel 
CCSparsePreprocessor  Template class SparsePreprocessor, base class for preprocessors (cf. CPreprocessor) that apply to CSparseFeatures 
CCSparseSpatialSampleStringKernel  Sparse Spatial Sample String Kernel by Pavel Kuksa pkuks.nosp@m.a@cs.nosp@m..rutg.nosp@m.ers..nosp@m.edu and Vladimir Pavlovic vladi.nosp@m.mir@.nosp@m.cs.ru.nosp@m.tger.nosp@m.s.edu 
CCSparseVGInferenceMethod  The inference method class based on the Titsias' variational bound. For more details, see Titsias, Michalis K. "Variational learning of inducing variables in sparse Gaussian processes." International Conference on Artificial Intelligence and Statistics. 2009 
CCSpecificityMeasure  Class SpecificityMeasure used to measure specificity of 2class classifier 
CCSpectrumMismatchRBFKernel  Spectrum mismatch rbf kernel 
CCSpectrumRBFKernel  Spectrum rbf kernel 
CCSphericalKernel  Spherical kernel 
CCSplineKernel  Computes the Spline Kernel function which is the cubic polynomial 
CCSplittingStrategy  Abstract base class for all splitting types. Takes a CLabels instance and generates a desired number of subsets which are being accessed by their indices via the method generate_subset_indices(...) 
CCSqrtDiagKernelNormalizer  SqrtDiagKernelNormalizer divides by the Square Root of the product of the diagonal elements 
CCSquaredHingeLoss  Class CSquaredHingeLoss implements a squared hinge loss function 
CCSquaredLoss  CSquaredLoss implements the squared loss function 
CCStateModel  Class CStateModel base, abstract class for the internal state representation used in the CHMSVMModel 
►CCStatistics  Class that contains certain functions related to statistics, such as probability/cumulative distribution functions, different statistics, etc 
CSigmoidParamters  
CCStochasticGBMachine  This class implements the stochastic gradient boosting algorithm for ensemble learning invented by Jerome H. Friedman. This class works with a variety of loss functions like squared loss, exponential loss, Huber loss etc which can be accessed through Shogun's CLossFunction interface (cf. http://www.shoguntoolbox.org/doc/en/latest/classshogun_1_1CLossFunction.html). Additionally, it can create an ensemble of any regressor class derived from the CMachine class (cf. http://www.shoguntoolbox.org/doc/en/latest/classshogun_1_1CMachine.html). For one dimensional optimization, this class uses the backtracking linesearch accessed via Shogun's LBFGS class. A concise description of the algorithm implemented can be found in the following link : http://en.wikipedia.org/wiki/Gradient_boosting#Algorithm 
CCStochasticProximityEmbedding  Class StochasticProximityEmbedding used to construct embeddings of data using the Stochastic Proximity algorithm 
CCStochasticSOSVM  Class CStochasticSOSVM solves SOSVM using stochastic subgradient descent on the SVM primal problem [1], which is equivalent to SGD or Pegasos [2]. This class is inspired by the matlab SGD implementation in [3] 
CCStoreScalarAggregator  Template class that aggregates scalar job results in each submit_result call, finalize then transforms current aggregation into a CScalarResult 
CCStoreVectorAggregator  Abstract template class that aggregates vector job results in each submit_result call, finalize is abstract 
CCStratifiedCrossValidationSplitting  Implementation of stratified crossvalidation on the base of CSplittingStrategy. Produces subset index sets of equal size (at most one difference) in which the label ratio is equal (at most one difference) to the label ratio of the specified labels. Do not use for regression since it may be impossible to distribute nice in that case 
CCStreamingAsciiFile  Class StreamingAsciiFile to read vectorbyvector from ASCII files 
CCStreamingDenseFeatures  This class implements streaming features with dense feature vectors 
CCStreamingDotFeatures  Streaming features that support dot products among other operations 
CCStreamingFeatures  Streaming features are features which are used for online algorithms 
CCStreamingFile  A Streaming File access class 
CCStreamingFileFromDenseFeatures  Class CStreamingFileFromDenseFeatures is a derived class of CStreamingFile which creates an input source for the online framework from a CDenseFeatures object 
CCStreamingFileFromFeatures  Class StreamingFileFromFeatures to read vectorbyvector from a CFeatures object 
CCStreamingFileFromSparseFeatures  Class CStreamingFileFromSparseFeatures is derived from CStreamingFile and provides an input source for the online framework. It uses an existing CSparseFeatures object to generate online examples 
CCStreamingFileFromStringFeatures  Class CStreamingFileFromStringFeatures is derived from CStreamingFile and provides an input source for the online framework from a CStringFeatures object 
CCStreamingHashedDenseFeatures  This class acts as an alternative to the CStreamingDenseFeatures class and their difference is that the current example in this class is hashed into a smaller dimension dim 
CCStreamingHashedDocDotFeatures  This class implements streaming features for a document collection. Like in the standard BagofWords representation, this class considers each document as a collection of tokens, which are then hashed into a new feature space of a specified dimension. This class is very flexible and allows the user to specify the tokenizer used to tokenize each document, specify whether the results should be normalized with regards to the sqrt of the document size, as well as to specify whether he wants to combine different tokens. The latter implements a kskip ngrams approach, meaning that you can combine up to n tokens, while skipping up to k. Eg. for the tokens ["a", "b", "c", "d"], with n_grams = 2 and skips = 2, one would get the following combinations : ["a", "ab", "ac" (skipped 1), "ad" (skipped 2), "b", "bc", "bd" (skipped 1), "c", "cd", "d"] 
CCStreamingHashedSparseFeatures  This class acts as an alternative to the CStreamingSparseFeatures class and their difference is that the current example in this class is hashed into a smaller dimension dim 
CCStreamingMMD  Abstract base class that provides an interface for performing kernel twosample test on streaming data using Maximum Mean Discrepancy (MMD) as the test statistic. The MMD is the distance of two probability distributions \(p\) and \(q\) in a RKHS (see [1] for formal description) 
CCStreamingSparseFeatures  This class implements streaming features with sparse feature vectors. The vector is represented as an SGSparseVector<T>. Each entry is of type SGSparseVectorEntry<T> with members `feat_index' and `entry' 
CCStreamingStringFeatures  This class implements streaming features as strings 
CCStreamingVwCacheFile  Class StreamingVwCacheFile to read vectorbyvector from VW cache files 
CCStreamingVwFeatures  This class implements streaming features for use with VW 
CCStreamingVwFile  Class StreamingVwFile to read vectorbyvector from Vowpal Wabbit data files. It reads the example and label into one object of VwExample type 
CCStringDistance  Template class StringDistance 
CCStringFeatures  Template class StringFeatures implements a list of strings 
CCStringFileFeatures  File based string features 
CCStringKernel  Template class StringKernel, is the base class of all String Kernels 
CCStringMap  
CCStringPreprocessor  Template class StringPreprocessor, base class for preprocessors (cf. CPreprocessor) that apply to CStringFeatures (i.e. strings of variable length) 
CCStructuredAccuracy  Class CStructuredAccuracy used to compute accuracy of structured classification 
CCStructuredData  Base class of the components of StructuredLabels 
CCStructuredLabels  Base class of the labels used in Structured Output (SO) problems 
CCStructuredModel  Class CStructuredModel that represents the application specific model and contains most of the application dependent logic to solve structured output (SO) problems. The idea of this class is to be instantiated giving pointers to the functions that are dependent on the application, i.e. the combined feature representation \(\Psi(\bold{x},\bold{y})\) and the argmax function \( {\arg\max} _{\bold{y} \neq \bold{y}_i} \left \langle { \bold{w}, \Psi(\bold{x}_i,\bold{y}) } \right \rangle \). See: MulticlassModel.h and .cpp for an example of these functions implemented 
CCStructuredOutputMachine  
CCStudentsTLikelihood  Class that models a Student'st likelihood 
CCStudentsTVGLikelihood  Class that models Student's T likelihood and uses numerical integration to approximate the following variational expection of log likelihood \[ \sum_{{i=1}^n}{E_{q(f_i{\mu}_i,{\sigma}^2_i)}[logP(y_if_i)]} \] 
CCSubsequenceStringKernel  Class SubsequenceStringKernel that implements String Subsequence Kernel (SSK) discussed by Lodhi et. al.[1]. A subsequence is any ordered sequence of \(n\) characters occurring in the text, though not necessarily contiguous. More formally, string \(u\) is a subsequence of string \(s\), iff there exists indices \(\mathbf{i}=(i_{1},\dots,i_{u})\), with \(1\le i_{1} \le \cdots \le i_{u} \le s\), such that \(u_{j}=s_{i_{j}}\) for \(j=1,\dots,u\), written as \(u=s[\mathbf{i}]\). The feature mapping \(\phi\) in this scenario is given by \[ \phi_{u}(s)=\sum_{\mathbf{i}:u=s[\mathbf{i}]}\lambda^{l(\mathbf{i})} \] for some \(lambda\le 1\), where \(l(\mathbf{i})\) is the length of the subsequence in \(s\), given by \(i_{u}i_{1}+1\). The kernel here is an inner product in the feature space generated by all subsequences of length \(n\). \[ K_{n}(s,t)=\sum_{u\in\Sigma^{n}}\langle \phi_{u}(s), \phi_{u}(t)\rangle = \sum_{u\in\Sigma^{n}}\sum_{\mathbf{i}:u=s[\mathbf{i}]} \sum_{\mathbf{j}:u=t[\mathbf{j}]}\lambda^{l(\mathbf{i})+l(\mathbf{j})} \] Since the subsequences are weighted by the exponentially decaying factor \(\lambda\) of their full length in the text, more weight is given to those occurrences that are nearly contiguous. A direct computation is infeasible since the dimension of the feature space grows exponentially with \(n\). The paper describes an efficient computation approach using a dynamic programming technique 
CCSubset  Wrapper class for an index subset which is used by SubsetStack 
CCSubsetStack  Class to add subset support to another class. A CSubsetStackStack instance should be added and wrapper methods to all interfaces should be added 
CCSumOne  Preprocessor SumOne, normalizes vectors to have sum 1 
CCSVM  A generic Support Vector Machine Interface 
CCSVMLight  Class SVMlight 
CCSVMLightOneClass  Trains a one class C SVM 
CCSVMLin  Class SVMLin 
CCSVMOcas  Class SVMOcas 
CCSVMSGD  Class SVMSGD 
CCSVRLight  Class SVRLight, performs support vector regression using SVMLight 
CCTableFactorType  Class CTableFactorType the way that store assignments of variables and energies in a table or a multiarray 
CCTanimotoDistance  Class Tanimoto coefficient 
CCTanimotoKernelNormalizer  TanimotoKernelNormalizer performs kernel normalization inspired by the Tanimoto coefficient (see http://en.wikipedia.org/wiki/Jaccard_index ) 
CCTask  Class Task used to represent tasks in multitask learning. Essentially it represent a set of feature vector indices 
CCTaskGroup  Class TaskGroup used to represent a group of tasks. Tasks in group do not overlap 
CCTaskRelation  Used to represent tasks in multitask learning 
CCTaskTree  Class TaskTree used to represent a tree of tasks. Tree is constructed via task with subtasks (and subtasks of subtasks ..) passed to the TaskTree 
CCTaxonomy  CTaxonomy is used to describe hierarchical structure between tasks 
CCTDistributedStochasticNeighborEmbedding  Class CTDistributedStochasticNeighborEmbedding used to embed data using tdistributed stochastic neighbor embedding algorithm: http://jmlr.csail.mit.edu/papers/volume9/vandermaaten08a/vandermaaten08a.pdf 
CCTensorProductPairKernel  Computes the Tensor Product Pair Kernel (TPPK) 
CCThresholdRejectionStrategy  Threshold based rejection strategy 
CCTime  Class Time that implements a stopwatch based on either cpu time or wall clock time 
CCTokenizer  The class CTokenizer acts as a base class in order to implement tokenizers. Subclasses must implement the methods has_next(), next_token_idx() and get_copy() 
CCTOPFeatures  The class TOPFeatures implements TOP kernel features obtained from two Hidden Markov models 
CCTraceSampler  Abstract template base class that provides an interface for sampling the trace of a linear operator using an abstract sample method 
CCTreeMachine  Class TreeMachine, a base class for tree based multiclass classifiers. This class is derived from CBaseMulticlassMachine and stores the root node (of class type CTreeMachineNode) to the tree structure 
CCTreeMachineNode  The node of the tree structure forming a TreeMachine The node contains a pointer to its parent and a vector of pointers to its children. A node of this class can have only one parent but any number of children.The node also contains data which can be of any type and has to be specified using template specifier 
CCTrie  Template class Trie implements a suffix trie, i.e. a tree in which all suffixes up to a certain length are stored 
CCTStudentKernel  Generalized TStudent kernel 
CCTwoSampleTest  Provides an interface for performing the classical twosample test i.e. Given samples from two distributions \(p\) and \(q\), the nullhypothesis is: \(H_0: p=q\), the alternative hypothesis: \(H_1: p\neq q\) 
CCTwoStateModel  Class CTwoStateModel class for the internal twostate representation used in the CHMSVMModel 
CCUAIFile  Class UAIFILE used to read data from UAI files. See http://graphmod.ics.uci.edu/uai08/FileFormat for more details 
CCUWedge  Class UWedge 
CCUWedgeSep  Class UWedgeSep 
CCVarianceKernelNormalizer  VarianceKernelNormalizer divides by the ``variance'' 
CCVariationalGaussianLikelihood  The variational Gaussian Likelihood base class. The variational distribution is Gaussian 
CCVariationalLikelihood  The Variational Likelihood base class 
CCVectorResult  Base class that stores the result of an independent job when the result is a vector 
CCVowpalWabbit  Class CVowpalWabbit is the implementation of the online learning algorithm used in Vowpal Wabbit 
CCVwAdaptiveLearner  VwAdaptiveLearner uses an adaptive subgradient technique to update weights 
CCVwCacheReader  Base class from which all cache readers for VW should be derived 
CCVwCacheWriter  CVwCacheWriter is the base class for all VW cache creating classes 
CCVwConditionalProbabilityTree  
CCVwEnvironment  Class CVwEnvironment is the environment used by VW 
CCVwLearner  Base class for all VW learners 
CCVwNativeCacheReader  Class CVwNativeCacheReader reads from a cache exactly as that which has been produced by VW's default cache format 
CCVwNativeCacheWriter  Class CVwNativeCacheWriter writes a cache exactly as that which would be produced by VW's default cache format 
CCVwNonAdaptiveLearner  VwNonAdaptiveLearner uses a standard gradient descent weight update rule 
CCVwParser  CVwParser is the object which provides the functions to parse examples from buffered input 
CCVwRegressor  Regressor used by VW 
CCWaveKernel  Wave kernel 
CCWaveletKernel  Class WaveletKernel 
CCWDFeatures  Features that compute the Weighted Degreee Kernel feature space explicitly 
CCWDSVMOcas  Class WDSVMOcas 
CCWeightedCommWordStringKernel  The WeightedCommWordString kernel may be used to compute the weighted spectrum kernel (i.e. a spectrum kernel for 1 to Kmers, where each kmer length is weighted by some coefficient \(\beta_k\)) from strings that have been mapped into unsigned 16bit integers 
CCWeightedDegreePositionStringKernel  The Weighted Degree Position String kernel (Weighted Degree kernel with shifts) 
CCWeightedDegreeRBFKernel  Weighted degree RBF kernel 
CCWeightedDegreeStringKernel  The Weighted Degree String kernel 
CCWeightedMajorityVote  Weighted Majority Vote implementation 
CCWRACCMeasure  Class WRACCMeasure used to measure weighted relative accuracy of 2class classifier 
CCZeroMean  The zero mean function class 
CCZeroMeanCenterKernelNormalizer  ZeroMeanCenterKernelNormalizer centers the kernel in feature space 
CDescendCorrection  This is a base class for descend based correction method 
CDescendUpdater  This is a base class for descend update 
CDescendUpdaterWithCorrection  This is a base class for descend update with descend based correction 
CDynArray  Template Dynamic array class that creates an array that can be used like a list or an array 
CEigenSparseUtil  This class contains some utilities for Eigen3 Sparse Matrix integration with shogun. Currently it provides a method for converting SGSparseMatrix to Eigen3 SparseMatrix 
CElasticNetPenalty  The is the base class for ElasticNet penalty/regularization within the FirstOrderMinimizer framework 
CFirstOrderBoundConstraintsCostFunction  The first order cost function base class with bound constrains 
CFirstOrderCostFunction  The first order cost function base class 
CFirstOrderMinimizer  The first order minimizer base class 
CFirstOrderSAGCostFunction  The class is about a stochastic cost function for stochastic average minimizers 
CFirstOrderStochasticCostFunction  The first order stochastic cost function base class 
CFirstOrderStochasticMinimizer  The base class for stochastic firstorder gradientbased minimizers 
CGCEdge  Graph cuts edge 
CGCNode  Graph cuts node 
CGCNodePtr  Graph guts node pointer 
CGradientDescendUpdater  The class implements the gradient descend method 
CICP_stats  
Cid3TreeNodeData  Structure to store data of a node of id3 tree. This can be used as a template type in TreeMachineNode class. Ex: id3 algorithm uses nodes of type CTreeMachineNode<id3TreeNodeData> 
CInverseScalingLearningRate  The implements the inverse scaling learning rate 
CIterativeSolverIterator  Template class that is used as an iterator for an iterative linear solver. In the iteration of solving phase, each solver initializes the iteration with a maximum number of iteration limit, and relative/ absolute tolerence. They then call begin with the residual vector and continue until its end returns true, i.e. either it has converged or iteration count reached maximum limit 
CK_THREAD_PARAM  
CL1Penalty  The is the base class for L1 penalty/regularization within the FirstOrderMinimizer framework 
CL1PenaltyForTG  The is the base class for L1 penalty/regularization within the FirstOrderMinimizer framework 
CL2Penalty  The class implements L2 penalty/regularization within the FirstOrderMinimizer framework 
Clbfgs_parameter_t  
CLBFGSMinimizer  The class wraps the Shogun's Cstyle LBFGS minimizer 
CLearningRate  The base class about learning rate for descentbased minimizers 
Cline_search_res  
CMappedSparseMatrix  Mapped sparse matrix for representing graph relations of tasks 
CMappingFunction  The base mapping function for mirror descend 
CMaybe  
CMixModelData  This structure is used for storing data required for using the generic Expectation Maximization (EM) implemented by the template class CEMBase for mixture models like gaussian mixture model, multinomial mixture model etc. The EM specialized for mixture models is implemented by the class CEMMixtureModel which uses this MixModelData structure 
CMKLMulticlassGLPK  MKLMulticlassGLPK is a helper class for MKLMulticlass 
CMKLMulticlassGradient  MKLMulticlassGradient is a helper class for MKLMulticlass 
CMKLMulticlassOptimizationBase  MKLMulticlassOptimizationBase is a helper class for MKLMulticlass 
CModel  Class Model 
CMomentumCorrection  This is a base class for momentum correction methods 
CMunkres  Munkres 
CNbodyTreeNodeData  Structure to store data of a node of NBody tree. This can be used as a template type in TreeMachineNode class. NBody tree building algorithm uses nodes of type CBinaryTreeMachineNode<NbodyTreeNodeData> 
CNesterovMomentumCorrection  This implements the Nesterov's Accelerated Gradient (NAG) correction 
CNLOPTMinimizer  
CNothing  
CParallel  Class Parallel provides helper functions for multithreading 
CParameter  Parameter class 
CParameterMap  Implements a map of ParameterMapElement instances Maps one key to a set of values 
CParameterMapElement  Class to hold instances of a parameter map. Each element contains a key and a set of values, which each are of type SGParamInfo. May be compared to each other based on their keys 
CPenalty  The base class for penalty/regularization used in minimization 
CPNormMappingFunction  This implements the Pnorm mapping function 
CProximalPenalty  The base class for sparse penalty/regularization used in minimization 
CRefCount  
CRelaxedTreeNodeData  
CRelaxedTreeUtil  
CRmsPropUpdater  The class implements the RmsProp method 
CSerializableAsciiReader00  Serializable ascii reader 
CSGDMinimizer  The class implements the stochastic gradient descend (SGD) minimizer 
CSGIO  Class SGIO, used to do input output operations throughout shogun 
CSGMatrix  Shogun matrix 
CSGMatrixList  Shogun matrix list 
CSGNDArray  Shogun ndimensional array 
CSGParamInfo  Class that holds informations about a certain parameter of an CSGObject. Contains name, type, etc. This is used for mapping types that have changed in different versions of shogun. Instances of this class may be compared to each other. Ordering is based on name, equalness is based on all attributes 
CSGReferencedData  Shogun reference count managed data 
CSGSparseMatrix  Template class SGSparseMatrix 
CSGSparseVector  Template class SGSparseVector The assumtion is that the stored SGSparseVectorEntry<T>* vector is ordered by SGSparseVectorEntry.feat_index in nondecreasing order. This has to be assured by the user of the class 
CSGSparseVectorEntry  Template class SGSparseVectorEntry 
CSGString  Shogun string 
CSGStringList  Template class SGStringList 
CSGVector  Shogun vector 
CShareBoostOptimizer  
CShogunException  Class ShogunException defines an exception which is thrown whenever an error inside of shogun occurs 
CSMDMinimizer  The class implements the stochastic mirror descend (SMD) minimizer 
CSMIDASMinimizer  The class implements the stochastic mirror descend (SMD) minimizer 
CSparsePenalty  The base class for sparse penalty/regularization used in minimization 
CSparsityStructure  Struct that represents the sparsity structure of the Sparse Matrix in CRS. Implementation has been adapted from Krylstat (https://github.com/ Froskekongen/KRYLSTAT) library (c) Erlend Aune erlen.nosp@m.da@m.nosp@m.ath.n.nosp@m.tnu..nosp@m.no under GPL2+ 
CSSKFeatures  SSKFeatures 
CStandardMomentumCorrection  This implements the plain momentum correction 
Csubstring  Struct Substring, specified by start position and end position 
CSVRGMinimizer  The class implements the stochastic variance reduced gradient (SVRG) minimizer 
Ctag_callback_data  
Ctag_iteration_data  
CTMultipleCPinfo  
CTParameter  Parameter struct 
CTSGDataType  Datatypes that shogun supports 
CUnique  
Cv_array  Class v_array taken directly from JL's implementation 
CVersion  Class Version provides version information 
CVwConditionalProbabilityTreeNodeData  
CVwExample  Example class for VW 
CVwFeature  One feature in VW 
CVwLabel  Class VwLabel holds a label object used by VW 
Cblock_tree_node_t  
CCSyntaxHighLight  Syntax highlight 
CCTron  Class Tron 
Cd_node  
CD_THREAD_PARAM  
Cds_node  
CEntryComparator  
CHolder  
Cmocas_data  
Cnode  
CShogunFeatureVectorCallback  
CShogunLoggerImplementation  
Ctask_tree_node_t  
Ctree_node_t 