Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 1234567]

_IterInfo	Struct that contains current state of the iteration for iterative linear solvers
block_tree_node_t
bmrm_ll
BmrmStatistics
CDynInt< T, sz >	Integer type of dynamic size
CECOCUtil
CIndirectObject< T, P >	Array class that accesses elements indirectly via an index array
CJLCoverTreePoint	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
class
class
class
CLock	Class Lock used for synchronization in concurrent programs
CLoss	Class which collects generic mathematical functions
ConditionalProbabilityTreeNodeData	Struct to store data of node of conditional probability tree
CSGObject	Class SGObject is the base class of all shogun objects
CCache< float64_t >
CLinearOperator< float64_t >
CLinearSolver< complex128_t, float64_t >
CIterativeLinearSolver< complex128_t, float64_t >
CConjugateOrthogonalCGSolver	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
CDirectLinearSolverComplex	Class that provides a solve method for complex dense-matrix linear systems
CLinearSolver< float64_t, float64_t >
CIterativeLinearSolver< float64_t, float64_t >
CIterativeShiftedLinearFamilySolver< float64_t, complex128_t >
CCGMShiftedFamilySolver	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
CConjugateGradientSolver	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 positive-definite matrices
CDirectSparseLinearSolver	Class that provides a solve method for real sparse-matrix linear systems using LLT
CLinearSolver< T, T >
CIterativeLinearSolver< T, T >
CIterativeShiftedLinearFamilySolver< T, ST >	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 matrix-vector 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\)
COperatorFunction< float64_t >
CDenseMatrixExactLog	Class that generates jobs for computing logarithm of a dense matrix linear operator
CRationalApproximation	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}\)
CLogRationalApproximationCGM	Implementaion of rational approximation of a operator-function 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 linear-family solver by the computation engine. generate_jobs generates one job per sample
CLogRationalApproximationIndividual	Implementaion of rational approximation of a operator-function times vector where the operator function is log of a dense-matrix. 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
CTreeMachineNode< ConditionalProbabilityTreeNodeData >
CTreeMachineNode< RelaxedTreeNodeData >
CTreeMachineNode< VwConditionalProbabilityTreeNodeData >
CAlphabet	The class Alphabet implements an alphabet and alphabet utility functions
CApproxJointDiagonalizer	Class ApproxJointDiagonalizer defines an Approximate Joint Diagonalizer (AJD) interface
CFFDiag	Class FFDiag
CJADiag	Class JADiag
CJADiagOrth	Class JADiagOrth
CJediDiag	Class Jedi
CQDiag	Class QDiag
CUWedge	Class UWedge
CBinaryStream< T >	Memory mapped emulation via binary streams (files)
CBitString	String class embedding a string in a compact bit representation
CCache< T >	Template class Cache implements a simple cache
CCircularBuffer	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
CCombinationRule	CombinationRule abstract class The CombinationRule defines an interface to how to combine the classification or regression outputs of an ensemble of Machines
CMeanRule	CMeanRule simply averages the outputs of the Machines in the ensemble
CWeightedMajorityVote	Weighted Majority Vote implementation
CMajorityVote	CMajorityVote is a CWeightedMajorityVote combiner, where each Machine's weight in the ensemble is 1.0
CCompressor	Compression library for compressing and decompressing buffers using one of the standard compression algorithms:
CConverter	Class Converter used to convert data
CEmbeddingConverter	Class EmbeddingConverter (part of the Efficient Dimensionality Reduction Toolkit) used to construct embeddings of features, e.g. construct dense numeric embedding of string features
CDiffusionMaps	Class DiffusionMaps used to preprocess given data using Diffusion Maps dimensionality reduction technique as described in
CFactorAnalysis
CLaplacianEigenmaps	Class LaplacianEigenmaps used to construct embeddings of data using Laplacian Eigenmaps algorithm as described in:
CLocalityPreservingProjections	Class LocalityPreservingProjections used to compute embeddings of data using Locality Preserving Projections method as described in
CLocallyLinearEmbedding	Class LocallyLinearEmbedding used to embed data using Locally Linear Embedding algorithm described in
CHessianLocallyLinearEmbedding	Class HessianLocallyLinearEmbedding used to preprocess data using Hessian Locally Linear Embedding algorithm as described in
CKernelLocallyLinearEmbedding	Class KernelLocallyLinearEmbedding used to construct embeddings of data using kernel formulation of Locally Linear Embedding algorithm as described in
CLocalTangentSpaceAlignment	Class LocalTangentSpaceAlignment used to embed data using Local Tangent Space Alignment (LTSA) algorithm as described in:
CLinearLocalTangentSpaceAlignment	Class LinearLocalTangentSpaceAlignment converter used to construct embeddings as described in:
CNeighborhoodPreservingEmbedding	NeighborhoodPreservingEmbedding converter used to construct embeddings as described in:
CManifoldSculpting
CMultidimensionalScaling	Class Multidimensionalscaling is used to perform multidimensional scaling (capable of landmark approximation if requested)
CIsomap	Class Isomap used to embed data using Isomap algorithm as described in
CStochasticProximityEmbedding	Class StochasticProximityEmbedding used to construct embeddings of data using the Stochastic Proximity algorithm
CTDistributedStochasticNeighborEmbedding
CHashedDocConverter	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 Bag-of-Words representation. Like in the standard Bag-of-Words 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 k-skip n-grams 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"]
CICAConverter	Class ICAConverter Base class for ICA algorithms
CFastICA	Class FastICA
CFFSep	Class FFSep
CJade	Class Jade
CJediSep	Class JediSep
CSOBI	Class SOBI
CUWedgeSep	Class UWedgeSep
CCplex	Class CCplex to encapsulate access to the commercial cplex general purpose optimizer
CCrossValidationOutput	Class for managing individual folds in cross-validation
CCrossValidationMKLStorage	Class for storing MKL weights in every fold of cross-validation
CCrossValidationMulticlassStorage	Class for storing multiclass evaluation information in every fold of cross-validation
CCrossValidationPrintOutput	Class for outputting cross-validation intermediate results to the standard output. Simply prints all messages it gets
CData	Dummy data holder
CDataGenerator	Class that is able to generate various data samples, which may be used for examples in SHOGUN
CDifferentiableFunction	An abstract class that describes a differentiable function used for GradientEvaluation
CInferenceMethod	The Inference Method base class
CEPInferenceMethod	Class of the Expectation Propagation (EP) posterior approximation inference method
CExactInferenceMethod	The Gaussian exact form inference method class
CFITCInferenceMethod	The Fully Independent Conditional Training inference method class
CLaplacianInferenceMethod	The Laplace approximation inference method class
CDisjointSet	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/Disjoint-set_data_structure
CDistance	Class Distance, a base class for all the distances used in the Shogun toolbox
CDenseDistance< float64_t >
CBrayCurtisDistance	Class Bray-Curtis distance
CCanberraMetric	Class CanberraMetric
CChebyshewMetric	Class ChebyshewMetric
CChiSquareDistance	Class ChiSquareDistance
CCosineDistance	Class CosineDistance
CGeodesicMetric	Class GeodesicMetric
CJensenMetric	Class JensenMetric
CManhattanMetric	Class ManhattanMetric
CMinkowskiMetric	Class MinkowskiMetric
CRealDistance	Class RealDistance
CAttenuatedEuclideanDistance	Class AttenuatedEuclideanDistance
CCustomMahalanobisDistance	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
CEuclideanDistance	Class EuclideanDistance
CMahalanobisDistance	Class MahalanobisDistance
CTanimotoDistance	Class Tanimoto coefficient
CSparseDistance< float64_t >
CSparseEuclideanDistance	Class SparseEucldeanDistance
CStringDistance< uint16_t >
CCanberraWordDistance	Class CanberraWordDistance
CHammingWordDistance	Class HammingWordDistance
CManhattanWordDistance	Class ManhattanWordDistance
CCustomDistance	The Custom Distance allows for custom user provided distance matrices
CDenseDistance< ST >	Template class DenseDistance
CKernelDistance	The Kernel distance takes a distance as input
CSparseDistance< ST >	Template class SparseDistance
CStringDistance< ST >	Template class StringDistance
CDistribution	Base class Distribution from which all methods implementing a distribution are derived
CGaussian	Gaussian distribution interface
CGHMM	Class GHMM - this class is non-functional and was meant to implement a Generalize Hidden Markov Model (aka Semi Hidden Markov HMM)
CGMM	Gaussian Mixture Model interface
CHistogram	Class Histogram computes a histogram over all 16bit unsigned integers in the features
CHMM	Hidden Markov Model
CLinearHMM	The class LinearHMM is for learning Higher Order Markov chains
CPositionalPWM	Positional PWM
CDynamicArray< T >	Template Dynamic array class that creates an array that can be used like a list or an array
CDynamicObjectArray	Dynamic array class for CSGObject pointers that creates an array that can be used like a list or an array
CDynProg	Dynamic Programming Class
CECOCDecoder
CECOCIHDDecoder
CECOCSimpleDecoder
CECOCAEDDecoder
CECOCEDDecoder
CECOCHDDecoder
CECOCLLBDecoder
CECOCEncoder	ECOCEncoder produce an ECOC codebook
CECOCDiscriminantEncoder
CECOCForestEncoder
CECOCOVOEncoder
CECOCOVREncoder
CECOCRandomDenseEncoder
CECOCRandomSparseEncoder
CEigenSolver	Abstract base class that provides an abstract compute method for computing eigenvalues of a real valued, self-adjoint linear operator. It also provides method for getting min and max eigenvalues
CDirectEigenSolver	Class that computes eigenvalues of a real valued, self-adjoint dense matrix linear operator using Eigen3
CLanczosEigenSolver	Class that computes eigenvalues of a real valued, self-adjoint linear operator using Lanczos algorithm
CEvaluation	Class Evaluation, a base class for other classes used to evaluate labels, e.g. accuracy of classification or mean squared error of regression
CBinaryClassEvaluation	The class TwoClassEvaluation, a base class used to evaluate binary classification labels
CContingencyTableEvaluation	The class ContingencyTableEvaluation a base class used to evaluate 2-class classification with TP, FP, TN, FN rates
CAccuracyMeasure	Class AccuracyMeasure used to measure accuracy of 2-class classifier
CBALMeasure	Class BALMeasure used to measure balanced error of 2-class classifier
CCrossCorrelationMeasure	Class CrossCorrelationMeasure used to measure cross correlation coefficient of 2-class classifier
CErrorRateMeasure	Class ErrorRateMeasure used to measure error rate of 2-class classifier
CF1Measure	Class F1Measure used to measure F1 score of 2-class classifier
CPrecisionMeasure	Class PrecisionMeasure used to measure precision of 2-class classifier
CRecallMeasure	Class RecallMeasure used to measure recall of 2-class classifier
CSpecificityMeasure	Class SpecificityMeasure used to measure specificity of 2-class classifier
CWRACCMeasure	Class WRACCMeasure used to measure weighted relative accuracy of 2-class classifier
CPRCEvaluation	Class PRCEvaluation used to evaluate PRC (Precision Recall Curve) and an area under PRC curve (auPRC)
CROCEvaluation	Class ROCEvalution used to evaluate ROC (Receiver Operating Characteristic) and an area under ROC curve (auROC)
CMultitaskROCEvaluation	Class MultitaskROCEvalution used to evaluate ROC (Receiver Operating Characteristic) and an area under ROC curve (auROC) of each task separately
CClusteringEvaluation	The base class used to evaluate clustering
CClusteringAccuracy	Clustering accuracy
CClusteringMutualInformation	Clustering (normalized) mutual information
CGradientCriterion	Simple class which specifies the direction of gradient search
CMeanAbsoluteError	Class MeanAbsoluteError used to compute an error of regression model
CMeanSquaredError	Class MeanSquaredError used to compute an error of regression model
CMeanSquaredLogError	Class CMeanSquaredLogError used to compute an error of regression model
CMulticlassAccuracy	The class MulticlassAccuracy used to compute accuracy of multiclass classification
CMulticlassOVREvaluation	The class MulticlassOVREvaluation used to compute evaluation parameters of multiclass classification via binary OvR decomposition and given binary evaluation technique
CStructuredAccuracy	Class CStructuredAccuracy used to compute accuracy of structured classification
CEvaluationResult	Abstract class that contains the result generated by the MachineEvaluation class
CCrossValidationResult	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
CGradientResult	Container class that returns results from GradientEvaluation. It contains the function value as well as its gradient
CFactor	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
CFactorDataSource	Class CFactorDataSource Source for factor data. In some cases, the same data can be shared by many factors
CFactorGraph	Class CFactorGraph a factor graph is a structured input in general
CFactorType	Class CFactorType defines the way of factor parameterization
CTableFactorType	Class CTableFactorType the way that store assignments of variables and energies in a table or a multi-array
CFeatures	The class Features is the base class of all feature objects
CAttributeFeatures	Implements attributed features, that is in the simplest case a number of (attribute, value) pairs
CCombinedFeatures	The class CombinedFeatures is used to combine a number of of feature objects into a single CombinedFeatures object
CDotFeatures	Features that support dot products among other operations
CDenseFeatures< float64_t >
CFKFeatures	The class FKFeatures implements Fischer kernel features obtained from two Hidden Markov models
CRealFileFeatures	The class RealFileFeatures implements a dense double-precision floating point matrix from a file
CTOPFeatures	The class TOPFeatures implements TOP kernel features obtained from two Hidden Markov models
CBinnedDotFeatures	The class BinnedDotFeatures contains a 0-1 conversion of features into bins
CCombinedDotFeatures	Features that allow stacking of a number of DotFeatures
CDenseFeatures< ST >	The class DenseFeatures implements dense feature matrices
CDenseSubsetFeatures< ST >
CExplicitSpecFeatures	Features that compute the Spectrum Kernel feature space explicitly
CHashedDenseFeatures< ST >	This class is identical to the CDenseFeatures class except that it hashes each dimension to a new feature space
CHashedDocDotFeatures	This class can be used to provide on-the-fly vectorization of a document collection. Like in the standard Bag-of-Words 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 k-skip n-grams 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"]
CHashedSparseFeatures< ST >	This class is identical to the CDenseFeatures class except that it hashes each dimension to a new feature space
CHashedWDFeatures	Features that compute the Weighted Degreee Kernel feature space explicitly
CHashedWDFeaturesTransposed	Features that compute the Weighted Degreee Kernel feature space explicitly
CImplicitWeightedSpecFeatures	Features that compute the Weighted Spectrum Kernel feature space explicitly
CLBPPyrDotFeatures	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
CPolyFeatures	Implement DotFeatures for the polynomial kernel
CRandomKitchenSinksDotFeatures	Class that implements the Random Kitchen Sinks for the DotFeatures as mentioned in http://books.nips.cc/papers/files/nips21/NIPS2008_0885.pdf
CRandomFourierDotFeatures	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
CSNPFeatures	Features that compute the Weighted Degreee Kernel feature space explicitly
CSparseFeatures< ST >	Template class SparseFeatures implements sparse matrices
CSparsePolyFeatures	Implement DotFeatures for the polynomial kernel
CWDFeatures	Features that compute the Weighted Degreee Kernel feature space explicitly
CDummyFeatures	The class DummyFeatures implements features that only know the number of feature objects (but don't actually contain any)
CFactorGraphFeatures	CFactorGraphFeatures maintains an array of factor graphs, each graph is a sample, i.e. an instance of structured input
CLatentFeatures	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 (user-defined) form based on CData
CMatrixFeatures< ST >	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)
CStreamingFeatures	Streaming features are features which are used for online algorithms
CStreamingDotFeatures	Streaming features that support dot products among other operations
CStreamingDenseFeatures< float64_t >
CGaussianBlobsDataGenerator
CMeanShiftDataGenerator
CStreamingDenseFeatures< T >	This class implements streaming features with dense feature vectors
CStreamingHashedDenseFeatures< ST >	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
CStreamingHashedDocDotFeatures	This class implements streaming features for a document collection. Like in the standard Bag-of-Words 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 k-skip n-grams 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"]
CStreamingHashedSparseFeatures< ST >	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
CStreamingSparseFeatures< T >	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'
CStreamingVwFeatures	This class implements streaming features for use with VW
CStreamingStringFeatures< T >	This class implements streaming features as strings
CStringFeatures< ST >	Template class StringFeatures implements a list of strings
CStringFileFeatures< ST >	File based string features
CFile	A File access base class
CBinaryFile	A Binary file access class
CCSVFile	Class CSVFile used to read data from comma-separated values (CSV) files. See http://en.wikipedia.org/wiki/Comma-separated_values
CLibSVMFile	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
CFunction	Class of a function of one variable
CGCArray< T >	Template class GCArray implements a garbage collecting static array
CGMNPLib	Class GMNPLib Library of solvers for Generalized Minimal Norm Problem (GMNP)
CGNPPLib	Class GNPPLib, a Library of solvers for Generalized Nearest Point Problem (GNPP)
CGUIClassifier	UI classifier
CGUIConverter	UI converter
CGUIDistance	UI distance
CGUIFeatures	UI features
CGUIHMM	UI HMM (Hidden Markov Model)
CGUIKernel	UI kernel
CGUILabels	UI labels
CGUIMath	UI math
CGUIPluginEstimate	UI estimate
CGUIPreprocessor	UI preprocessor
CGUIStructure	UI structure
CGUITime	UI time
CHash	Collection of Hashing Functions
CIndependentComputationEngine	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
CSerialComputationEngine	Class that computes multiple independent instances of computation jobs sequentially
CIndependentJob	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
CDenseExactLogJob	Class that represents the job of applying the log of a CDenseMatrixOperator on a real vector
CRationalApproximationCGMJob	Implementation of independent jobs that solves one whole family of shifted systems in rational approximation of linear operator function times a vector using CG-M linear solver. compute calls submit_results of the aggregator with CScalarResult (see CRationalApproximation)
CRationalApproximationIndividualJob	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)
CIndexBlock	Class IndexBlock used to represent contiguous indices of one group (e.g. block of related features)
CIndexBlockRelation	Class IndexBlockRelation
CIndexBlockGroup	Class IndexBlockGroup used to represent group-based feature relation
CIndexBlockTree	Class IndexBlockTree used to represent tree guided feature relation
CIntegration	Class that contains certain methods related to numerical integration
CIntronList	Class IntronList
CIOBuffer	An I/O buffer class
CJacobiEllipticFunctions	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{(1-t^{2})(1-m^{2}t^{2})}} =\int_{0}^{\varphi}\frac{d\theta}{\sqrt{(1-m^{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{1-sn(u,m)^{2}}\) and \(dn(u,m)=\sqrt{1-m^{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{1-m^{2}}\) is called the complementary complete elliptic integral of first kind. Jacobi functions are double periodic with quardratic periods \(K\) and \(K'\)
CJobResult	Base class that stores the result of an independent job
CScalarResult< T >	Base class that stores the result of an independent job when the result is a scalar
CVectorResult< T >	Base class that stores the result of an independent job when the result is a vector
CJobResultAggregator	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
CStoreVectorAggregator< complex128_t >
CIndividualJobResultAggregator	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
CStoreScalarAggregator< T >	Template class that aggregates scalar job results in each submit_result call, finalize then transforms current aggregation into a CScalarResult
CStoreVectorAggregator< T >	Abstract template class that aggregates vector job results in each submit_result call, finalize is abstract
CKernel	The Kernel base class
CStringKernel< char >
CDistantSegmentsKernel	The distant segments kernel is a string kernel, which counts the number of substrings, so-called segments, at a certain distance from each other
CFixedDegreeStringKernel	The FixedDegree String kernel takes as input two strings of same size and counts the number of matches of length d
CGaussianMatchStringKernel	The class GaussianMatchStringKernel computes a variant of the Gaussian kernel on strings of same length
CLinearStringKernel	Computes the standard linear kernel on dense char valued features
CLocalAlignmentStringKernel	The LocalAlignmentString kernel compares two sequences through all possible local alignments between the two sequences
CLocalityImprovedStringKernel	The LocalityImprovedString kernel is inspired by the polynomial kernel. Comparing neighboring characters it puts emphasize on local features
COligoStringKernel	This class offers access to the Oligo Kernel introduced by Meinicke et al. in 2004
CPolyMatchStringKernel	The class PolyMatchStringKernel computes a variant of the polynomial kernel on strings of same length
CRegulatoryModulesStringKernel	The Regulaty Modules kernel, based on the WD kernel, as published in Schultheiss et al., Bioinformatics (2009) on regulatory sequences
CSimpleLocalityImprovedStringKernel	SimpleLocalityImprovedString kernel, is a ``simplified'' and better performing version of the Locality improved kernel
CSNPStringKernel	The class SNPStringKernel computes a variant of the polynomial kernel on strings of same length
CSparseSpatialSampleStringKernel	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
CSpectrumMismatchRBFKernel	Spectrum mismatch rbf kernel
CSpectrumRBFKernel	Spectrum rbf kernel
CWeightedDegreePositionStringKernel	The Weighted Degree Position String kernel (Weighted Degree kernel with shifts)
CWeightedDegreeStringKernel	The Weighted Degree String kernel
CStringKernel< uint16_t >
CCommWordStringKernel	The CommWordString kernel may be used to compute the spectrum kernel from strings that have been mapped into unsigned 16bit integers
CWeightedCommWordStringKernel	The WeightedCommWordString kernel may be used to compute the weighted spectrum kernel (i.e. a spectrum kernel for 1 to K-mers, where each k-mer length is weighted by some coefficient \(\beta_k\)) from strings that have been mapped into unsigned 16bit integers
CHistogramWordStringKernel	The HistogramWordString computes the TOP kernel on inhomogeneous Markov Chains
CMatchWordStringKernel	The class MatchWordStringKernel computes a variant of the polynomial kernel on strings of same length converted to a word alphabet
CPolyMatchWordStringKernel	The class PolyMatchWordStringKernel computes a variant of the polynomial kernel on word-features
CSalzbergWordStringKernel	The SalzbergWordString kernel implements the Salzberg kernel
CStringKernel< uint64_t >
CCommUlongStringKernel	The CommUlongString kernel may be used to compute the spectrum kernel from strings that have been mapped into unsigned 64bit integers
CCauchyKernel	Cauchy kernel
CCircularKernel	Circular kernel
CCombinedKernel	The Combined kernel is used to combine a number of kernels into a single CombinedKernel object by linear combination
CConstKernel	The Constant Kernel returns a constant for all elements
CCustomKernel	The Custom Kernel allows for custom user provided kernel matrices
CDiagKernel	The Diagonal Kernel returns a constant for the diagonal and zero otherwise
CDistanceKernel	The Distance kernel takes a distance as input
CBesselKernel	Class Bessel kernel
CDotKernel	Template class DotKernel is the base class for kernels working on DotFeatures
CANOVAKernel	ANOVA (ANalysis Of VAriances) kernel
CAUCKernel	The AUC kernel can be used to maximize the area under the receiver operator characteristic curve (AUC) instead of margin in SVM training
CChi2Kernel	The Chi2 kernel operating on realvalued vectors computes the chi-squared distance between sets of histograms
CExponentialKernel	The Exponential Kernel, closely related to the Gaussian Kernel computed on CDotFeatures
CGaussianKernel	The well known Gaussian kernel (swiss army knife for SVMs) computed on CDotFeatures
CGaussianShiftKernel	An experimental kernel inspired by the WeightedDegreePositionStringKernel and the Gaussian kernel
CGaussianShortRealKernel	The well known Gaussian kernel (swiss army knife for SVMs) on dense short-real valued features
CHistogramIntersectionKernel	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
CJensenShannonKernel	The Jensen-Shannon kernel operating on real-valued vectors computes the Jensen-Shannon distance between the features. Often used in computer vision
CLinearARDKernel	Linear Kernel with Automatic Relevance Detection
CGaussianARDKernel	Gaussian Kernel with Automatic Relevance Detection
CLinearKernel	Computes the standard linear kernel on CDotFeatures
CPolyKernel	Computes the standard polynomial kernel on CDotFeatures
CPyramidChi2	Pyramid Kernel over Chi2 matched histograms
CSigmoidKernel	The standard Sigmoid kernel computed on dense real valued features
CSplineKernel	Computes the Spline Kernel function which is the cubic polynomial
CTensorProductPairKernel	Computes the Tensor Product Pair Kernel (TPPK)
CWaveletKernel	Class WaveletKernel
CWeightedDegreeRBFKernel	Weighted degree RBF kernel
CInverseMultiQuadricKernel	InverseMultiQuadricKernel
CLogKernel	Log kernel
CMultiquadricKernel	MultiquadricKernel
CPowerKernel	Power kernel
CProductKernel	The Product kernel is used to combine a number of kernels into a single ProductKernel object by element multiplication
CRationalQuadraticKernel	Rational Quadratic kernel
CSparseKernel< ST >	Template class SparseKernel, is the base class of kernels working on sparse features
CSphericalKernel	Spherical kernel
CStringKernel< ST >	Template class StringKernel, is the base class of all String Kernels
CTStudentKernel	Generalized T-Student kernel
CWaveKernel	Wave kernel
CKernelMeanMatching	Kernel Mean Matching
CKernelNormalizer	The class Kernel Normalizer defines a function to post-process kernel values
CAvgDiagKernelNormalizer	Normalize the kernel by either a constant or the average value of the diagonal elements (depending on argument c of the constructor)
CDiceKernelNormalizer	DiceKernelNormalizer performs kernel normalization inspired by the Dice coefficient (see http://en.wikipedia.org/wiki/Dice's_coefficient)
CFirstElementKernelNormalizer	Normalize the kernel by a constant obtained from the first element of the kernel matrix, i.e. \( c=k({\bf x},{\bf x})\)
CIdentityKernelNormalizer	Identity Kernel Normalization, i.e. no normalization is applied
CMultitaskKernelMaskNormalizer	The MultitaskKernel allows Multitask Learning via a modified kernel function
CMultitaskKernelMaskPairNormalizer	The MultitaskKernel allows Multitask Learning via a modified kernel function
CMultitaskKernelMklNormalizer	Base-class for parameterized Kernel Normalizers
CMultitaskKernelPlifNormalizer	The MultitaskKernel allows learning a piece-wise linear function (PLIF) via MKL
CMultitaskKernelTreeNormalizer	The MultitaskKernel allows Multitask Learning via a modified kernel function based on taxonomy
CMultitaskKernelNormalizer	The MultitaskKernel allows Multitask Learning via a modified kernel function
CRidgeKernelNormalizer	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)
CScatterKernelNormalizer	Scatter kernel normalizer
CSqrtDiagKernelNormalizer	SqrtDiagKernelNormalizer divides by the Square Root of the product of the diagonal elements
CTanimotoKernelNormalizer	TanimotoKernelNormalizer performs kernel normalization inspired by the Tanimoto coefficient (see http://en.wikipedia.org/wiki/Jaccard_index )
CVarianceKernelNormalizer	VarianceKernelNormalizer divides by the ``variance''
CZeroMeanCenterKernelNormalizer	ZeroMeanCenterKernelNormalizer centers the kernel in feature space
CLabels	The class Labels models labels, i.e. class assignments of objects
CDenseLabels	Dense integer or floating point labels
CBinaryLabels	Binary Labels for binary classification
CMulticlassLabels	Multiclass Labels for multi-class classification
CRegressionLabels	Real Labels are real-valued labels
CLatentLabels	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
CMulticlassMultipleOutputLabels	Multiclass Labels for multi-class classification with multiple labels
CStructuredLabels	Base class of the labels used in Structured Output (SO) problems
CFactorGraphLabels	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
CMulticlassSOLabels	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_classes-1}. Each label is of type CRealNumber and all of them are stored in a CDynamicObjectArray
CSequenceLabels	Class CSequenceLabels used e.g. in the application of Structured Output (SO) learning to Hidden Markov Support Vector Machines (HM-SVM). 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
CLabelsFactory	The helper class to specialize base class instances of labels
CLatentModel	Abstract class CLatentModel It represents the application specific model and contains most of the application dependent logic to solve latent variable based problems
CLikelihoodModel	The Likelihood model base class
CGaussianLikelihood	Class that models Gaussian likelihood
CLogitLikelihood	Class that models Logit likelihood
CProbitLikelihood	Class that models Probit likelihood
CStudentsTLikelihood	Class that models a Student's-t likelihood
CLinearOperator< T >	Abstract template base class that represents a linear operator, e.g. a matrix
CMatrixOperator< T >	Abstract base class that represents a matrix linear operator. It provides an interface to computes matrix-vector 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}\)
CDenseMatrixOperator< T >	Class that represents a dense-matrix linear operator. It computes matrix-vector 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}\)
CSparseMatrixOperator< T >	Class that represents a sparse-matrix linear operator. It computes matrix-vector 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}\)
CLinearSolver< T, ST >	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\)
CIterativeLinearSolver< T, ST >	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
CLineReader	Class for buffered reading from a ascii file
CList	Class List implements a doubly connected list for low-level-objects
CListElement	Class ListElement, defines how an element of the the list looks like
CLMNN	Class LMNN that implements the distance metric learning technique Large Margin Nearest Neighbour (LMNN) described in
CLMNNStatistics	Class LMNNStatistics used to give access to intermediate results obtained training LMNN
CLogDetEstimator	Class to create unbiased estimators of \(log(\left|C\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
CLossFunction	Class CLossFunction is the base class of all loss functions
CHingeLoss	CHingeLoss implements the hinge loss function
CLogLoss	CLogLoss implements the logarithmic loss function
CLogLossMargin	Class CLogLossMargin implements a margin-based log-likelihood loss function
CSmoothHingeLoss	CSmoothHingeLoss implements the smooth hinge loss function
CSquaredHingeLoss	Class CSquaredHingeLoss implements a squared hinge loss function
CSquaredLoss	CSquaredLoss implements the squared loss function
CMachine	A generic learning machine interface
CBaggingMachine	: Bagging algorithm i.e. bootstrap aggregating
CBaseMulticlassMachine
CTreeMachine< ConditionalProbabilityTreeNodeData >
CConditionalProbabilityTree
CBalancedConditionalProbabilityTree
CRandomConditionalProbabilityTree
CTreeMachine< RelaxedTreeNodeData >
CRelaxedTree
CTreeMachine< VwConditionalProbabilityTreeNodeData >
CVwConditionalProbabilityTree
CMulticlassMachine	Experimental abstract generic multiclass machine class
CKernelMulticlassMachine	Generic kernel multiclass
CMulticlassSVM	Class MultiClassSVM
CGMNPSVM	Class GMNPSVM implements a one vs. rest MultiClass SVM
CLaRank	LaRank multiclass SVM machine
CMKLMulticlass	MKLMulticlass is a class for L1-norm Multiclass MKL
CMulticlassLibSVM	Class LibSVMMultiClass. Does one vs one classification
CScatterSVM	ScatterSVM - Multiclass SVM
CLinearMulticlassMachine	Generic linear multiclass machine
CMulticlassLibLinear	Multiclass LibLinear wrapper. Uses Crammer-Singer formulation and gradient descent optimization algorithm implemented in the LibLinear library. Regularized bias support is added using stacking bias 'feature' to hyperplanes normal vectors
CDomainAdaptationMulticlassLibLinear	Domain adaptation multiclass LibLinear wrapper Source domain is assumed to b
CMulticlassLogisticRegression	Multiclass logistic regression
CMulticlassOCAS	Multiclass OCAS wrapper
CMulticlassTreeGuidedLogisticRegression	Multiclass tree guided logistic regression
CShareBoost
CNativeMulticlassMachine	Experimental abstract native multiclass machine class
CGaussianNaiveBayes	Class GaussianNaiveBayes, a Gaussian Naive Bayes classifier
CMCLDA	Class MCLDA implements multiclass Linear Discriminant Analysis
CQDA	Class QDA implements Quadratic Discriminant Analysis
CTreeMachine< T >	Class TreeMachine, a base class for tree based multiclass classifiers
CDistanceMachine	A generic DistanceMachine interface
CHierarchical	Agglomerative hierarchical single linkage clustering
CKMeans	KMeans clustering, partitions the data into k (a-priori specified) clusters
CKNN	Class KNN, an implementation of the standard k-nearest neigbor classifier
CNearestCentroid	Class NearestCentroid, an implementation of Nearest Shrunk Centroid classifier
CGaussianProcessMachine	A base class for Gaussian Processes
CGaussianProcessBinaryClassification	Class GaussianProcessBinaryClassification implements binary classification based on Gaussian Processes
CGaussianProcessRegression	Class GaussianProcessRegression implements regression based on Gaussian Processes
CKernelMachine	A generic KernelMachine interface
CKernelRidgeRegression	Class KernelRidgeRegression implements Kernel Ridge Regression - a regularized least square method for classification and regression
CSVM	A generic Support Vector Machine Interface
CCPLEXSVM	CplexSVM a SVM solver implementation based on cplex (unfinished)
CGNPPSVM	Class GNPPSVM
CGPBTSVM	Class GPBTSVM
CLibSVM	LibSVM
CLibSVMOneClass	Class LibSVMOneClass
CLibSVR	Class LibSVR, performs support vector regression using LibSVM
CMKL	Multiple Kernel Learning
CMKLClassification	Multiple Kernel Learning for two-class-classification
CMKLOneClass	Multiple Kernel Learning for one-class-classification
CMKLRegression	Multiple Kernel Learning for regression
CMPDSVM	Class MPDSVM
CSVMLight	Class SVMlight
CDomainAdaptationSVM	Class DomainAdaptationSVM
CSVMLightOneClass	Trains a one class C SVM
CSVRLight	Class SVRLight, performs support vector regression using SVMLight
CLinearMachine	Class LinearMachine is a generic interface for all kinds of linear machines like classifiers
CAveragedPerceptron	Class Averaged Perceptron implements the standard linear (online) algorithm. Averaged perceptron is the simple extension of Perceptron
CFeatureBlockLogisticRegression	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
CLDA	Class LDA implements regularized Linear Discriminant Analysis
CLeastAngleRegression	Class for Least Angle Regression, can be used to solve LASSO
CLibLinear	Class to implement LibLinear
CDomainAdaptationSVMLinear	Class DomainAdaptationSVMLinear
CLibLinearMTL	Class to implement LibLinear
CLibLinearRegression	LibLinear for regression
CLinearLatentMachine	Abstract implementaion of Linear Machine with latent variable This is the base implementation of all linear machines with latent variable
CLatentSOSVM	Class Latent Structured Output SVM, an structured output based machine for classification problems with latent variables
CLatentSVM	LatentSVM class Latent SVM implementation based on [1]. For optimization this implementation uses SVMOcas
CLinearRidgeRegression	Class LinearRidgeRegression implements Ridge Regression - a regularized least square method for classification and regression
CLeastSquaresRegression	Class to perform Least Squares Regression
CLPBoost	Class LPBoost trains a linear classifier called Linear Programming Machine, i.e. a SVM using a \(\ell_1\) norm regularizer
CLPM	Class LPM trains a linear classifier called Linear Programming Machine, i.e. a SVM using a \(\ell_1\) norm regularizer
CMultitaskLinearMachine	Class MultitaskLinearMachine, a base class for linear multitask classifiers
CMultitaskLeastSquaresRegression	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
CMultitaskLogisticRegression	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
CMultitaskClusteredLogisticRegression	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
CMultitaskL12LogisticRegression	Class MultitaskL12LogisticRegression, a classifier for multitask problems. Supports only task group relations. Based on solver ported from the MALSAR library
CMultitaskTraceLogisticRegression	Class MultitaskTraceLogisticRegression, a classifier for multitask problems. Supports only task group relations. Based on solver ported from the MALSAR library
CNewtonSVM	NewtonSVM, In this Implementation linear SVM is trained in its primal form using Newton-like 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
CPerceptron	Class Perceptron implements the standard linear (online) perceptron
CSGDQN	Class SGDQN
CSVMLin	Class SVMLin
CSVMOcas	Class SVMOcas
CSVMSGD	Class SVMSGD
COnlineLinearMachine	Class OnlineLinearMachine is a generic interface for linear machines like classifiers which work through online algorithms
COnlineLibLinear	Class implementing a purely online version of LibLinear, using the L2R_L1LOSS_SVC_DUAL solver only
COnlineSVMSGD	Class OnlineSVMSGD
CVowpalWabbit	Class CVowpalWabbit is the implementation of the online learning algorithm used in Vowpal Wabbit
CPluginEstimate	Class PluginEstimate
CStructuredOutputMachine
CKernelStructuredOutputMachine
CLinearStructuredOutputMachine
CCCSOSVM	CCSOSVM
CDualLibQPBMSOSVM	Class DualLibQPBMSOSVM that uses Bundle Methods for Regularized Risk Minimization algorithms for structured output (SO) problems [1] presented in [2]
CWDSVMOcas	Class WDSVMOcas
CMachineEvaluation	Machine Evaluation is an abstract class that evaluates a machine according to some criterion
CCrossValidation	Base class for cross-validation evaluation. Given a learning machine, a splitting strategy, an evaluation criterium, features and correspnding labels, this provides an interface for cross-validation. 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 p-value is specified. Default number of runs is one, confidence interval combutation is disabled
CGradientEvaluation	Class evaluates a machine using its associated differentiable function for the function value and its gradient with respect to parameters
CMap< K, T >	Class CMap, a map based on the hash-table. w: http://en.wikipedia.org/wiki/Hash_table
CMAPInference	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}) \)
CMAPInferImpl	Class CMAPInferImpl abstract class of MAP inference implementation
CMath	Class which collects generic mathematical functions
CMeanFunction	An abstract class of the mean function
CZeroMean	The zero mean function class
CMemoryMappedFile< T >	Memory mapped file
CMMDKernelSelection	Base class for kernel selection for MMD-based two-sample 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
CMMDKernelSelectionComb	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
CMMDKernelSelectionCombMaxL2	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 L2-regularization 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
CMMDKernelSelectionCombOpt	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\)
CMMDKernelSelectionMax	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
CMMDKernelSelectionMedian	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
CMMDKernelSelectionOpt	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 two-sample test. This only works for the CLinearTimeMMD statistic
CModelSelection	Abstract base class for model selection
CGradientModelSelection	Model selection class which searches for the best model by a gradient-search
CGridSearchModelSelection	Model selection class which searches for the best model by a grid- search. See CModelSelection for details
CRandomSearchModelSelection	Model selection class which searches for the best model by a random search. See CModelSelection for details
CModelSelectionParameters	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
CMulticlassStrategy	Class MulticlassStrategy used to construct generic multiclass classifiers with ensembles of binary classifiers
CECOCStrategy
CMulticlassOneVsOneStrategy	Multiclass one vs one strategy used to train generic multiclass machines for K-class problems with building voting-based ensemble of K*(K-1) binary classifiers multiclass probabilistic outputs can be obtained by using the heuristics described in [1]
CMulticlassOneVsRestStrategy	Multiclass one vs rest strategy used to train generic multiclass machines for K-class problems with building ensemble of K binary classifiers
CNode	A CNode is an element of a CTaxonomy, which is used to describe hierarchical structure between tasks
COperatorFunction< T >	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
CParameterCombination	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 sub-parameters are stored in sub-nodes. Using a tree of this class, parameters of models may easily be set. There are these types of nodes:
CParser	Class for reading from a string
CPlifBase	Class PlifBase
CPlif	Class Plif
CPlifArray	Class PlifArray
CPlifMatrix	Store plif arrays for all transitions in the model
CPreprocessor	Class Preprocessor defines a preprocessor interface
CDensePreprocessor< float64_t >
CDimensionReductionPreprocessor	Class DimensionReductionPreprocessor, a base class for preprocessors used to lower the dimensionality of given simple features (dense matrices)
CKernelPCA	Preprocessor KernelPCA performs kernel principal component analysis
CPCA	Preprocessor PCACut performs principial component analysis on the input vectors and keeps only the n eigenvectors with eigenvalues above a certain threshold
CHomogeneousKernelMap	Preprocessor HomogeneousKernelMap performs homogeneous kernel maps as described in
CLogPlusOne	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
CNormOne	Preprocessor NormOne, normalizes vectors to have norm 1
CPNorm	Preprocessor PNorm, normalizes vectors to have p-norm
CPruneVarSubMean	Preprocessor PruneVarSubMean will substract the mean and remove features that have zero variance
CRandomFourierGaussPreproc	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
CRescaleFeatures	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]
CSumOne	Preprocessor SumOne, normalizes vectors to have sum 1
CStringPreprocessor< uint16_t >
CSortWordString	Preprocessor SortWordString, sorts the indivual strings in ascending order
CStringPreprocessor< uint64_t >
CSortUlongString	Preprocessor SortUlongString, sorts the indivual strings in ascending order
CDensePreprocessor< ST >	Template class DensePreprocessor, base class for preprocessors (cf. CPreprocessor) that apply to CDenseFeatures (i.e. rectangular dense matrices)
CSparsePreprocessor< ST >	Template class SparsePreprocessor, base class for preprocessors (cf. CPreprocessor) that apply to CSparseFeatures
CStringPreprocessor< ST >	Template class StringPreprocessor, base class for preprocessors (cf. CPreprocessor) that apply to CStringFeatures (i.e. strings of variable length)
CDecompressString< ST >	Preprocessor that decompresses compressed strings
CProbabilityDistribution	A base class for representing n-dimensional probability distribution over the real numbers (64bit) for which various statistics can be computed and which can be sampled
CGaussianDistribution	Dense version of the well-known 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) \]
CQPBSVMLib	Class QPBSVMLib
CRandom	: Pseudo random number geneartor
CRejectionStrategy	Base rejection strategy class
CDixonQTestRejectionStrategy	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
CThresholdRejectionStrategy	Threshold based rejection strategy
CResultSet
CSegmentLoss	Class IntronList
CSerializableFile	Serializable file
CSerializableAsciiFile	Serializable ascii file
CSerializableFile::TSerializableReader	Serializable reader
SerializableAsciiReader00	Serializable ascii reader
CSet< T >	Class CSet, a set based on the hash-table. w: http://en.wikipedia.org/wiki/Hash_table
CSignal	Class Signal implements signal handling to e.g. allow ctrl+c to cancel a long running process
CSimpleFile< T >	Template class SimpleFile to read and write from files
CSparseInverseCovariance	Used to estimate inverse covariance matrix using graphical lasso
CSplittingStrategy	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(...)
CCrossValidationSplitting	Implementation of normal cross-validation on the base of CSplittingStrategy. Produces subset index sets of equal size (at most one difference)
CStratifiedCrossValidationSplitting	Implementation of stratified cross-validation 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
CStateModel	Class CStateModel base, abstract class for the internal state representation used in the CHMSVMModel
CTwoStateModel	Class CTwoStateModel class for the internal two-state representation used in the CHMSVMModel
CStatistics	Class that contains certain functions related to statistics, such as probability/cumulative distribution functions, different statistics, etc
CStreamingFile	A Streaming File access class
CStreamingAsciiFile	Class StreamingAsciiFile to read vector-by-vector from ASCII files
CStreamingFileFromFeatures	Class StreamingFileFromFeatures to read vector-by-vector from a CFeatures object
CStreamingFileFromDenseFeatures< T >	Class CStreamingFileFromDenseFeatures is a derived class of CStreamingFile which creates an input source for the online framework from a CDenseFeatures object
CStreamingFileFromSparseFeatures< T >	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
CStreamingFileFromStringFeatures< T >	Class CStreamingFileFromStringFeatures is derived from CStreamingFile and provides an input source for the online framework from a CStringFeatures object
CStreamingVwCacheFile	Class StreamingVwCacheFile to read vector-by-vector from VW cache files
CStreamingVwFile	Class StreamingVwFile to read vector-by-vector from Vowpal Wabbit data files. It reads the example and label into one object of VwExample type
CStructuredData	Base class of the components of StructuredLabels
CFactorGraphObservation	Class CFactorGraphObservation is used as the structured output
CRealNumber	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
CSequence	Class CSequence to be used in the application of Structured Output (SO) learning to Hidden Markov Support Vector Machines (HM-SVM)
CStructuredModel	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
CFactorGraphModel	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
CHMSVMModel	Class CHMSVMModel that represents the application specific model and contains the application dependent logic to solve Hidden Markov Support Vector Machines (HM-SVM) type of problems within a generic SO framework
CMulticlassModel	Class CMulticlassModel that represents the application specific model and contains the application dependent logic to solve multiclass classification within a generic SO framework
CSubset	Wrapper class for an index subset which is used by SubsetStack
CSubsetStack	Class to add subset support to another class. A CSubsetStackStack instance should be added and wrapper methods to all interfaces should be added
CTask	Class Task used to represent tasks in multitask learning. Essentially it represent a set of feature vector indices
CTaskRelation	Used to represent tasks in multitask learning
CTaskGroup	Class TaskGroup used to represent a group of tasks. Tasks in group do not overlap
CTaskTree	Class TaskTree used to represent a tree of tasks. Tree is constructed via task with subtasks (and subtasks of subtasks ..) passed to the TaskTree
CTaxonomy	CTaxonomy is used to describe hierarchical structure between tasks
CTestStatistic	Test statistic base class. Provides an interface for statistical tests via three methods: compute_statistic(), compute_p_value() and compute_threshold(). The second computes a p-value for the statistic computed by the first method. The p-value represents the position of the statistic in the null-distribution, i.e. the distribution of the statistic population given the null-hypothesis is true. (1-position = p-value). The third method, compute_threshold(), computes a threshold for a given test level which is needed to reject the null-hypothesis
CTwoDistributionsTestStatistic	Provides an interface for performing statistical tests on two sets of samples from two distributions. Instances of these tests are the classical two-sample test and the independence test. This class may be used as base class for both
CKernelIndependenceTestStatistic	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}_x\textbf{P}_y\), does the joint distribution factorize as \(\textbf{P}_{xy}=\textbf{P}_x\textbf{P}_y\)? The null- hypothesis says yes, i.e. no independence, the alternative hypothesis says yes
CHSIC	This class implements the Hilbert Schmidtd Independence Criterion based independence test as described in [1]
CKernelTwoSampleTestStatistic	Two sample test base class. Provides an interface for performing a two-sample test, i.e. Given samples from two distributions \(p\) and \(q\), the null-hypothesis is: \(H_0: p=q\), the alternative hypothesis: \(H_1: p\neq q\)
CLinearTimeMMD	This class implements the linear time Maximum Mean Statistic as described in [1]. This statistic is in particular suitable for streaming data. Therefore, only streaming features may be passed. To process other feature types, construct streaming features from these (see constructor documentations). A blocksize has to be specified that determines how many examples are processed at once. This should be set as large as available memory allows to ensure faster computations
CQuadraticTimeMMD	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 \[ \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} \]
CTime	Class Time that implements a stopwatch based on either cpu time or wall clock time
CTokenizer	The class CTokenizer acts as a base class in order to implement tokenizers. Sub-classes must implement the methods has_next(), next_token_idx() and get_copy()
CDelimiterTokenizer	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;
CNGramTokenizer	The class CNGramTokenizer is used to tokenize a SGVector<char> into n-grams
CTraceSampler	Abstract template base class that provides an interface for sampling the trace of a linear operator using an abstract sample method
CNormalSampler	Class that provides a sample method for Gaussian samples
CTreeMachineNode< T >
CTrie< Trie >	Template class Trie implements a suffix trie, i.e. a tree in which all suffixes up to a certain length are stored
CVwCacheReader	Base class from which all cache readers for VW should be derived
CVwNativeCacheReader	Class CVwNativeCacheReader reads from a cache exactly as that which has been produced by VW's default cache format
CVwCacheWriter	CVwCacheWriter is the base class for all VW cache creating classes
CVwNativeCacheWriter	Class CVwNativeCacheWriter writes a cache exactly as that which would be produced by VW's default cache format
CVwEnvironment	Class CVwEnvironment is the environment used by VW
CVwLearner	Base class for all VW learners
CVwAdaptiveLearner	VwAdaptiveLearner uses an adaptive subgradient technique to update weights
CVwNonAdaptiveLearner	VwNonAdaptiveLearner uses a standard gradient descent weight update rule
CVwParser	CVwParser is the object which provides the functions to parse examples from buffered input
CVwRegressor	Regressor used by VW
MKLMulticlassOptimizationBase	MKLMulticlassOptimizationBase is a helper class for MKLMulticlass
MKLMulticlassGLPK	MKLMulticlassGLPK is a helper class for MKLMulticlass
MKLMulticlassGradient	MKLMulticlassGradient is a helper class for MKLMulticlass
CSyntaxHighLight	Syntax highlight
CTron	Class Tron
d_node< P >
D_THREAD_PARAM< T >
ds_node< P >
DynArray< T >	Template Dynamic array class that creates an array that can be used like a list or an array
EigenSparseUtil< T >	This class contains some utilities for Eigen3 Sparse Matrix integration with shogun. Currently it provides a method for converting SGSparseMatrix to Eigen3 SparseMatrix
EntryComparator
ICP_stats
IndexSorter< T >
IterativeSolverIterator< T >	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
K_THREAD_PARAM< T >
lbfgs_parameter_t
line_search_res
MappedSparseMatrix	Mapped sparse matrix for representing graph relations of tasks
mocas_data
Model	Class Model
Munkres	Munkres
node< P >
Parallel	Class Parallel provides helper functions for multithreading
Parameter	Parameter class
ParameterMap	Implements a map of ParameterMapElement instances Maps one key to a set of values
ParameterMapElement	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
RefCount
RelaxedTreeNodeData
RelaxedTreeUtil
SGIO	Class SGIO, used to do input output operations throughout shogun
SGParamInfo	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
SGReferencedData	Shogun reference count managed data
SGMatrix< float64_t >
SGVector< complex128_t >
SGVector< float64_t >
SGMatrix< T >	Shogun matrix
SGMatrixList< T >	Shogun matrix list
SGNDArray< T >	Shogun n-dimensional array
SGSparseMatrix< T >	Template class SGSparseMatrix
SGSparseVector< T >	Template class SGSparseVector The assumtion is that the stored SGSparseVectorEntry<T>* vector is ordered by SGSparseVectorEntry.feat_index in non-decreasing order. This has to be assured by the user of the class
SGStringList< T >	Template class SGStringList
SGVector< T >	Shogun vector
SGSparseVectorEntry< T >	Template class SGSparseVectorEntry
SGString< T >	Shogun string
ShareBoostOptimizer
ShogunException	Class ShogunException defines an exception which is thrown whenever an error inside of shogun occurs
ShogunFeatureVectorCallback
ShogunLoggerImplementation
CStatistics::SigmoidParamters
SparsityStructure	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+
SSKFeatures	SSKFeatures
substring	Struct Substring, specified by start position and end position
tag_callback_data
tag_iteration_data
task_tree_node_t
TMultipleCPinfo
TParameter	Parameter struct
tree_node_t
TSGDataType	Datatypes that shogun supports
v_array< T >	Class v_array taken directly from JL's implementation
Version	Class Version provides version information
VwConditionalProbabilityTreeNodeData
VwExample	Example class for VW
VwFeature	One feature in VW
VwLabel	Class VwLabel holds a label object used by VW