 |
Ginkgo
Generated from pipelines/1589998975 branch based on develop. Ginkgo version 1.10.0
A numerical linear algebra library targeting many-core architectures
|
|
Ginkgo
Generated from pipelines/1589998975 branch based on develop. Ginkgo version 1.10.0
A numerical linear algebra library targeting many-core architectures
|
| ►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 |
| CFactory | |
| Cparameters_type | |
| ►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 |
| CFactory | |
| Cparameters_type | |
| ►CCg | Cg or the Conjugate Gradient is a Krylov subspace solver |
| CFactory | |
| Cparameters_type | |
| 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 |
| CFactory | |
| Cparameters_type | |
| 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 |
| 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 |
| Ccommunicator | A thin wrapper of MPI_Comm that supports most MPI calls |
| Ccontiguous_type | A move-only wrapper for a contiguous MPI_Datatype |
| Cenvironment | Class that sets up and finalizes the MPI environment |
| 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 |
| CFactory | |
| Cparameters_type | |
| ►Nsolver | |
| ►CDirect | A direct solver based on a factorization into lower and upper triangular factors (with an optional diagonal scaling) |
| CFactory | |
| Cparameters_type | |
| ►Nfactorization | The Factorization namespace |
| ►CIc | Represents an incomplete Cholesky factorization (IC(0)) of a sparse matrix |
| CFactory | |
| Cparameters_type | |
| ►CIlu | Represents an incomplete LU factorization – ILU(0) – of a sparse matrix |
| CFactory | |
| Cparameters_type | |
| ►CParIc | ParIC is an incomplete Cholesky factorization which is computed in parallel |
| CFactory | |
| Cparameters_type | |
| ►CParIct | ParICT is an incomplete threshold-based Cholesky factorization which is computed in parallel |
| CFactory | |
| Cparameters_type | |
| ►CParIlu | ParILU is an incomplete LU factorization which is computed in parallel |
| CFactory | |
| Cparameters_type | |
| ►CParIlut | ParILUT is an incomplete threshold-based LU factorization which is computed in parallel |
| CFactory | |
| Cparameters_type | |
| ►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 |
| Cnested_summary_entry | |
| CNestedSummaryWriter | Receives the results from ProfilerHook::create_nested_summary() |
| Csummary_entry | |
| CSummaryWriter | Receives the results from ProfilerHook::create_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) |
| Cautomatical | |
| Cclassical | Classical is a strategy_type which uses the same number of threads on each row |
| Ccusparse | Cusparse is a strategy_type which uses the sparselib csr |
| Cload_balance | Load_balance is a strategy_type which uses the load balance algorithm |
| Cmerge_path | Merge_path is a strategy_type which uses the merge_path algorithm |
| Csparselib | Sparselib is a strategy_type which uses the sparselib csr |
| Cstrategy_type | Strategy_type is to decide how to set the csr algorithm |
| 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 |
| Cautomatic | Automatic is a strategy_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 strategy_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 strategy_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 |
| 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 |
| CFactory | |
| Cparameters_type | |
| CMultigridLevel | This class represents two levels in a multigrid hierarchy |
| ►CPgm | Parallel graph match (Pgm) is the aggregate method introduced in the paper M |
| CFactory | |
| Cparameters_type | |
| ►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) |
| CFactory | |
| Cparameters_type | |
| ►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) |
| CFactory | |
| Cparameters_type | |
| ►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 |
| CFactory | |
| Cparameters_type | |
| ►CJacobi | A block-Jacobi preconditioner is a block-diagonal linear operator, obtained by inverting the diagonal blocks of the source operator |
| CFactory | |
| Cparameters_type | |
| ►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 |
| CFactory | |
| Cparameters_type | |
| 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 |
| CFactory | |
| Cparameters_type | |
| ►CBicgstab | BiCGSTAB or the Bi-Conjugate Gradient-Stabilized is a Krylov subspace solver |
| CFactory | |
| Cparameters_type | |
| ►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 |
| 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 | |
| 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 |
| ►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 | |
| ►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 |
| 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 | |
| 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 |
| 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 | |
| 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 |
| CFactory | |
| Cparameters_type | |
| ►CMultigrid | Multigrid methods have a hierarchy of many levels, whose corase level is a subset of the fine level, of the problem |
| CFactory | |
| Cparameters_type | |
| CSolverBase | |
| ►CUpperTrs | UpperTrs is the triangular solver which solves the system U x = b, when U is an upper triangular matrix |
| CFactory | |
| Cparameters_type | |
| 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< Fcg< ValueType > > | |
| Cworkspace_traits< Gcr< ValueType > > | |
| Cworkspace_traits< gko::experimental::solver::Direct< ValueType, IndexType > > | |
| Cworkspace_traits< Gmres< ValueType > > | |
| Cworkspace_traits< Idr< ValueType > > | |
| Cworkspace_traits< Ir< ValueType > > | |
| Cworkspace_traits< LowerTrs< ValueType, IndexType > > | |
| Cworkspace_traits< Multigrid > | |
| 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 |
| CFactory | |
| Cparameters_type | |
| ►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 |
| ►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 |
| CFactory | |
| Cparameters_type | |
| ►CIteration | Stopping criterion which stops the iteration process after a preset number of iterations |
| CFactory | |
| Cparameters_type | |
| ►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 |
| CFactory | |
| Cparameters_type | |
| ►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 |
| CFactory | |
| Cparameters_type | |
| 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 |
| CFactory | |
| Cparameters_type | |
| ►CTime | Stopping criterion which stops the iteration process after a certain amount of time has passed |
| CFactory | |
| Cparameters_type | |
| ►Nsyn | The Synthesizer namespace |
| Crange | Range records start, end, step in template |
| Ctype_list | Type_list records several types in template |
| Cvalue_list | Value_list records several values with the same type in template |
| 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 |
| 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 + .. |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
1.8.16