Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

▼Ngko	The Ginkgo namespace
►Naccessor	The accessor namespace
Cabs_operaton
Cadd
Cbitwise_and
Cbitwise_not
Cbitwise_or
Cbitwise_xor
Cconj_operaton
Cdiv
Cequal
Cgreater
Cgreater_or_equal
Cimag_operaton
Cleft_shift
Cless
Cless_or_equal
Clogical_and
Clogical_not
Clogical_or
Cmax_operaton
Cmin_operaton
Cmmul_operation
Cmod
Cmul
Cnot_equal
Cone_operaton
Creal_operaton
Cright_shift
Crow_major	A row_major accessor is a bridge between a range and the row-major memory layout
Csquared_norm_operaton
Csub
Ctranspose_operation
Cunary_minus
Cunary_plus
Czero_operation
►Nlog	The logger namespace
CConvergence	Convergence is a Logger which logs data strictly from the criterion_check_completed event
Ccriterion_data	Struct representing Criterion related data
CEnableLogging	EnableLogging is a mixin which should be inherited by any class which wants to enable logging
Cexecutor_data	Struct representing Executor related data
Citeration_complete_data	Struct representing iteration complete related data
Clinop_data	Struct representing LinOp related data
Clinop_factory_data	Struct representing LinOp factory related data
CLoggable	Loggable class is an interface which should be implemented by classes wanting to support logging
CLogger
Coperation_data	Struct representing Operator related data
Cpolymorphic_object_data	Struct representing PolymorphicObject related data
►CRecord	Record is a Logger which logs every event to an object
Clogged_data	Struct storing the actually logged data
CStream	Stream is a Logger which logs every event to a stream
►Nmatrix	The matrix namespace
CCoo	COO stores a matrix in the coordinate matrix format
►CCsr	CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matrix (compressed sparse row format)
Cautomatical
Cclassical
Ccusparse
Cload_balance
Cmerge_path
Cstrategy_type
CDense	Dense is a matrix format which explicitly stores all values of the matrix
CEll	ELL is a matrix format where stride with explicit zeros is used such that all rows have the same number of stored elements
►CHybrid	HYBRID is a matrix format which splits the matrix into ELLPACK and COO format
Cautomatic	Automatic is a stratgy_type which decides the number of stored elements per row of the ell part automatically
Ccolumn_limit	Column_limit is a strategy_type which decides the number of stored elements per row of the ell part by specifying the number of columns
Cimbalance_bounded_limit	Imbalance_bounded_limit is a stratgy_type which decides the number of stored elements per row of the ell part
Cimbalance_limit	Imbalance_limit is a strategy_type which decides the number of stored elements per row of the ell part according to the percent
Cminimal_storage_limit	Minimal_storage_limit is a stratgy_type which decides the number of stored elements per row of the ell part
Cstrategy_type	Strategy_type is to decide how to set the hybrid config
CIdentity	This class is a utility which efficiently implements the identity matrix (a linear operator which maps each vector to itself)
CIdentityFactory	This factory is a utility which can be used to generate Identity operators
CSellp	SELL-P is a matrix format similar to ELL format
►Npreconditioner	The Preconditioner namespace
Cblock_interleaved_storage_scheme	Defines the parameters of the interleaved block storage scheme used by block-Jacobi blocks
►CJacobi	A block-Jacobi preconditioner is a block-diagonal linear operator, obtained by inverting the diagonal blocks of the source operator
CFactory
Cparameters_type
►Nsolver	The ginkgo Solve namespace
►CBicgstab	BiCGSTAB or the Bi-Conjugate Gradient-Stabilized is a Krylov subspace solver
CFactory
Cparameters_type
►CCg	CG or the conjugate gradient method is an iterative type Krylov subspace method which is suitable for symmetric positive definite methods
CFactory
Cparameters_type
►CCgs	CGS or the conjugate gradient square method is an iterative type Krylov subspace method which is suitable for general systems
CFactory
Cparameters_type
►CFcg	FCG or the flexible conjugate gradient method is an iterative type Krylov subspace method which is suitable for symmetric positive definite methods
CFactory
Cparameters_type
►CGmres	GMRES or the generalized minimal residual method is an iterative type Krylov subspace method which is suitable for nonsymmetric linear systems
CFactory
Cparameters_type
►CIr	Iterative refinement (IR) is an iterative method that uses another coarse method to approximate the error of the current solution via the current residual
CFactory
Cparameters_type
►Nstop	The Stopping criterion namespace
►CCombined	Used to combine multiple criterions together through an OR operation
CFactory
Cparameters_type
►CCriterion	Base class for all stopping criteria
CUpdater	Serves for convenient argument passing to the Criterion's check function
CCriterionArgs	This struct is used to pass parameters to the EnableDefaultCriterionFactoryCriterionFactory::generate() method
►CIteration	Stopping criterion which stops the iteration process after a preset number of iterations
CFactory
Cparameters_type
►CResidualNormReduction	The ResidualNormReduction class is a stopping criterion which stops the iteration process when the relative residual norm is below a certain threshold
CFactory
Cparameters_type
►CTime	Stopping criterion which stops the iteration process after a certain amout of time has passed
CFactory
Cparameters_type
►Nsyn	The Synthesizer namespace
Crange
Ctype_list
Cvalue_list
CAbstractFactory	The AbstractFactory is a generic interface template that enables easy implementation of the abstract factory design pattern
CAllocationError	AllocationError is thrown if a memory allocation fails
CArray	An Array is a container which encapsulates fixed-sized arrays, stored on the Executor tied to the Array
CCombination	The Combination class can be used to construct a linear combination of multiple linear operators `c1 * op1 + c2 * op2 + ..
CComposition	The Composition class can be used to compose linear operators op1, op2, ..., opn and obtain the operator `op1 * op2 * ..
CConvertibleTo	ConvertibleTo interface is used to mark that the implementer can be converted to the object of ResultType
Ccopy_back_deleter	A copy_back_deleter is a type of deleter that copies the data to an internally referenced object before performing the deletion
Ccopy_back_deleter< const T >
CCublasError	CublasError is thrown when a cuBLAS routine throws a non-zero error code
CCudaError	CudaError is thrown when a CUDA routine throws a non-zero error code
CCudaExecutor	This is the Executor subclass which represents the CUDA device
CCusparseError	CusparseError is thrown when a cuSPARSE routine throws a non-zero error code
Cdefault_converter	Used to convert objects of type S to objects of type R using static_cast
Cdim	A type representing the dimensions of a multidimensional object
Cdim< 1u, DimensionType >
CDimensionMismatch	DimensionMismatch is thrown if an operation is being applied to LinOps of incompatible size
Cenable_parameters_type	The enable_parameters_type mixin is used to create a base implementation of the factory parameters structure
CEnableAbstractPolymorphicObject	This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a new abstract object
CEnableCreateMethod	This mixin implements a static create() method on ConcreteType that dynamically allocates the memory, uses the passed-in arguments to construct the object, and returns an std::unique_ptr to such an object
CEnableDefaultFactory	This mixin provides a default implementation of a concrete factory
CEnableLinOp	The EnableLinOp mixin can be used to provide sensible default implementations of the majority of the LinOp and PolymorphicObject interface
CEnablePolymorphicAssignment	This mixin is used to enable a default PolymorphicObject::copy_from() implementation for objects that have implemented conversions between them
CEnablePolymorphicObject	This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a new concrete polymorphic object
CError	Used to report exceptional behaviour in library functions
CExecutor	The first step in using the Ginkgo library consists of creating an executor
Cexecutor_deleter	This is a deleter that uses an executor's free method to deallocate the data
Cexecutor_deleter< T[]>
CKernelNotFound	KernelNotFound is thrown if Ginkgo cannot find a kernel which satisfies the criteria imposed by the input arguments
CLinOp
CLinOpFactory	A LinOpFactory represents a higher order mapping which transforms one linear operator into another
►Cmatrix_data	This structure is used as an intermediate data type to store a sparse matrix
Cnonzero_type	Type used to store nonzeros
CNotCompiled	NotCompiled is thrown when attempting to call an operation which is a part of a module that was not compiled on the system
CNotImplemented	NotImplemented is thrown in case an operation has not yet been implemented (but will be implemented in the future)
CNotSupported	NotSupported is thrown in case it is not possible to perform the requested operation on the given object type
Cnull_deleter	This is a deleter that does not delete the object
Cnull_deleter< T[]>
COmpExecutor	This is the Executor subclass which represents the OpenMP device (typically CPU)
COperation	Operations can be used to define functionalities whose implementations differ among devices
COutOfBoundsError	OutOfBoundsError is thrown if a memory access is detected to be out-of-bounds
CPolymorphicObject	A PolymorphicObject is the abstract base for all "heavy" objects in Ginkgo that behave polymorphically
Cprecision_reduction	This class is used to encode storage precisions of low precision algorithms
CPreconditionable	A LinOp implementing this interface can be preconditioned
Crange	A range is a multidimensional view of the memory
CReadableFromMatrixData	A LinOp implementing this interface can read its data from a matrix_data structure
CReferenceExecutor	This is a specialization of the OmpExecutor, which runs the reference implementations of the kernels used for debugging purposes
Cspan	A span is a lightweight structure used to create sub-ranges from other ranges
Cstopping_status	This class is used to keep track of the stopping status of one vector
CStreamError	StreamError is thrown if accessing a stream failed
Ctemporary_clone	A temporary_clone is a special smart pointer-like object that is designed to hold an object temporarily copied to another executor
CTransposable	Linear operators which support transposition should implement the Transposable interface
Ctruncated
Cversion	This structure is used to represent versions of various Ginkgo modules
Cversion_info	Ginkgo uses version numbers to label new features and to communicate backward compatibility guarantees:
CWritableToMatrixData	A LinOp implementing this interface can write its data to a matrix_data structure