SHOGUN  6.0.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234567]
 C_IterInfoStruct that contains current state of the iteration for iterative linear solvers
 Callocate_result< Operand, ReturnType >Template struct allocate_result for allocating objects of return type for element-wise operations. This generic version takes care of the vector types supported by Shogun (SGVector and CGPUVector)
 Callocate_result< SGMatrix< T >, SGMatrix< ST > >Specialization for allocate_result when return type is SGMatrix. Works with different scalar types as well. T defines the scalar type for the operand and whereas ST is the scalar type for the result of the element-wise operation
 CAnyAllows to store objects of arbitrary types by using a BaseAnyPolicy and provides a type agnostic API. See its usage in CSGObject::Self, CSGObject::set(), CSGObject::get() and CSGObject::has().
 CBaseAnyPolicyAn interface for a policy to store a value. Value can be any data like primitive data-types, shogun objects, etc. Policy defines how to handle this data. It works with a provided memory region and is able to set value, clear it and return the type-name as string
 CBaseTagBase class for all tags. This class stores name and not the type information for a shogun object. It can be used as an identifier for a shogun object where type information is not known. One application of this can be found in CSGObject::set_param_with_btag()
 CBlockClass that holds a block feature. A block feature is a shallow copy of an underlying (non-owning) feature object. In its constructor, it increases the refcount of the original object (since it has to be alive as long as the block is alive) and it decreases the refcount of the original object in destructor
 CBlock< Matrix >Generic class Block which wraps a matrix class and contains block specific information, providing a uniform way to deal with matrix blocks for all supported backend matrices
 CBlockwiseDetailsClass that holds block-details for the data-fetchers. There are one instance of this class per fetcher
 CC45TreeNodeDataStructure to store data of a node of C4.5 tree. This can be used as a template type in TreeMachineNode class. Ex: C4.5 algorithm uses nodes of type CTreeMachineNode<C45TreeNodeData>
 CCARTreeNodeDataStructure to store data of a node of CART. This can be used as a template type in TreeMachineNode class. CART algorithm uses nodes of type CTreeMachineNode<CARTreeNodeData>
 CCConvolutionalFeatureMapHandles convolution and gradient calculation for a single feature map in a convolutional neural network
 CCDynInt< T, sz >Integer type of dynamic size
 CCGPUMatrix< T >
 CCHAIDTreeNodeDataStructure to store data of a node of CHAID. This can be used as a template type in TreeMachineNode class. CHAID algorithm uses nodes of type CTreeMachineNode<CHAIDTreeNodeData>
 CCIndirectObject< T, P >Array class that accesses elements indirectly via an index array
 CCInputParser< T >Class CInputParser is a templated class used to maintain the reading/parsing/providing of examples
 CCInputParser< char >
 CCInputParser< float32_t >
 CCInputParser< float64_t >
 CCInputParser< shogun::SGSparseVectorEntry< ST > >
 CCInputParser< shogun::SGSparseVectorEntry< T > >
 CCInputParser< shogun::VwExample >
 CCInputParser< ST >
 CCJLCoverTreePointClass 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
 CCKNNHeapThis class implements a specialized version of max heap structure. This heap specializes in storing the least k values seen so far along with the indices (or id) of the entities with which the values are associated. On calling the push method, it is automatically checked, if the new value supplied, is among the least k distances seen so far. Also, in case the heap is full already, the max among the stored values is automatically thrown out as the new value finds its proper place in the heap
 CCLockClass Lock used for synchronization in concurrent programs
 CCLossClass which collects generic mathematical functions
 CCMatrixOperationsThe helper class is used for Laplace and KL methods
 CConditionalProbabilityTreeNodeDataStruct to store data of node of conditional probability tree
 Ccross_entropy< backend, Matrix >
 Ccross_entropy< Backend::EIGEN3, Matrix >
 CCSGObjectClass SGObject is the base class of all shogun objects
 CCTaxonomyCTaxonomy is used to describe hierarchical structure between tasks
 Cd_node< P >
 CDataManagerClass DataManager for fetching/streaming test data block-wise. It can handle data coming from multiple sources. The number of data sources is represented by the num_distributions parameter in the constructor of the data manager. It can handle heterogenous data sources, and it can stream multiple blocks per burst, as the computation would require. The size of the blocks and the number of blocks to be fetched per burst can be set externally
 Cds_node< P >
 CDynArray< T >Template Dynamic array class that creates an array that can be used like a list or an array
 CDynArray< bool >
 CDynArray< char * >
 CDynArray< char >
 CDynArray< CMapNode< K, T > * >
 CDynArray< CMapNode< shogun::TParameter *, shogun::CSGObject * > * >
 CDynArray< CMapNode< shogun::TParameter *, shogun::SGVector< float64_t > > * >
 CDynArray< CMapNode< std::string, T > * >
 CDynArray< CSetNode< T > * >
 CDynArray< float32_t >
 CDynArray< float64_t >
 CDynArray< int32_t >
 CDynArray< long >
 CDynArray< shogun::CPlifBase * >
 CDynArray< shogun::CSGObject * >
 CDynArray< shogun::SGVector< int32_t > >
 CDynArray< shogun::TParameter * >
 CEigenSparseUtil< T >This class contains some utilities for Eigen3 Sparse Matrix integration with shogun. Currently it provides a method for converting SGSparseMatrix to Eigen3 SparseMatrix
 Celementwise_unary_operation< backend, Operand, ReturnType, UnaryOp >Template struct elementwise_unary_operation. This struct is specialized for computing element-wise operations for both matrices and vectors of CPU (SGMatrix/SGVector) or GPU (CGPUMatrix/CGPUVector)
 Celementwise_unary_operation< Backend::EIGEN3, Operand, ReturnType, UnaryOp >Specialization for elementwise_unary_operation with EIGEN3 backend. The operand types MUST be of CPU types (SGMatrix/SGVector)
 Celementwise_unary_operation< Backend::NATIVE, Operand, ReturnType, UnaryOp >Specialization for elementwise_unary_operation with NATIVE backend. The operand types MUST be of CPU types (SGMatrix/SGVector)
 CGCEdgeGraph cuts edge
 CGCNodeGraph cuts node
 CGCNodePtrGraph guts node pointer
 CGPUMemoryBase< T >Interface for GPU memory libraries
 Chash< shogun::BaseTag >
 Cid3TreeNodeDataStructure to store data of a node of id3 tree. This can be used as a template type in TreeMachineNode class. Ex: id3 algorithm uses nodes of type CTreeMachineNode<id3TreeNodeData>
 CCMath::IndexSorter< T >
 CIterativeSolverIterator< 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
 CLDLT< class, int >
 CLinalgBackendBaseBase interface of generic linalg methods and generic memory transfer methods
 Clogistic< backend, Matrix >
 Clogistic< Backend::EIGEN3, Matrix >
 CMap< class, int, class >
 CMappedSparseMatrixMapped sparse matrix for representing graph relations of tasks
 CMatrix< class, int, int, int, int, int >
 CMaybe< T >Holder that represents an object that can be either present or absent. Quite simllar to std::optional introduced in C++14, but provides a way to pass the reason of absence (e.g. "incorrect parameter")
 CMixModelDataThis structure is used for storing data required for using the generic Expectation Maximization (EM) implemented by the template class CEMBase for mixture models like gaussian mixture model, multinomial mixture model etc. The EM specialized for mixture models is implemented by the class CEMMixtureModel which uses this MixModelData structure
 CModelClass Model
 Cmultiply_by_logistic_derivative< backend, Matrix >
 Cmultiply_by_logistic_derivative< Backend::EIGEN3, Matrix >
 Cmultiply_by_rectified_linear_derivative< backend, Matrix >
 Cmultiply_by_rectified_linear_derivative< Backend::EIGEN3, Matrix >
 CNbodyTreeNodeDataStructure to store data of a node of N-Body tree. This can be used as a template type in TreeMachineNode class. N-Body tree building algorithm uses nodes of type CBinaryTreeMachineNode<NbodyTreeNodeData>
 CNextSamplesClass NextSamples is the return type for next() call in DataManager. If there are no more samples (from any one of the distributions), an empty instance of NextSamples is supposed to be returned. This can be verified from the caller by calling the empty() method. Otherwise, always a get() call with appropriate index would give the samples from that distribution. If an inappropriate index is provided, e.g. get(2) for a two-sample test, a runtime exception is thrown
 Cnode< P >
 Cocl_operationClass ocl_operation for element-wise unary OpenCL operations for GPU-types (CGPUMatrix/CGPUVector)
 COneDistributionTestMeta test-type for 1-distribution statistical tests
 CParallelClass Parallel provides helper functions for multithreading
 CParameterStruct Parameter for wrapping up parameters to custom OpenCL operation strings. Supports string type, C-style string type and all basic types of parameters
 CParameterParameter class
 Crectified_linear< backend, Matrix >
 Crectified_linear< Backend::EIGEN3, Matrix >
 CSGIOClass SGIO, used to do input output operations throughout shogun
 CSGLinalgLinalg library backend
 CSGReferencedDataShogun reference count managed data
 CSGSparseVectorEntry< T >Template class SGSparseVectorEntry
 CSGSparseVectorEntry< float64_t >
 CSGSparseVectorEntry< ST >
 CSGString< T >Shogun string
 CSGString< char >
 CSGString< ST >
 CSGString< uint16_t >
 CSGString< uint8_t >
 CShogunExceptionClass ShogunException defines an exception which is thrown whenever an error inside of shogun occurs
 Csin< complex128_t >
 Csoftmax< backend, Matrix >
 Csoftmax< Backend::EIGEN3, Matrix >
 CSparsityStructureStruct that represents the sparsity structure of the Sparse Matrix in CRS. Implementation has been adapted from Krylstat ( Froskekongen/KRYLSTAT) library (c) Erlend Aune under GPL2+
 Csquared_error< backend, Matrix >
 Csquared_error< Backend::EIGEN3, Matrix >
 CStride< int, int >
 CsubstringStruct Substring, specified by start position and end position
 CThreeDistributionTestMeta test-type for 3-distribution statistical tests
 CTParameterParameter struct
 CTSGDataTypeDatatypes that shogun supports
 CTwoDistributionTestMeta test-type for 2-distribution statistical tests
 CUnique< T >
 CUnique< CMKL::Self >
 CUnique< shogun::CSGObject::Self >
 Cv_array< T >Class v_array taken directly from JL's implementation
 Cv_array< char >
 Cv_array< float >
 Cv_array< shogun::substring >
 Cv_array< shogun::VwFeature >
 Cv_array< vw_size_t >
 CVersionClass Version provides version information
 CVwExampleExample class for VW
 CVwFeatureOne feature in VW
 CVwLabelClass VwLabel holds a label object used by VW

SHOGUN Machine Learning Toolbox - Documentation