Class List

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

Ngko	The Ginkgo namespace
Naccessor	The accessor namespace
Cabs_operation
Cabs_operaton
Cadd
Cbitwise_and
Cbitwise_not
Cbitwise_or
Cbitwise_xor
Cconj_operation
Cconj_operaton
Cdiv
Cequal
Cgreater
Cgreater_or_equal
Cimag_operation
Cimag_operaton
Cleft_shift
Cless
Cless_or_equal
Clogical_and
Clogical_not
Clogical_or
Cmax_operation
Cmin_operation
Cmmul_operation
Cmod
Cmul
Cnot_equal
Cone_operation
Cone_operaton
Creal_operation
Creal_operaton
Cright_shift
Crow_major	A row_major accessor is a bridge between a range and the row-major memory layout
Csquared_norm_operation
Csquared_norm_operaton
Csub
Ctranspose_operation
Cunary_minus
Cunary_plus
Czero_operation
Nbatch
Nlog	The logger namespace
CBatchConvergence	Logs the final residuals and iteration counts for a batch solver
Nmatrix
CCsr	Csr is a general sparse matrix format that stores the column indices for each nonzero entry and a cumulative sum of the number of nonzeros in each row
CDense	Dense is a batch matrix format which explicitly stores all values of the matrix in each of the batches
CEll	Ell is a sparse matrix format that stores the same number of nonzeros in each row, enabling coalesced accesses
CIdentity	The batch Identity matrix, which represents a batch of Identity matrices
Npreconditioner
CJacobi	A block-Jacobi preconditioner is a block-diagonal linear operator, obtained by inverting the diagonal blocks (stored in a dense row major fashion) of the source operator
Cparameters_type
CFactory
Nsolver
CBatchSolver	The BatchSolver is a base class for all batched solvers and provides the common getters and setter for these batched solver classes
CBicgstab	BiCGSTAB or the Bi-Conjugate Gradient-Stabilized is a Krylov subspace solver
Cparameters_type
CFactory
CCg	Cg or the Conjugate Gradient is a Krylov subspace solver
Cparameters_type
CFactory
Cenable_preconditioned_iterative_solver_factory_parameters
CEnableBatchSolver	This mixin provides apply and common iterative solver functionality to all the batched solvers
CBatchLinOp
CBatchLinOpFactory	A BatchLinOpFactory represents a higher order mapping which transforms one batch linear operator into another
CEnableBatchLinOp	The EnableBatchLinOp mixin can be used to provide sensible default implementations of the majority of the BatchLinOp and PolymorphicObject interface
CMultiVector	MultiVector stores multiple vectors in a batched fashion and is useful for batched operations
Nconfig
Cpnode	Pnode describes a tree of properties
Cregistry	This class stores additional context for creating Ginkgo objects from configuration files
Ctype_descriptor	This class describes the value and index types to be used when building a Ginkgo type from a configuration file
Nexperimental
Ndistributed	The distributed namespace
Npreconditioner	The Preconditioner namespace
CSchwarz	A Schwarz preconditioner is a simple domain decomposition preconditioner that generalizes the Block Jacobi preconditioner, incorporating options for different local subdomain solvers and overlaps between the subdomains
Cparameters_type
CFactory
CDistributedBase	A base class for distributed objects
Cindex_map	This class defines mappings between global and local indices
CMatrix	The Matrix class defines a (MPI-)distributed matrix
CPartition	Represents a partition of a range of indices [0, size) into a disjoint set of parts
CRowGatherer	The distributed::RowGatherer gathers the rows of distributed::Vector that are located on other processes
CVector	Vector is a format which explicitly stores (multiple) distributed column vectors in a dense storage format
Nfactorization
CCholesky	Computes a Cholesky factorization of a symmetric, positive-definite sparse matrix
Cparameters_type
CFactorization	Represents a generic factorization consisting of two triangular factors (upper and lower) and an optional diagonal scaling matrix
CLu	Computes an LU factorization of a sparse matrix
Cparameters_type
Nmpi	The mpi namespace, contains wrapper for many MPI functions
CCollectiveCommunicator	Interface for a collective communicator
Ccommunicator	A thin wrapper of MPI_Comm that supports most MPI calls
Ccontiguous_type	A move-only wrapper for a contiguous MPI_Datatype
CDenseCommunicator	A CollectiveCommunicator that uses a dense communication
Cenvironment	Class that sets up and finalizes the MPI environment
CNeighborhoodCommunicator	A CollectiveCommunicator that uses a neighborhood topology
Crequest	Light, move-only wrapper around the MPI_Request handle
Cstatus	The status struct is a light wrapper around the MPI_Status struct
Ctype_impl	A struct that is used to determine the MPI_Datatype of a specified type
Ctype_impl< char >
Ctype_impl< double >
Ctype_impl< float >
Ctype_impl< int >
Ctype_impl< long >
Ctype_impl< long double >
Ctype_impl< long long >
Ctype_impl< unsigned >
Ctype_impl< unsigned char >
Ctype_impl< unsigned long >
Ctype_impl< unsigned long long >
Ctype_impl< unsigned short >
Cwindow	This class wraps the MPI_Window class with RAII functionality
Nreorder	The Reorder namespace
CAmd	Computes a Approximate Minimum Degree (AMD) reordering of an input matrix
Cparameters_type
CMc64	MC64 is an algorithm for permuting large entries to the diagonal of a sparse matrix
Cparameters_type
CRcm	Rcm (Reverse Cuthill-McKee) is a reordering algorithm minimizing the bandwidth of a matrix
Cparameters_type
CScaledReordered	Provides an interface to wrap reorderings like Rcm and diagonal scaling like equilibration around a LinOp like e.g
Cparameters_type
CFactory
Nsolver
CDirect	A direct solver based on a factorization into lower and upper triangular factors (with an optional diagonal scaling)
Cparameters_type
CFactory
Nfactorization	The Factorization namespace
CIc	Represents an incomplete Cholesky factorization (IC(0)) of a sparse matrix
Cparameters_type
CFactory
CIlu	Represents an incomplete LU factorization – ILU(0) – of a sparse matrix
Cparameters_type
CFactory
CParIc	ParIC is an incomplete Cholesky factorization which is computed in parallel
Cparameters_type
CFactory
CParIct	ParICT is an incomplete threshold-based Cholesky factorization which is computed in parallel
Cparameters_type
CFactory
CParIlu	ParILU is an incomplete LU factorization which is computed in parallel
Cparameters_type
CFactory
CParIlut	ParILUT is an incomplete threshold-based LU factorization which is computed in parallel
Cparameters_type
CFactory
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
CPapi	Papi is a Logger which logs every event to the PAPI software
CPerformanceHint	PerformanceHint is a Logger which analyzes the performance of the application and outputs hints for unnecessary copies and allocations
Cpolymorphic_object_data	Struct representing PolymorphicObject related data
CProfilerHook	This Logger can be used to annotate the execution of Ginkgo functionality with profiler-specific ranges
Csummary_entry
Cnested_summary_entry
CSummaryWriter	Receives the results from ProfilerHook::create_summary()
CNestedSummaryWriter	Receives the results from ProfilerHook::create_nested_summary()
CTableSummaryWriter	Writes the results from ProfilerHook::create_summary() and ProfilerHook::create_nested_summary() to a ASCII table in Markdown format
Cprofiling_scope_guard	Scope guard that annotates its scope with the provided profiler hooks
CRecord	Record is a Logger which logs every event to an object
Clogged_data	Struct storing the actually logged data
CSolverProgress	This Logger outputs the value of all scalar values (and potentially vectors) stored internally by the solver after each iteration
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
CCooBuilder
CCsr	CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matrix (compressed sparse row format)
Cstrategy_type	Strategy_type is to decide how to set the csr algorithm
Cclassical	Classical is a strategy_type which uses the same number of threads on each row
Cmerge_path	Merge_path is a strategy_type which uses the merge_path algorithm
Ccusparse	Cusparse is a strategy_type which uses the sparselib csr
Csparselib	Sparselib is a strategy_type which uses the sparselib csr
Cload_balance	Load_balance is a strategy_type which uses the load balance algorithm
Cautomatical
Cmultiply_reuse_info	Class describing the internal lookup structures created by multiply_reuse(const Csr*) to recompute a sparse matrix-matrix product with updated values
Cmultiply_add_reuse_info	Class describing the internal lookup structures created by multiply_add_reuse to recompute a sparse matrix-matrix product with updated values
Cscale_add_reuse_info	Class describing the internal lookup structures created by scale_add_reuse to recompute a sparse matrix-matrix sum with updated values
Cpermuting_reuse_info	A struct describing a transformation of the matrix that reorders the values of the matrix into the transformed matrix
CCsrBuilder
CDense	Dense is a matrix format which explicitly stores all values of the matrix
CDiagonal	This class is a utility which efficiently implements the diagonal matrix (a linear operator which scales a vector row wise)
CEll	ELL is a matrix format where stride with explicit zeros is used such that all rows have the same number of stored elements
CFbcsr	Fixed-block compressed sparse row storage matrix format
CFbcsrBuilder
CFft	This LinOp implements a 1D Fourier matrix using the FFT algorithm
CFft2	This LinOp implements a 2D Fourier matrix using the FFT algorithm
CFft3	This LinOp implements a 3D Fourier matrix using the FFT algorithm
CHybrid	HYBRID is a matrix format which splits the matrix into ELLPACK and COO format
Cstrategy_type	Strategy_type is to decide how to set the hybrid config
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_limit	Imbalance_limit is a strategy_type which decides the number of stored elements per row of the ell part according to the percent
Cimbalance_bounded_limit	Imbalance_bounded_limit is a strategy_type which decides the number of stored elements per row of the ell part
Cminimal_storage_limit	Minimal_storage_limit is a strategy_type which decides the number of stored elements per row of the ell part
Cautomatic	Automatic is a strategy_type which decides the number of stored elements per row of the ell part automatically
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
CPermutation	Permutation is a matrix format that represents a permutation matrix, i.e
CRowGatherer	RowGatherer is a matrix "format" which stores the gather indices arrays which can be used to gather rows to another matrix
CScaledPermutation	ScaledPermutation is a matrix combining a permutation with scaling factors
CSellp	SELL-P is a matrix format similar to ELL format
CSparsityCsr	SparsityCsr is a matrix format which stores only the sparsity pattern of a sparse matrix by compressing each row of the matrix (compressed sparse row format)
Nmultigrid	The multigrid components namespace
CEnableMultigridLevel	The EnableMultigridLevel gives the default implementation of MultigridLevel with composition and provides set_multigrid_level function
CFixedCoarsening	FixedCoarsening is a very simple coarse grid generation algorithm
Cparameters_type
CFactory
CMultigridLevel	This class represents two levels in a multigrid hierarchy
CPgm	Parallel graph match (Pgm) is the aggregate method introduced in the paper M
Cparameters_type
CFactory
Npreconditioner	The Preconditioner namespace
Cblock_interleaved_storage_scheme	Defines the parameters of the interleaved block storage scheme used by block-Jacobi blocks
CGaussSeidel	This class generates the Gauss-Seidel preconditioner
Cparameters_type
CIc	The Incomplete Cholesky (IC) preconditioner solves the equation for a given lower triangular matrix L and the right hand side b (can contain multiple right hand sides)
Cparameters_type
CFactory
CIlu	The Incomplete LU (ILU) preconditioner solves the equation for a given lower triangular matrix L, an upper triangular matrix U and the right hand side b (can contain multiple right hand sides)
Cparameters_type
CFactory
CIsai	The Incomplete Sparse Approximate Inverse (ISAI) Preconditioner generates an approximate inverse matrix for a given square matrix A, lower triangular matrix L, upper triangular matrix U or symmetric positive (spd) matrix B
Cparameters_type
CFactory
CJacobi	A block-Jacobi preconditioner is a block-diagonal linear operator, obtained by inverting the diagonal blocks of the source operator
Cparameters_type
CFactory
CSor	This class generates the (S)SOR preconditioner
Cparameters_type
Nreorder	The Reorder namespace
CRcm	Rcm (Reverse Cuthill-McKee) is a reordering algorithm minimizing the bandwidth of a matrix
Cparameters_type
CFactory
CReorderingBase	The ReorderingBase class is a base class for all the reordering algorithms
CReorderingBaseArgs	This struct is used to pass parameters to the EnableDefaultReorderingBaseFactory::generate() method
Nsolver	The ginkgo Solve namespace
CApplyWithInitialGuess	ApplyWithInitialGuess provides a way to give the input guess for apply function
CBicg	BICG or the Biconjugate gradient method is a Krylov subspace solver
Cparameters_type
CFactory
CBicgstab	BiCGSTAB or the Bi-Conjugate Gradient-Stabilized is a Krylov subspace solver
Cparameters_type
CFactory
CCbGmres	CB-GMRES or the compressed basis generalized minimal residual method is an iterative type Krylov subspace method which is suitable for nonsymmetric linear systems
Cparameters_type
CFactory
CCg	CG or the conjugate gradient method is an iterative type Krylov subspace method which is suitable for symmetric positive definite methods
Cparameters_type
CFactory
CCgs	CGS or the conjugate gradient square method is an iterative type Krylov subspace method which is suitable for general systems
Cparameters_type
CFactory
CChebyshev	Chebyshev iteration is an iterative method for solving nonsymmetric problems based on some knowledge of the spectrum of the (preconditioned) system matrix
Cparameters_type
CFactory
Cenable_iterative_solver_factory_parameters
Cenable_preconditioned_iterative_solver_factory_parameters
CEnableApplyWithInitialGuess	EnableApplyWithInitialGuess providing default operation for ApplyWithInitialGuess with correct validation and log
CEnableIterativeBase	A LinOp deriving from this CRTP class stores a stopping criterion factory and allows applying with a guess
CEnablePreconditionable	Mixin providing default operation for Preconditionable with correct value semantics
CEnablePreconditionedIterativeSolver	A LinOp implementing this interface stores a system matrix and stopping criterion factory
CEnableSolverBase	A LinOp deriving from this CRTP class stores a system matrix
CFactory
CFcg	FCG or the flexible conjugate gradient method is an iterative type Krylov subspace method which is suitable for symmetric positive definite methods
Cparameters_type
CFactory
CGcr	GCR or the generalized conjugate residual method is an iterative type Krylov subspace method similar to GMRES which is suitable for nonsymmetric linear systems
Cparameters_type
CFactory
CGmres	GMRES or the generalized minimal residual method is an iterative type Krylov subspace method which is suitable for nonsymmetric linear systems
Cparameters_type
CFactory
Chas_with_criteria	Helper structure to test if the Factory of SolverType has a function with_criteria
CIdr	IDR(s) is an efficient method for solving large nonsymmetric systems of linear equations
Cparameters_type
CFactory
CIterativeBase	A LinOp implementing this interface stores a stopping criterion factory
CLowerTrs	LowerTrs is the triangular solver which solves the system L x = b, when L is a lower triangular matrix
Cparameters_type
CFactory
CMinres	Minres is an iterative type Krylov subspace method, which is suitable for indefinite and full-rank symmetric/hermitian operators
Cparameters_type
CFactory
CMultigrid	Multigrid methods have a hierarchy of many levels, whose corase level is a subset of the fine level, of the problem
Cparameters_type
CFactory
Cparameters_type
CPipeCg	PIPE_CG or the pipelined conjugate gradient method is an iterative type Krylov subspace method which is suitable for symmetric positive definite methods
Cparameters_type
CFactory
CSolverBase
CUpperTrs	UpperTrs is the triangular solver which solves the system U x = b, when U is an upper triangular matrix
Cparameters_type
CFactory
Cworkspace_traits	Traits class providing information on the type and location of workspace vectors inside a solver
Cworkspace_traits< Bicg< ValueType > >
Cworkspace_traits< Bicgstab< ValueType > >
Cworkspace_traits< Cg< ValueType > >
Cworkspace_traits< Cgs< ValueType > >
Cworkspace_traits< Chebyshev< ValueType > >
Cworkspace_traits< Fcg< ValueType > >
Cworkspace_traits< Gcr< ValueType > >
Cworkspace_traits< gko::experimental::solver::Direct< ValueType, IndexType > >
Cworkspace_traits< Gmres< ValueType > >
Cworkspace_traits< Idr< ValueType > >
Cworkspace_traits< LowerTrs< ValueType, IndexType > >
Cworkspace_traits< Minres< ValueType > >
Cworkspace_traits< Multigrid >
Cworkspace_traits< PipeCg< ValueType > >
Cworkspace_traits< UpperTrs< ValueType, IndexType > >
Nstop	The Stopping criterion namespace
CAbsoluteResidualNorm	The AbsoluteResidualNorm class is a stopping criterion which stops the iteration process when the residual norm is below a certain threshold, i.e
Cparameters_type
CFactory
CCombined	Used to combine multiple criterions together through an OR operation
Cparameters_type
CFactory
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
CImplicitResidualNorm	The ImplicitResidualNorm class is a stopping criterion which stops the iteration process when the implicit residual norm is below a certain threshold relative to
Cparameters_type
CFactory
CIteration	Stopping criterion which stops the iteration process after a preset number of iterations
Cparameters_type
CFactory
CRelativeResidualNorm	The RelativeResidualNorm class is a stopping criterion which stops the iteration process when the residual norm is below a certain threshold relative to the norm of the right-hand side, i.e
Cparameters_type
CFactory
CResidualNorm	The ResidualNorm class is a stopping criterion which stops the iteration process when the actual residual norm is below a certain threshold relative to
Cparameters_type
CFactory
CResidualNormBase	The ResidualNormBase class provides a framework for stopping criteria related to the residual norm
CResidualNormReduction	The ResidualNormReduction class is a stopping criterion which stops the iteration process when the residual norm is below a certain threshold relative to the norm of the initial residual, i.e
Cparameters_type
CFactory
CTime	Stopping criterion which stops the iteration process after a certain amount of time has passed
Cparameters_type
CFactory
Nsyn	The Synthesizer namespace
Cvalue_list	Value_list records several values with the same type in template
Ctype_list	Type_list records several types in template
Crange	Range records start, end, step in template
Nxstd	The namespace for functionalities after C++14 standard
Ctype_identity
CAbsoluteComputable	The AbsoluteComputable is an interface that allows to get the component wise absolute of a LinOp
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
CAllocator	Provides generic allocation and deallocation functionality to be used by an Executor
Camd_device	Amd_device handles the number of executor on Amd devices and have the corresponding recursive_mutex
Care_all_integral	Evaluates if all template arguments Args fulfill std::is_integral
Care_all_integral< First, Args... >
Carray	An array is a container which encapsulates fixed-sized arrays, stored on the Executor tied to the array
CBadDimension	BadDimension is thrown if an operation is being applied to a LinOp with bad dimensions
Cbatch_dim	A type representing the dimensions of a multidimensional batch object
Cbfloat16	A class providing basic support for bfloat16 precision floating point types
CBlockOperator	A BlockOperator represents a linear operator that is partitioned into multiple blocks
CBlockSizeError	Error that denotes issues between block sizes and matrix dimensions
CCombination	The Combination class can be used to construct a linear combination of multiple linear operators c1 * op1 + c2 * op2 + ... + ck * opk
CComposition	The Composition class can be used to compose linear operators op1, op2, ..., opn and obtain the operator op1 * op2 * ... * opn
CCpuAllocator	Allocator using new/delete
CCpuAllocatorBase	Implement this interface to provide an allocator for OmpExecutor or ReferenceExecutor
CCpuTimer	A timer using std::chrono::steady_clock for timing
Ccpx_real_type	Access the underlying real type of a complex number
CCublasError	CublasError is thrown when a cuBLAS routine throws a non-zero error code
Ccuda_stream	An RAII wrapper for a custom CUDA stream
CCudaAllocator	Allocator using cudaMalloc
CCudaAllocatorBase	Implement this interface to provide an allocator for CudaExecutor
CCudaAsyncAllocator
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
CCudaHostAllocator
CCudaTimer	A timer using events for timing on a CudaExecutor
CCudaUnifiedAllocator
CCufftError	CufftError is thrown when a cuFFT routine throws a non-zero error code
CCurandError	CurandError is thrown when a cuRAND routine throws a non-zero error code
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
Cdeferred_factory_parameter	Represents a factory parameter of factory type that can either initialized by a pre-existing factory or by passing in a factory_parameters object whose .on(exec) will be called to instantiate a factory
Cdevice_matrix_data	This type is a device-side equivalent to matrix_data
Carrays	Stores the internal arrays of a device_matrix_data object
CDiagonalExtractable	The diagonal of a LinOp implementing this interface can be extracted
CDiagonalLinOpExtractable	The diagonal of a LinOp can be extracted
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
CDpcppExecutor	This is the Executor subclass which represents a DPC++ enhanced device
CDpcppTimer	A timer using kernels for timing on a DpcppExecutor in profiling mode
Cenable_parameters_type	The enable_parameters_type mixin is used to create a base implementation of the factory parameters structure
CEnableAbsoluteComputation	The EnableAbsoluteComputation mixin provides the default implementations of compute_absolute_linop and the absolute interface
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
Cerr
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[]>
Chalf	A class providing basic support for half precision floating point types
Chip_stream	An RAII wrapper for a custom HIP stream
CHipAllocator
CHipAllocatorBase	Implement this interface to provide an allocator for HipExecutor
CHipAsyncAllocator
CHipblasError	HipblasError is thrown when a hipBLAS routine throws a non-zero error code
CHipError	HipError is thrown when a HIP routine throws a non-zero error code
CHipExecutor	This is the Executor subclass which represents the HIP enhanced device
CHipfftError	HipfftError is thrown when a hipFFT routine throws a non-zero error code
CHipHostAllocator
CHiprandError	HiprandError is thrown when a hipRAND routine throws a non-zero error code
CHipsparseError	HipsparseError is thrown when a hipSPARSE routine throws a non-zero error code
CHipTimer	A timer using events for timing on a HipExecutor
CHipUnifiedAllocator
Cindex_set	An index set class represents an ordered set of intervals
CInvalidStateError	Exception thrown if an object is in an invalid state
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
Clocal_span	A span that is used exclusively for local numbering
Cmachine_topology	The machine topology class represents the hierarchical topology of a machine, including NUMA nodes, cores and PCI Devices
Cmatrix_assembly_data	This structure is used as an intermediate type to assemble a sparse matrix
Cmatrix_data	This structure is used as an intermediate data type to store a sparse matrix
Cmatrix_data_entry	Type used to store nonzeros
CMetisError	MetisError is thrown when METIS routine throws an error code
CMpiError	MpiError is thrown when a MPI routine throws a non-zero error code
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[]>
Cnvidia_device	Nvidia_device handles the number of executor on Nvidia devices and have the corresponding recursive_mutex
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
COverflowError	OverflowError is thrown when an index calculation for storage requirements overflows
CPermutable	Linear operators which support permutation should implement the Permutable interface
CPerturbation	The Perturbation class can be used to construct a LinOp to represent the operation (identity + scalar * basis * projector)
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
Cptr_param	This class is used for function parameters in the place of raw pointers
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
CScaledIdentityAddable	Adds the operation M <- a I + b M for matrix M, identity operator I and scalars a and b, where M is the calling object
Cscoped_device_id_guard	This move-only class uses RAII to set the device id within a scoped block, if necessary
Csegmented_array	A minimal interface for a segmented array
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
Ctime_point	An opaque wrapper for a time point generated by a timer
CTimer	Represents a generic timer that can be used to record time points and measure time differences on host or device streams
CTransposable	Linear operators which support transposition should implement the Transposable interface
Ctruncated
CUnsupportedMatrixProperty	Exception throws if a matrix does not have a property required by a numerical method
CUseComposition	The UseComposition class can be used to store the composition information in LinOp
CValueMismatch	ValueMismatch is thrown if two values are not equal
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
Chwloc_obj_t
Chwloc_obj_type_t