SHOGUN
v2.0.0

shogun  All of classes and functions are contained in the shogun namespace 
DynArray  Template Dynamic array class that creates an array that can be used like a list or an array 
Parallel  Class Parallel provides helper functions for multithreading 
TParameter  Parameter struct 
Parameter  Parameter class 
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 
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 
ParameterMap  Implements a map of ParameterMapElement instances Maps one key to a set of values 
CSGObject  Class SGObject is the base class of all shogun objects 
Version  Class Version provides version information 
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 
CLPBoost  Class LPBoost trains a linear classifier called Linear Programming Machine, i.e. a SVM using a norm regularizer 
CLPM  Class LPM trains a linear classifier called Linear Programming Machine, i.e. a SVM using a norm regularizer 
CMKL  Multiple Kernel Learning 
CMKLClassification  Multiple Kernel Learning for twoclassclassification 
CMKLMulticlass  MKLMulticlass is a class for L1norm multiclass MKL 
MKLMulticlassGLPK  MKLMulticlassGLPK is a helper class for MKLMulticlass 
MKLMulticlassGradient  MKLMulticlassGradient is a helper class for MKLMulticlass 
MKLMulticlassOptimizationBase  MKLMulticlassOptimizationBase is a helper class for MKLMulticlass 
CMKLOneClass  Multiple Kernel Learning for oneclassclassification 
CNearestCentroid  Class NearestCentroid, an implementation of Nearest Shrunk Centroid classifier 
CPerceptron  Class Perceptron implements the standard linear (online) perceptron 
CPluginEstimate  Class PluginEstimate 
CSubGradientLPM  Class SubGradientSVM trains a linear classifier called Linear Programming Machine, i.e. a SVM using a norm regularizer 
CCPLEXSVM  CplexSVM a SVM solver implementation based on cplex (unfinished) 
CGNPPLib  Class GNPPLib, a Library of solvers for Generalized Nearest Point Problem (GNPP) 
CGNPPSVM  Class GNPPSVM 
CGPBTSVM  Class GPBTSVM 
CLibLinear  Class to implement LibLinear 
CLibSVM  LibSVM 
CLibSVMOneClass  Class LibSVMOneClass 
CMPDSVM  Class MPDSVM 
CNewtonSVM  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 
COnlineLibLinear  Class implementing a purely online version of LibLinear, using the L2R_L1LOSS_SVC_DUAL solver only 
COnlineSVMSGD  Class OnlineSVMSGD 
CQPBSVMLib  Class QPBSVMLib 
CSGDQN  Class SGDQN 
CSubGradientSVM  Class SubGradientSVM 
CSVM  A generic Support Vector Machine Interface 
CSVMLight  Class SVMlight 
CSVMLightOneClass  Trains a one class C SVM 
CSVMLin  Class SVMLin 
CSVMOcas  Class SVMOcas 
CSVMSGD  Class SVMSGD 
CWDSVMOcas  Class WDSVMOcas 
CVwCacheReader  Base class from which all cache readers for VW should be derived 
CVwCacheWriter  CVwCacheWriter is the base class for all VW cache creating classes 
CVwNativeCacheReader  Class CVwNativeCacheReader reads from a cache exactly as that which has been produced by VW's default cache format 
CVwNativeCacheWriter  Class CVwNativeCacheWriter writes a cache exactly as that which would be produced by VW's default cache format 
CVwAdaptiveLearner  VwAdaptiveLearner uses an adaptive subgradient technique to update weights 
CVwNonAdaptiveLearner  VwNonAdaptiveLearner uses a standard gradient descent weight update rule 
CVowpalWabbit  Class CVowpalWabbit is the implementation of the online learning algorithm used in Vowpal Wabbit 
VwFeature  One feature in VW 
VwExample  Example class for VW 
VwLabel  Class VwLabel holds a label object used by VW 
CVwEnvironment  Class CVwEnvironment is the environment used by VW 
CVwLearner  Base class for all VW learners 
CVwParser  CVwParser is the object which provides the functions to parse examples from buffered input 
CVwRegressor  Regressor used by VW 
CGMM  Gaussian Mixture Model interface 
CHierarchical  Agglomerative hierarchical single linkage clustering 
CKMeans  KMeans clustering, partitions the data into k (apriori specified) clusters 
CConverter  Class Converter used to convert data 
CDiffusionMaps  Class DiffusionMaps (part of the Efficient Dimensionality Reduction Toolkit) used to preprocess given data using Diffusion Maps dimensionality reduction technique as described in 
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 
CHessianLocallyLinearEmbedding  Class HessianLocallyLinearEmbedding (part of the Efficient Dimensionality Reduction Toolkit) used to preprocess data using Hessian Locally Linear Embedding algorithm as described in 
CIsomap  Class Isomap (part of the Efficient Dimension Reduction Toolkit) used to embed data using Isomap algorithm as described in 
CKernelLocallyLinearEmbedding  Class KernelLocallyLinearEmbedding (part of the Efficient Dimensionality Reduction Toolkit) used to construct embeddings of data using kernel formulation of Locally Linear Embedding algorithm as described in 
CKernelLocalTangentSpaceAlignment  Class LocalTangentSpaceAlignment (part of the Efficient Dimensionality Reduction Toolkit) used to embed data using kernel extension of the Local Tangent Space Alignment (LTSA) algorithm 
CLaplacianEigenmaps  Class LaplacianEigenmaps (part of the Efficient Dimensionality Reduction Toolkit) used to construct embeddings of data using Laplacian Eigenmaps algorithm as described in: 
CLinearLocalTangentSpaceAlignment  Class LinearLocalTangentSpaceAlignment (part of the Efficient Dimensionality Reduction Toolkit) converter used to construct embeddings as described in: 
CLocalityPreservingProjections  Class LocalityPreservingProjections (part of the Efficient Dimensionality Reduction Toolkit) used to compute embeddings of data using Locality Preserving Projections method as described in 
CLocallyLinearEmbedding  Class LocallyLinearEmbedding (part of the Efficient Dimensionality Reduction Toolkit) used to embed data using Locally Linear Embedding algorithm described in 
CLocalTangentSpaceAlignment  Class LocalTangentSpaceAlignment (part of the Efficient Dimensionality Reduction Toolkit) used to embed data using Local Tangent Space Alignment (LTSA) algorithm as described in: 
CMultidimensionalScaling  Class Multidimensionalscaling (part of the Efficient Dimensionality Reduction Toolkit) is used to perform multidimensional scaling (capable of landmark approximation if requested) 
CNeighborhoodPreservingEmbedding  NeighborhoodPreservingEmbedding (part of the Efficient Dimensionality Reduction Toolkit) converter used to construct embeddings as described in: 
CStochasticProximityEmbedding  Class StochasticProximityEmbedding (part of the Efficient Dimensionality Reduction Toolkit) used to construct embeddings of data using the Stochastic Proximity algorithm 
CAttenuatedEuclideanDistance  Class AttenuatedEuclideanDistance 
CBrayCurtisDistance  Class BrayCurtis distance 
CCanberraMetric  Class CanberraMetric 
CCanberraWordDistance  Class CanberraWordDistance 
CChebyshewMetric  Class ChebyshewMetric 
CChiSquareDistance  Class ChiSquareDistance 
CCosineDistance  Class CosineDistance 
CCustomDistance  The Custom Distance allows for custom user provided distance matrices 
CDenseDistance  Template class DenseDistance 
CDistance  Class Distance, a base class for all the distances used in the Shogun toolbox 
CEuclideanDistance  Class EuclideanDistance 
CGeodesicMetric  Class GeodesicMetric 
CHammingWordDistance  Class HammingWordDistance 
CJensenMetric  Class JensenMetric 
CKernelDistance  The Kernel distance takes a distance as input 
CMahalanobisDistance  Class MahalanobisDistance 
CManhattanMetric  Class ManhattanMetric 
CManhattanWordDistance  Class ManhattanWordDistance 
CMinkowskiMetric  Class MinkowskiMetric 
CRealDistance  Class RealDistance 
CSparseDistance  Template class SparseDistance 
CSparseEuclideanDistance  Class SparseEucldeanDistance 
CStringDistance  Template class StringDistance 
CTanimotoDistance  Class Tanimoto coefficient 
CDistribution  Base class Distribution from which all methods implementing a distribution are derived 
CGaussian  Gaussian distribution interface 
CGHMM  Class GHMM  this class is nonfunctional and was meant to implement a Generalize Hidden Markov Model (aka Semi Hidden Markov HMM) 
CHistogram  Class Histogram computes a histogram over all 16bit unsigned integers in the features 
Model  Class Model 
CHMM  Hidden Markov Model 
CLinearHMM  The class LinearHMM is for learning Higher Order Markov chains 
CPositionalPWM  Positional PWM 
CBinaryClassEvaluation  The class TwoClassEvaluation, a base class used to evaluate binary classification labels 
CClusteringAccuracy  Clustering accuracy 
CClusteringEvaluation  The base class used to evaluate clustering 
CClusteringMutualInformation  Clustering (normalized) mutual information 
CContingencyTableEvaluation  The class ContingencyTableEvaluation a base class used to evaluate 2class classification with TP, FP, TN, FN rates 
CAccuracyMeasure  Class AccuracyMeasure used to measure accuracy of 2class classifier 
CErrorRateMeasure  Class ErrorRateMeasure used to measure error rate of 2class classifier 
CBALMeasure  Class BALMeasure used to measure balanced error of 2class classifier 
CWRACCMeasure  Class WRACCMeasure used to measure weighted relative accuracy of 2class classifier 
CF1Measure  Class F1Measure used to measure F1 score of 2class classifier 
CCrossCorrelationMeasure  Class CrossCorrelationMeasure used to measure cross correlation coefficient of 2class classifier 
CRecallMeasure  Class RecallMeasure used to measure recall of 2class classifier 
CPrecisionMeasure  Class PrecisionMeasure used to measure precision of 2class classifier 
CSpecificityMeasure  Class SpecificityMeasure used to measure specificity of 2class classifier 
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 
CCrossValidation  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 
CCrossValidationMKLStorage  Class for storing MKL weights in every fold of crossvalidation 
CCrossValidationMulticlassStorage  Class for storing multiclass evaluation information in every fold of crossvalidation 
CCrossValidationOutput  Class for managing individual folds in crossvalidation 
CCrossValidationPrintOutput  Class for outputting crossvalidation intermediate results to the standard output. Simply prints all messages it gets 
CCrossValidationSplitting  Implementation of normal crossvalidation on the base of CSplittingStrategy. Produces subset index sets of equal size (at most one difference) 
CDifferentiableFunction  DifferentiableFunction 
CEvaluation  Class Evaluation, a base class for other classes used to evaluate labels, e.g. accuracy of classification or mean squared error of regression 
CEvaluationResult  EvaluationResult is the abstract class that contains the result generated by the MachineEvaluation class 
CGradientCriterion  CGradientCriterion Simple class which specifies the direction of gradient search. Does not provide any label evaluation measure, however 
CGradientEvaluation  GradientEvaluation evaluates a machine using its associated differentiable function for the function value and its gradient with respect to parameters 
CGradientResult  GradientResult is a container class that returns results from GradientEvaluation. It contains the function value as well as its gradient 
CMachineEvaluation  Machine Evaluation is an abstract class that evaluates a machine according to some criterion 
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 
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) 
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(...) 
CStratifiedCrossValidationSplitting  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 
CStructuredAccuracy  Class CStructuredAccuracy used to compute accuracy of structured classification 
CAlphabet  The class Alphabet implements an alphabet and alphabet utility functions 
CAttributeFeatures  Implements attributed features, that is in the simplest case a number of (attribute, value) pairs 
CBinnedDotFeatures  The class BinnedDotFeatures contains a 01 conversion of features into bins 
CCombinedDotFeatures  Features that allow stacking of a number of DotFeatures 
CCombinedFeatures  The class CombinedFeatures is used to combine a number of of feature objects into a single CombinedFeatures object 
CDataGenerator  Class that is able to generate various data samples, which may be used for examples in SHOGUN 
CDenseFeatures  The class DenseFeatures implements dense feature matrices 
CDenseSubsetFeatures  
CDotFeatures  Features that support dot products among other operations 
CDummyFeatures  The class DummyFeatures implements features that only know the number of feature objects (but don't actually contain any) 
CExplicitSpecFeatures  Features that compute the Spectrum Kernel feature space explicitly 
CFeatures  The class Features is the base class of all feature objects 
CFKFeatures  The class FKFeatures implements Fischer kernel features obtained from two Hidden Markov models 
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 
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 (userdefined) form based on CData 
CLBPPyrDotFeatures  Implement DotFeatures for the polynomial kernel 
CMatrixFeatures  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) 
CPolyFeatures  Implement DotFeatures for the polynomial kernel 
CRealFileFeatures  The class RealFileFeatures implements a dense doubleprecision floating point matrix from a file 
CSNPFeatures  Features that compute the Weighted Degreee Kernel feature space explicitly 
CSparseFeatures  Template class SparseFeatures implements sparse matrices 
CSparsePolyFeatures  Implement DotFeatures for the polynomial kernel 
CStreamingDenseFeatures  This class implements streaming features with dense feature vectors 
CStreamingDotFeatures  Streaming features that support dot products among other operations 
CStreamingFeatures  Streaming features are features which are used for online algorithms 
CStreamingSparseFeatures  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' 
CStreamingStringFeatures  This class implements streaming features as strings 
CStreamingVwFeatures  This class implements streaming features for use with VW 
CStringFeatures  Template class StringFeatures implements a list of strings 
CStringFileFeatures  File based string features 
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 
CTOPFeatures  The class TOPFeatures implements TOP kernel features obtained from two Hidden Markov models 
CWDFeatures  Features that compute the Weighted Degreee Kernel feature space explicitly 
CAsciiFile  A Ascii File access class 
CBinaryFile  A Binary file access class 
CBinaryStream  Memory mapped emulation via binary streams (files) 
CFile  A File access base class 
CIOBuffer  An I/O buffer class 
CMemoryMappedFile  Memory mapped file 
CSerializableAsciiFile  Serializable ascii file 
SerializableAsciiReader00  Serializable ascii reader 
CSerializableFile  Serializable file 
TSerializableReader  Serializable reader 
SGIO  Class SGIO, used to do input output operations throughout shogun 
substring  Struct Substring, specified by start position and end position 
CSimpleFile  Template class SimpleFile to read and write from files 
CInputParser  Class CInputParser is a templated class used to maintain the reading/parsing/providing of examples 
Example  Class Example is the container type for the vector+label combination 
CParseBuffer  Class CParseBuffer implements a ring of examples of a defined size. The ring stores objects of the Example type 
CStreamingAsciiFile  Class StreamingAsciiFile to read vectorbyvector from ASCII files 
CStreamingFile  A Streaming File access class 
CStreamingFileFromDenseFeatures  Class CStreamingFileFromDenseFeatures is a derived class of CStreamingFile which creates an input source for the online framework from a CDenseFeatures object 
CStreamingFileFromFeatures  Class StreamingFileFromFeatures to read vectorbyvector from a CFeatures object 
CStreamingFileFromSparseFeatures  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  Class CStreamingFileFromStringFeatures is derived from CStreamingFile and provides an input source for the online framework from a CStringFeatures object 
CStreamingVwCacheFile  Class StreamingVwCacheFile to read vectorbyvector from VW cache files 
CStreamingVwFile  Class StreamingVwFile to read vectorbyvector from Vowpal Wabbit data files. It reads the example and label into one object of VwExample type 
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 
CBesselKernel  Class Bessel kernel 
CCauchyKernel  Cauchy kernel 
CChi2Kernel  The Chi2 kernel operating on realvalued vectors computes the chisquared distance between sets of histograms 
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 
CDotKernel  Template class DotKernel is the base class for kernels working on DotFeatures 
CExponentialKernel  The Exponential Kernel, closely related to the Gaussian Kernel computed on CDotFeatures 
CGaussianARDKernel  Gaussian Kernel with Automatic Relevance Detection 
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 shortreal 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 
CInverseMultiQuadricKernel  InverseMultiQuadricKernel 
CJensenShannonKernel  The JensenShannon kernel operating on realvalued vectors computes the JensenShannon distance between the features. Often used in computer vision 
CKernel  The Kernel base class 
CLinearARDKernel  Linear Kernel with Automatic Relevance Detection 
CLinearKernel  Computes the standard linear kernel on CDotFeatures 
CLogKernel  Log kernel 
CMultiquadricKernel  MultiquadricKernel 
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. 
CIdentityKernelNormalizer  Identity Kernel Normalization, i.e. no normalization is applied 
CKernelNormalizer  The class Kernel Normalizer defines a function to postprocess kernel values 
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 
CPolyKernel  Computes the standard polynomial kernel on CDotFeatures 
CPowerKernel  Power kernel 
CProductKernel  The Product kernel is used to combine a number of kernels into a single ProductKernel object by element multiplication 
CPyramidChi2  Pyramid Kernel over Chi2 matched histograms 
CRationalQuadraticKernel  Rational Quadratic kernel 
CSigmoidKernel  The standard Sigmoid kernel computed on dense real valued features 
CSparseKernel  Template class SparseKernel, is the base class of kernels working on sparse features 
CSphericalKernel  Spherical kernel 
CSplineKernel  Computes the Spline Kernel function which is the cubic polynomial 
CCommUlongStringKernel  The CommUlongString kernel may be used to compute the spectrum kernel from strings that have been mapped into unsigned 64bit integers 
CCommWordStringKernel  The CommWordString kernel may be used to compute the spectrum kernel from strings that have been mapped into unsigned 16bit integers 
CDistantSegmentsKernel  The distant segments kernel is a string kernel, which counts the number of substrings, socalled 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 
CHistogramWordStringKernel  The HistogramWordString computes the TOP kernel on inhomogeneous Markov Chains 
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 
CMatchWordStringKernel  The class MatchWordStringKernel computes a variant of the polynomial kernel on strings of same length converted to a word alphabet 
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 
CPolyMatchWordStringKernel  The class PolyMatchWordStringKernel computes a variant of the polynomial kernel on wordfeatures 
CRegulatoryModulesStringKernel  The Regulaty Modules kernel, based on the WD kernel, as published in Schultheiss et al., Bioinformatics (2009) on regulatory sequences 
CSalzbergWordStringKernel  The SalzbergWordString kernel implements the Salzberg kernel 
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 
SSKFeatures  SSKFeatures 
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 
CStringKernel  Template class StringKernel, is the base class of all String Kernels 
CWeightedCommWordStringKernel  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 ) from strings that have been mapped into unsigned 16bit integers 
CWeightedDegreePositionStringKernel  The Weighted Degree Position String kernel (Weighted Degree kernel with shifts) 
CWeightedDegreeStringKernel  The Weighted Degree String kernel 
CTensorProductPairKernel  Computes the Tensor Product Pair Kernel (TPPK) 
CTStudentKernel  Generalized TStudent kernel 
CWaveKernel  Wave kernel 
CWaveletKernel  Class WaveletKernel 
CWeightedDegreeRBFKernel  Weighted degree RBF kernel 
CBinaryLabels  Binary Labels for binary classification 
CDenseLabels  Dense integer or floating point labels 
CLabels  The class Labels models labels, i.e. class assignments of objects 
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 
CMulticlassLabels  Multiclass Labels for multiclass classification 
CMulticlassMultipleOutputLabels  Multiclass Labels for multiclass classification with multiple labels 
CRegressionLabels  Real Labels are realvalued labels 
CStructuredLabels  Base class of the labels used in Structured Output (SO) problems 
CLatentModel  Abstract class CLatentModel It represents the application specific model and contains most of the application dependent logic to solve latent variable based problems 
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 
CBitString  String class embedding a string in a compact bit representation 
CCache  Template class Cache implements a simple cache 
CCompressor  Compression library for compressing and decompressing buffers using one of the standard compression algorithms, LZO, GZIP, BZIP2 or LZMA 
CoverTree  
CData  Dummy data holder 
TSGDataType  Datatypes that shogun supports 
CDynamicArray  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 
CDynInt  Integer type of dynamic size 
func_wrapper  
CGCArray  Template class GCArray implements a garbage collecting static array 
CHash  Collection of Hashing Functions 
CIndexBlock  Class IndexBlock used to represent contiguous indices of one group (e.g. block of related features) 
CIndexBlockGroup  Class IndexBlockGroup used to represent groupbased feature relation 
CIndexBlockRelation  Class IndexBlockRelation 
CIndexBlockTree  Class IndexBlockTree used to represent tree guided feature relation 
CIndirectObject  Array class that accesses elements indirectly via an index array 
v_array  Class v_array taken directly from JL's implementation 
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 
CListElement  Class ListElement, defines how an element of the the list looks like 
CList  Class List implements a doubly connected list for lowlevelobjects 
CMap  Class CMap, a map based on the hashtable. w: http://en.wikipedia.org/wiki/Hash_table 
CSet  Class CSet, a set based on the hashtable. w: http://en.wikipedia.org/wiki/Hash_table 
SGMatrix  Shogun matrix 
SGMatrixList  Shogun matrix list 
SGNDArray  Shogun ndimensional array 
SGReferencedData  Shogun reference count managed data 
SGSparseMatrix  Template class SGSparseMatrix 
SGSparseVectorEntry  Template class SGSparseVectorEntry 
SGSparseVector  Template class SGSparseVector 
SGString  Shogun string 
SGStringList  Template class SGStringList 
SGVector  Shogun vector 
IndexSorter  
ShogunException  Class ShogunException defines an exception which is thrown whenever an error inside of shogun occurs 
CSignal  Class Signal implements signal handling to e.g. allow ctrl+c to cancel a long running process 
CStructuredData  Base class of the components of StructuredLabels 
CTime  Class Time that implements a stopwatch based on either cpu time or wall clock time 
CTrie  Template class Trie implements a suffix trie, i.e. a tree in which all suffixes up to a certain length are stored 
CHingeLoss  CHingeLoss implements the hinge loss function 
CLogLoss  CLogLoss implements the logarithmic loss function 
CLogLossMargin  Class CLogLossMargin implements a marginbased loglikelihood loss function 
CLossFunction  Class CLossFunction is the base class of all loss functions 
CSmoothHingeLoss  CSmoothHingeLoss implements the smooth hinge loss function 
CSquaredHingeLoss  Class CSquaredHingeLoss implements a squared hinge loss function 
CSquaredLoss  CSquaredLoss implements the squared loss function 
CBaseMulticlassMachine  
CDistanceMachine  A generic DistanceMachine interface 
CKernelMachine  A generic KernelMachine interface 
CKernelMulticlassMachine  Generic kernel multiclass 
CKernelStructuredOutputMachine  
CLinearLatentMachine  Abstract implementaion of Linear Machine with latent variable This is the base implementation of all linear machines with latent variable 
CLinearMachine  Class LinearMachine is a generic interface for all kinds of linear machines like classifiers 
CLinearMulticlassMachine  Generic linear multiclass machine 
CLinearStructuredOutputMachine  
CMachine  A generic learning machine interface 
CMulticlassMachine  Experimental abstract generic multiclass machine class 
CNativeMulticlassMachine  Experimental abstract native multiclass machine class 
COnlineLinearMachine  Class OnlineLinearMachine is a generic interface for linear machines like classifiers which work through online algorithms 
CStructuredOutputMachine  
CCplex  Class CCplex to encapsulate access to the commercial cplex general purpose optimizer 
CLoss  Class which collects generic mathematical functions 
CMath  Class which collects generic mathematical functions 
Munkres  Munkres 
CSparseInverseCovariance  Used to estimate inverse covariance matrix using graphical lasso 
CStatistics  Class that contains certain functions related to statistics, such as probability/cumulative distribution functions, different statistics, etc 
CGradientModelSelection  Model selection class which searches for the best model by a gradient search 
nlopt_package  Struct used for nlopt callback function 
CGridSearchModelSelection  Model selection class which searches for the best model by a grid search. See CModelSelection for details 
CModelSelection  Abstract base class for model selection. Takes a parameter tree which specifies parameters for model selection, and a crossvalidation instance and searches for the best combination of parameters in the abstract method select_model(), which has to be implemented in concrete subclasses 
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 
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 subparameters are stored in subnodes. Using a tree of this class, parameters of models may easily be set. There are these types of nodes: 
CRandomSearchModelSelection  Model selection class which searches for the best model by a random search. See CModelSelection for details 
CConjugateIndex  Conjugate index classifier. Described in: 
CECOCAEDDecoder  
CECOCDecoder  
CECOCDiscriminantEncoder  
CECOCEDDecoder  
CECOCEncoder  ECOCEncoder produce an ECOC codebook 
CECOCForestEncoder  
CECOCHDDecoder  
CECOCIHDDecoder  
CECOCLLBDecoder  
CECOCOVOEncoder  
CECOCOVREncoder  
CECOCRandomDenseEncoder  
CECOCRandomSparseEncoder  
CECOCSimpleDecoder  
CECOCStrategy  
CECOCUtil  
CGaussianNaiveBayes  Class GaussianNaiveBayes, a Gaussian Naive Bayes classifier 
CGMNPLib  Class GMNPLib Library of solvers for Generalized Minimal Norm Problem (GMNP) 
CGMNPSVM  Class GMNPSVM implements a one vs. rest MultiClass SVM 
CKNN  Class KNN, an implementation of the standard knearest neigbor classifier 
CLaRank  LaRank multiclass SVM machine 
CMulticlassLibLinear  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 
CMulticlassLibSVM  Class LibSVMMultiClass. Does one vs one classification 
CMulticlassOCAS  Multiclass OCAS wrapper 
CMulticlassOneVsOneStrategy  Multiclass one vs one strategy used to train generic multiclass machines for Kclass problems with building votingbased ensemble of K*(K1) binary classifiers 
CMulticlassOneVsRestStrategy  Multiclass one vs rest strategy used to train generic multiclass machines for Kclass problems with building ensemble of K binary classifiers 
CMulticlassStrategy  Class MulticlassStrategy used to construct generic multiclass classifiers with ensembles of binary classifiers 
CMulticlassSVM  Class MultiClassSVM 
CMulticlassTreeGuidedLogisticRegression  Multiclass tree guided logistic regression 
CQDA  Class QDA implements Quadratic Discriminant Analysis 
CRejectionStrategy  Base rejection strategy class 
CThresholdRejectionStrategy  Threshold based rejection strategy 
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 
CScatterSVM  ScatterSVM  Multiclass SVM 
CShareBoost  
ShareBoostOptimizer  
CBalancedConditionalProbabilityTree  
CConditionalProbabilityTree  
ConditionalProbabilityTreeNodeData  Struct to store data of node of conditional probability tree 
CRandomConditionalProbabilityTree  
CRelaxedTree  
RelaxedTreeNodeData  
RelaxedTreeUtil  
CTreeMachine  Class TreeMachine, a base class for tree based multiclass classifiers 
CTreeMachineNode  
VwConditionalProbabilityTreeNodeData  
CVwConditionalProbabilityTree  
tag_callback_data  
tag_iteration_data  
lbfgs_parameter_t  
CDecompressString  Preprocessor that decompresses compressed strings 
CDensePreprocessor  Template class DensePreprocessor, base class for preprocessors (cf. CPreprocessor) that apply to CDenseFeatures (i.e. rectangular dense matrices) 
CDimensionReductionPreprocessor  Class DimensionReductionPreprocessor, a base class for preprocessors used to lower the dimensionality of given simple features (dense matrices) 
CHomogeneousKernelMap  Preprocessor HomogeneousKernelMap performs homogeneous kernel maps as described in 
CKernelPCA  Preprocessor KernelPCA performs kernel principal component analysis 
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 
CPCA  Preprocessor PCACut performs principial component analysis on the input vectors and keeps only the n eigenvectors with eigenvalues above a certain threshold 
CPNorm  Preprocessor PNorm, normalizes vectors to have pnorm 
CPreprocessor  Class Preprocessor defines a preprocessor interface 
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 
CSortUlongString  Preprocessor SortUlongString, sorts the indivual strings in ascending order 
CSortWordString  Preprocessor SortWordString, sorts the indivual strings in ascending order 
CSparsePreprocessor  Template class SparsePreprocessor, base class for preprocessors (cf. CPreprocessor) that apply to CSparseFeatures 
CStringPreprocessor  Template class StringPreprocessor, base class for preprocessors (cf. CPreprocessor) that apply to CStringFeatures (i.e. strings of variable length) 
CSumOne  Preprocessor SumOne, normalizes vectors to have sum 1 
CGaussianProcessRegression  Class GaussianProcessRegression implements Gaussian Process Regression.vInstead of a distribution over weights, the GP specifies a distribution over functions 
CExactInferenceMethod  The Gaussian Exact Form Inference Method 
CFITCInferenceMethod  The Fully Independent Conditional Training Inference Method 
CGaussianLikelihood  This is the class that models a Gaussian Likelihood 
CInferenceMethod  The Inference Method base class 
Psi_line  
CLaplacianInferenceMethod  The Laplace Approximation Inference Method 
CLikelihoodModel  The Likelihood Model base class 
CMeanFunction  Mean Function base class 
CStudentsTLikelihood  This is the class that models a likelihood model with a Student's T Distribution. The parameters include degrees of freedom as well as a sigma scale parameter 
CZeroMean  Zero Mean Function 
CKernelRidgeRegression  Class KernelRidgeRegression implements Kernel Ridge Regression  a regularized least square method for classification and regression 
CLeastAngleRegression  Class for Least Angle Regression, can be used to solve LASSO 
CLeastSquaresRegression  Class to perform Least Squares Regression 
CLinearRidgeRegression  Class LinearRidgeRegression implements Ridge Regression  a regularized least square method for classification and regression 
CLibLinearRegression  LibLinear for regression 
CLibSVR  Class LibSVR, performs support vector regression using LibSVM 
CMKLRegression  Multiple Kernel Learning for regression 
CSVRLight  Class SVRLight, performs support vector regression using SVMLight 
CHSIC  This class implements the Hilbert Schmidtd Independence Criterion based independence test as described in [1] 
CKernelIndependenceTestStatistic  Independence test base class. Provides an interface for performing an independence test. Given samples from the joint distribution , does the joint distribution factorize as ? The null hypothesis says yes, i.e. no independence, the alternative hypothesis says yes 
CKernelMeanMatching  Kernel Mean Matching 
CKernelTwoSampleTestStatistic  Two sample test base class. Provides an interface for performing a twosample test, i.e. Given samples from two distributions and , the nullhypothesis is: , the alternative hypothesis: 
CLinearTimeMMD  This class implements the linear time Maximum Mean Statistic as described in [1]. The MMD is the distance of two probability distributions and in a RKHS.

CQuadraticTimeMMD  This class implements the quadratic time Maximum Mean Statistic as described in [1]. The MMD is the distance of two probability distributions and in a RKHS

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 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 
CTwoDistributionsTestStatistic  Provides an interface for performing statistical tests on two sets of samples from two distributions. Instances of these tests are the classical twosample test and the independence test. This class may be used as base class for both 
CDualLibQPBMSOSVM  Class DualLibQPBMSOSVM that uses Bundle Methods for Regularized Risk Minimization algorithms for structured output (SO) problems [1] presented in [2] 
CDynProg  Dynamic Programming Class 
CSequence  Class CSequence to be used in the application of Structured Output (SO) learning to Hidden Markov Support Vector Machines (HMSVM) 
CHMSVMLabels  Class CHMSVMLabels to be used 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 
CHMSVMModel  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 
CIntronList  Class IntronList 
bmrm_return_value_T  
bmrm_ll  
CMulticlassModel  Class CMulticlassModel that represents the application specific model and contains the application dependent logic to solve multiclass classification within a generic SO framework 
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 
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_classes1}. Each label is of type CRealNumber and all of them are stored in a CDynamicObjectArray 
CPlif  Class Plif 
CPlifArray  Class PlifArray 
CPlifBase  Class PlifBase 
CPlifMatrix  Store plif arrays for all transitions in the model 
CSegmentLoss  Class IntronList 
CStateModel  Class CStateModel base, abstract class for the internal state representation used in the CHMSVMModel 
TMultipleCPinfo  
CResultSet  
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 and the argmax function . See: MulticlassModel.h and .cpp for an example of these functions implemented 
CTwoStateModel  Class CTwoStateModel class for the internal twostate representation used in the CHMSVMModel 
CDomainAdaptationMulticlassLibLinear  Domain adaptation multiclass LibLinear wrapper Source domain is assumed to b 
CDomainAdaptationSVM  Class DomainAdaptationSVM 
CDomainAdaptationSVMLinear  Class DomainAdaptationSVMLinear 
MappedSparseMatrix  Mapped sparse matrix for representing graph relations of tasks 
CLibLinearMTL  Class to implement LibLinear 
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 
CMultitaskCompositeMachine  Class MultitaskCompositeMachine used to solve multitask binary classification problems with separate training of given binary classifier on each task 
CMultitaskKernelMaskNormalizer  The MultitaskKernel allows Multitask Learning via a modified kernel function 
CMultitaskKernelMaskPairNormalizer  The MultitaskKernel allows Multitask Learning via a modified kernel function 
CMultitaskKernelMklNormalizer  Baseclass for parameterized Kernel Normalizers 
CMultitaskKernelNormalizer  The MultitaskKernel allows Multitask Learning via a modified kernel function 
CMultitaskKernelPlifNormalizer  The MultitaskKernel allows learning a piecewise linear function (PLIF) via MKL 
CNode  A CNode is an element of a CTaxonomy, which is used to describe hierarchical structure between tasks 
CTaxonomy  CTaxonomy is used to describe hierarchical structure between tasks 
CMultitaskKernelTreeNormalizer  The MultitaskKernel allows Multitask Learning via a modified kernel function based on taxonomy 
CMultitaskL12LogisticRegression  Class MultitaskL12LogisticRegression, a classifier for multitask problems. Supports only task group relations. Based on solver ported from the MALSAR library 
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 
CMultitaskLinearMachine  Class MultitaskLinearMachine, a base class for linear multitask classifiers 
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 
CMultitaskROCEvaluation  Class MultitaskROCEvalution used to evaluate ROC (Receiver Operating Characteristic) and an area under ROC curve (auROC) of each task separately 
CMultitaskTraceLogisticRegression  Class MultitaskTraceLogisticRegression, a classifier for multitask problems. Supports only task group relations. Based on solver ported from the MALSAR library 
CTask  Class Task used to represent tasks in multitask learning. Essentially it represent a set of feature vector indices 
CTaskGroup  Class TaskGroup used to represent a group of tasks. Tasks in group do not overlap 
CTaskRelation  Used to represent tasks in multitask learning 
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 
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 
block_tree_node_t  
CSyntaxHighLight  Syntax highlight 
CTron  Class Tron 
d_node  
ds_node  
EntryComparator  
mocas_data  
node  
refcount_t  
SPE_COVERTREE_POINT  
task_tree_node_t  
tree_node_t 