C gko::AbsoluteComputable The AbsoluteComputable is an interface that allows to get the component wise absolute of a LinOp
C gko::EnableAbsoluteComputation< remove_complex< Vector< double > > >
C gko::experimental::distributed::Vector< ValueType > Vector is a format which explicitly stores (multiple) distributed column vectors in a dense storage format
C gko::EnableAbsoluteComputation< remove_complex< Coo< default_precision, int32 > > >
C gko::matrix::Coo< ValueType, IndexType > COO stores a matrix in the coordinate matrix format
C gko::EnableAbsoluteComputation< remove_complex< Csr< default_precision, int32 > > >
C gko::matrix::Csr< ValueType, IndexType > CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matrix (compressed sparse row format)
C gko::EnableAbsoluteComputation< remove_complex< Dense< default_precision > > >
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::EnableAbsoluteComputation< remove_complex< Diagonal< default_precision > > >
C gko::matrix::Diagonal< ValueType > This class is a utility which efficiently implements the diagonal matrix (a linear operator which scales a vector row wise)
C gko::EnableAbsoluteComputation< remove_complex< Ell< default_precision, int32 > > >
C gko::matrix::Ell< ValueType, IndexType > ELL is a matrix format where stride with explicit zeros is used such that all rows have the same number of stored elements
C gko::EnableAbsoluteComputation< remove_complex< Fbcsr< default_precision, int32 > > >
C gko::matrix::Fbcsr< ValueType, IndexType > Fixed-block compressed sparse row storage matrix format
C gko::EnableAbsoluteComputation< remove_complex< Hybrid< default_precision, int32 > > >
C gko::matrix::Hybrid< ValueType, IndexType > HYBRID is a matrix format which splits the matrix into ELLPACK and COO format
C gko::EnableAbsoluteComputation< remove_complex< Sellp< default_precision, int32 > > >
C gko::matrix::Sellp< ValueType, IndexType > SELL-P is a matrix format similar to ELL format
C gko::EnableAbsoluteComputation< AbsoluteLinOp > The EnableAbsoluteComputation mixin provides the default implementations of compute_absolute_linop and the absolute interface
C gko::experimental::distributed::Vector< ValueType >
C gko::experimental::distributed::Vector< to_complex< value_type > >
C gko::experimental::distributed::Vector< previous_precision< ValueType > >
C gko::matrix::Coo< ValueType, IndexType >
C gko::matrix::Csr< value_type, index_type >
C gko::matrix::Csr< ValueType, IndexType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Diagonal< ValueType >
C gko::matrix::Ell< value_type, index_type >
C gko::matrix::Ell< ValueType, IndexType >
C gko::matrix::Fbcsr< ValueType, IndexType >
C gko::Allocator Provides generic allocation and deallocation functionality to be used by an Executor
C gko::CpuAllocatorBase Implement this interface to provide an allocator for OmpExecutor or ReferenceExecutor
C gko::CpuAllocator Allocator using new/delete
C gko::CudaHostAllocator
C gko::CudaUnifiedAllocator
C gko::HipHostAllocator
C gko::HipUnifiedAllocator
C gko::CudaAllocatorBase Implement this interface to provide an allocator for CudaExecutor
C gko::CudaAllocator Allocator using cudaMalloc
C gko::CudaAsyncAllocator
C gko::CudaHostAllocator
C gko::CudaUnifiedAllocator
C gko::HipAllocatorBase Implement this interface to provide an allocator for HipExecutor
C gko::HipAllocator
C gko::HipAsyncAllocator
C gko::HipHostAllocator
C gko::HipUnifiedAllocator
C gko::amd_device Amd_device handles the number of executor on Amd devices and have the corresponding recursive_mutex
C gko::solver::ApplyWithInitialGuess ApplyWithInitialGuess provides a way to give the input guess for apply function
C gko::solver::EnableApplyWithInitialGuess< Chebyshev< default_precision > >
C gko::solver::Chebyshev< ValueType > Chebyshev iteration is an iterative method for solving nonsymmetric problems based on some knowledge of the spectrum of the (preconditioned) system matrix
C gko::solver::EnableApplyWithInitialGuess< Ir< default_precision > >
C gko::solver::Ir< ValueType > Iterative refinement (IR) is an iterative method that uses another coarse method to approximate the error of the current solution via the current residual
C gko::solver::EnableApplyWithInitialGuess< Multigrid >
C gko::solver::Multigrid Multigrid methods have a hierarchy of many levels, whose corase level is a subset of the fine level, of the problem
C gko::solver::EnableApplyWithInitialGuess< DerivedType > EnableApplyWithInitialGuess providing default operation for ApplyWithInitialGuess with correct validation and log
C gko::solver::Chebyshev< ValueType >
C gko::solver::Ir< ValueType >
C gko::array< ValueType > An array is a container which encapsulates fixed-sized arrays, stored on the Executor tied to the array
C gko::device_matrix_data< ValueType, IndexType >::arrays Stores the internal arrays of a device_matrix_data object
C gko::batch_dim< Dimensionality, DimensionType > A type representing the dimensions of a multidimensional batch object
C BatchLinOp
C gko::EnableAbstractPolymorphicObject< ConcreteBatchLinOp, BatchLinOp >
C gko::EnablePolymorphicObject< ConcreteBatchLinOp, BatchLinOp >
C gko::batch::EnableBatchLinOp< ConcreteBatchLinOp, PolymorphicBase > The EnableBatchLinOp mixin can be used to provide sensible default implementations of the majority of the BatchLinOp and PolymorphicObject interface
C gko::batch::matrix::Csr< ValueType, IndexType >
C gko::batch::matrix::Dense< ValueType >
C gko::EnableAbstractPolymorphicObject< Csr< default_precision, int32 >, BatchLinOp >
C gko::EnablePolymorphicObject< Csr< default_precision, int32 >, BatchLinOp >
C gko::batch::EnableBatchLinOp< Csr< default_precision, int32 > >
C gko::batch::matrix::Csr< ValueType, IndexType > 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
C gko::EnableAbstractPolymorphicObject< Dense< default_precision >, BatchLinOp >
C gko::EnablePolymorphicObject< Dense< default_precision >, BatchLinOp >
C gko::batch::EnableBatchLinOp< Dense< default_precision > >
C gko::batch::matrix::Dense< ValueType > Dense is a batch matrix format which explicitly stores all values of the matrix in each of the batches
C gko::EnableAbstractPolymorphicObject< Ell< default_precision, int32 >, BatchLinOp >
C gko::EnablePolymorphicObject< Ell< default_precision, int32 >, BatchLinOp >
C gko::batch::EnableBatchLinOp< Ell< default_precision, int32 > >
C gko::batch::matrix::Ell< ValueType, IndexType > Ell is a sparse matrix format that stores the same number of nonzeros in each row, enabling coalesced accesses
C gko::EnableAbstractPolymorphicObject< Identity< default_precision >, BatchLinOp >
C gko::EnablePolymorphicObject< Identity< default_precision >, BatchLinOp >
C gko::batch::EnableBatchLinOp< Identity< default_precision > >
C gko::batch::matrix::Identity< ValueType > The batch Identity matrix, which represents a batch of Identity matrices
C gko::EnableAbstractPolymorphicObject< Jacobi< default_precision, int32 >, BatchLinOp >
C gko::EnablePolymorphicObject< Jacobi< default_precision, int32 >, BatchLinOp >
C gko::batch::EnableBatchLinOp< Jacobi< default_precision, int32 > >
C gko::batch::preconditioner::Jacobi< ValueType, IndexType > 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
C gko::EnableAbstractPolymorphicObject< Bicgstab< default_precision >, BatchLinOp >
C gko::EnablePolymorphicObject< Bicgstab< default_precision >, BatchLinOp >
C gko::batch::EnableBatchLinOp< Bicgstab< default_precision >, BatchLinOp >
C gko::batch::solver::EnableBatchSolver< Bicgstab< default_precision >, default_precision >
C gko::batch::solver::Bicgstab< ValueType > BiCGSTAB or the Bi-Conjugate Gradient-Stabilized is a Krylov subspace solver
C gko::EnableAbstractPolymorphicObject< Cg< default_precision >, BatchLinOp >
C gko::EnablePolymorphicObject< Cg< default_precision >, BatchLinOp >
C gko::batch::EnableBatchLinOp< Cg< default_precision >, BatchLinOp >
C gko::batch::solver::EnableBatchSolver< Cg< default_precision >, default_precision >
C gko::batch::solver::Cg< ValueType > Cg or the Conjugate Gradient is a Krylov subspace solver
C gko::EnableAbstractPolymorphicObject< ConcreteSolver, BatchLinOp >
C gko::EnablePolymorphicObject< ConcreteSolver, BatchLinOp >
C gko::batch::EnableBatchLinOp< ConcreteSolver, BatchLinOp >
C gko::batch::solver::EnableBatchSolver< ConcreteSolver, ValueType, PolymorphicBase > This mixin provides apply and common iterative solver functionality to all the batched solvers
C gko::batch::solver::BatchSolver The BatchSolver is a base class for all batched solvers and provides the common getters and setter for these batched solver classes
C gko::batch::solver::EnableBatchSolver< Bicgstab< default_precision >, default_precision >
C gko::batch::solver::EnableBatchSolver< Cg< default_precision >, default_precision >
C gko::batch::solver::EnableBatchSolver< ConcreteSolver, ValueType, PolymorphicBase > This mixin provides apply and common iterative solver functionality to all the batched solvers
C gko::bfloat16 A class providing basic support for bfloat16 precision floating point types
C gko::preconditioner::block_interleaved_storage_scheme< IndexType > Defines the parameters of the interleaved block storage scheme used by block-Jacobi blocks
C gko::experimental::mpi::CollectiveCommunicator Interface for a collective communicator
C gko::experimental::mpi::DenseCommunicator A CollectiveCommunicator that uses a dense communication
C gko::experimental::mpi::NeighborhoodCommunicator A CollectiveCommunicator that uses a neighborhood topology
C gko::experimental::mpi::communicator A thin wrapper of MPI_Comm that supports most MPI calls
C gko::experimental::mpi::contiguous_type A move-only wrapper for a contiguous MPI_Datatype
C gko::ConvertibleTo< ResultType > ConvertibleTo interface is used to mark that the implementer can be converted to the object of ResultType
C gko::batch::matrix::Csr< ValueType, IndexType >
C gko::batch::matrix::Dense< ValueType >
C gko::experimental::distributed::Vector< ValueType >
C gko::experimental::distributed::Vector< to_complex< value_type > >
C gko::experimental::distributed::Vector< previous_precision< ValueType > >
C gko::matrix::Coo< ValueType, IndexType >
C gko::matrix::Coo< ValueType, IndexType >
C gko::matrix::Coo< ValueType, IndexType >
C gko::matrix::Csr< value_type, index_type >
C gko::matrix::Csr< value_type, index_type >
C gko::matrix::Csr< value_type, index_type >
C gko::matrix::Csr< value_type, index_type >
C gko::matrix::Csr< value_type, index_type >
C gko::matrix::Csr< value_type, index_type >
C gko::matrix::Csr< value_type, index_type >
C gko::matrix::Csr< value_type, index_type >
C gko::matrix::Csr< ValueType, IndexType >
C gko::matrix::Csr< ValueType, IndexType >
C gko::matrix::Csr< ValueType, IndexType >
C gko::matrix::Csr< ValueType, IndexType >
C gko::matrix::Csr< ValueType, IndexType >
C gko::matrix::Csr< ValueType, IndexType >
C gko::matrix::Csr< ValueType, IndexType >
C gko::matrix::Csr< ValueType, IndexType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Diagonal< ValueType >
C gko::matrix::Diagonal< ValueType >
C gko::matrix::Diagonal< ValueType >
C gko::matrix::Ell< value_type, index_type >
C gko::matrix::Ell< value_type, index_type >
C gko::matrix::Ell< value_type, index_type >
C gko::matrix::Ell< ValueType, IndexType >
C gko::matrix::Ell< ValueType, IndexType >
C gko::matrix::Ell< ValueType, IndexType >
C gko::matrix::Fbcsr< ValueType, IndexType >
C gko::matrix::Fbcsr< ValueType, IndexType >
C gko::matrix::Fbcsr< ValueType, IndexType >
C gko::matrix::Fbcsr< ValueType, IndexType >
C gko::matrix::SparsityCsr< value_type, index_type >
C gko::matrix::SparsityCsr< value_type, index_type >
C gko::matrix::SparsityCsr< IndexType, ValueType >
C gko::matrix::SparsityCsr< IndexType, ValueType >
C gko::matrix::SparsityCsr< ValueType, IndexType >
C gko::matrix::SparsityCsr< ValueType, IndexType >
C gko::preconditioner::Jacobi< ValueType, IndexType >
C gko::ConvertibleTo< Amd< int32 > >
C gko::EnablePolymorphicAssignment< Amd< int32 > >
C gko::experimental::reorder::Amd< IndexType > Computes a Approximate Minimum Degree (AMD) reordering of an input matrix
C gko::ConvertibleTo< Bicg< default_precision > >
C gko::EnablePolymorphicAssignment< Bicg< default_precision > >
C gko::EnableLinOp< Bicg< default_precision > >
C gko::solver::Bicg< ValueType > BICG or the Biconjugate gradient method is a Krylov subspace solver
C gko::ConvertibleTo< Bicgstab< default_precision > >
C gko::EnablePolymorphicAssignment< Bicgstab< default_precision > >
C gko::EnableLinOp< Bicgstab< default_precision > >
C gko::solver::Bicgstab< ValueType > BiCGSTAB or the Bi-Conjugate Gradient-Stabilized is a Krylov subspace solver
C gko::batch::EnableBatchLinOp< Bicgstab< default_precision >, BatchLinOp >
C gko::ConvertibleTo< BlockOperator >
C gko::EnablePolymorphicAssignment< BlockOperator >
C gko::EnableLinOp< BlockOperator >
C gko::BlockOperator A BlockOperator represents a linear operator that is partitioned into multiple blocks
C gko::ConvertibleTo< CbGmres< default_precision > >
C gko::EnablePolymorphicAssignment< CbGmres< default_precision > >
C gko::EnableLinOp< CbGmres< default_precision > >
C gko::solver::CbGmres< ValueType > CB-GMRES or the compressed basis generalized minimal residual method is an iterative type Krylov subspace method which is suitable for nonsymmetric linear systems
C gko::ConvertibleTo< Cg< default_precision > >
C gko::EnablePolymorphicAssignment< Cg< default_precision > >
C gko::EnableLinOp< Cg< default_precision > >
C gko::solver::Cg< ValueType > CG or the conjugate gradient method is an iterative type Krylov subspace method which is suitable for symmetric positive definite methods
C gko::batch::EnableBatchLinOp< Cg< default_precision >, BatchLinOp >
C gko::ConvertibleTo< Cgs< default_precision > >
C gko::EnablePolymorphicAssignment< Cgs< default_precision > >
C gko::EnableLinOp< Cgs< default_precision > >
C gko::solver::Cgs< ValueType > CGS or the conjugate gradient square method is an iterative type Krylov subspace method which is suitable for general systems
C gko::ConvertibleTo< Chebyshev< default_precision > >
C gko::EnablePolymorphicAssignment< Chebyshev< default_precision > >
C gko::EnableLinOp< Chebyshev< default_precision > >
C gko::solver::Chebyshev< ValueType > Chebyshev iteration is an iterative method for solving nonsymmetric problems based on some knowledge of the spectrum of the (preconditioned) system matrix
C gko::ConvertibleTo< Cholesky< ValueType, IndexType > >
C gko::EnablePolymorphicAssignment< Cholesky< ValueType, IndexType > >
C gko::experimental::factorization::Cholesky< ValueType, IndexType > Computes a Cholesky factorization of a symmetric, positive-definite sparse matrix
C gko::ConvertibleTo< Combination< default_precision > >
C gko::EnablePolymorphicAssignment< Combination< default_precision > >
C gko::EnableLinOp< Combination< default_precision > >
C gko::Combination< ValueType > The Combination class can be used to construct a linear combination of multiple linear operators c1 * op1 + c2 * op2 + ... + ck * opk
C gko::ConvertibleTo< Composition< default_precision > >
C gko::EnablePolymorphicAssignment< Composition< default_precision > >
C gko::EnableLinOp< Composition< default_precision > >
C gko::Composition< default_precision >
C gko::factorization::ParIc< ValueType, IndexType > ParIC is an incomplete Cholesky factorization which is computed in parallel
C gko::factorization::ParIct< ValueType, IndexType > ParICT is an incomplete threshold-based Cholesky factorization which is computed in parallel
C gko::factorization::ParIlu< ValueType, IndexType > ParILU is an incomplete LU factorization which is computed in parallel
C gko::factorization::ParIlut< ValueType, IndexType > ParILUT is an incomplete threshold-based LU factorization which is computed in parallel
C gko::Composition< ValueType > The Composition class can be used to compose linear operators op1, op2, ...,
opn and obtain the operator op1 * op2 * ... * opn
C gko::ConvertibleTo< Composition< gko::default_precision > >
C gko::EnablePolymorphicAssignment< Composition< gko::default_precision > >
C gko::EnableLinOp< Composition< gko::default_precision > >
C gko::Composition< gko::default_precision >
C gko::factorization::Ic< ValueType, IndexType > Represents an incomplete Cholesky factorization (IC(0)) of a sparse matrix
C gko::factorization::Ilu< ValueType, IndexType > Represents an incomplete LU factorization – ILU(0) – of a sparse matrix
C gko::ConvertibleTo< ConcreteBatchLinOp >
C gko::EnablePolymorphicAssignment< ConcreteBatchLinOp >
C gko::batch::EnableBatchLinOp< ConcreteBatchLinOp, PolymorphicBase > The EnableBatchLinOp mixin can be used to provide sensible default implementations of the majority of the BatchLinOp and PolymorphicObject interface
C gko::ConvertibleTo< ConcreteFactory >
C gko::EnablePolymorphicAssignment< ConcreteFactory >
C gko::EnableDefaultFactory< ConcreteFactory, ConcreteBatchLinOp, ParametersType, PolymorphicBase >
C gko::batch::preconditioner::Jacobi< ValueType, IndexType >::Factory
C gko::batch::solver::Bicgstab< ValueType >::Factory
C gko::batch::solver::Cg< ValueType >::Factory
C gko::EnableDefaultFactory< ConcreteFactory, ConcreteLinOp, ParametersType, PolymorphicBase >
C gko::experimental::distributed::preconditioner::Schwarz< ValueType, LocalIndexType, GlobalIndexType >::Factory
C gko::experimental::reorder::ScaledReordered< ValueType, IndexType >::Factory
C gko::experimental::solver::Direct< ValueType, IndexType >::Factory
C gko::factorization::Ic< ValueType, IndexType >::Factory
C gko::factorization::Ilu< ValueType, IndexType >::Factory
C gko::factorization::ParIc< ValueType, IndexType >::Factory
C gko::factorization::ParIct< ValueType, IndexType >::Factory
C gko::factorization::ParIlu< ValueType, IndexType >::Factory
C gko::factorization::ParIlut< ValueType, IndexType >::Factory
C gko::multigrid::FixedCoarsening< ValueType, IndexType >::Factory
C gko::multigrid::Pgm< ValueType, IndexType >::Factory
C gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >::Factory
C gko::preconditioner::Ilu< LSolverTypeOrValueType, USolverTypeOrValueType, ReverseApply, IndexType >::Factory
C gko::preconditioner::Isai< IsaiType, ValueType, IndexType >::Factory
C gko::preconditioner::Jacobi< ValueType, IndexType >::Factory
C gko::solver::Bicg< ValueType >::Factory
C gko::solver::Bicgstab< ValueType >::Factory
C gko::solver::CbGmres< ValueType >::Factory
C gko::solver::Cg< ValueType >::Factory
C gko::solver::Cgs< ValueType >::Factory
C gko::solver::Chebyshev< ValueType >::Factory
C gko::solver::Fcg< ValueType >::Factory
C gko::solver::Gcr< ValueType >::Factory
C gko::solver::Gmres< ValueType >::Factory
C gko::solver::Idr< ValueType >::Factory
C gko::solver::Ir< ValueType >::Factory
C gko::solver::LowerTrs< ValueType, IndexType >::Factory
C gko::solver::Minres< ValueType >::Factory
C gko::solver::Multigrid::Factory
C gko::solver::PipeCg< ValueType >::Factory
C gko::solver::UpperTrs< ValueType, IndexType >::Factory
C gko::EnableDefaultFactory< ConcreteFactory, ConcreteReorderingBase, ParametersType, PolymorphicBase >
C gko::reorder::Rcm< ValueType, IndexType >::Factory
C gko::EnableDefaultFactory< ConcreteFactory, ConcreteCriterion, ParametersType, PolymorphicBase >
C gko::stop::AbsoluteResidualNorm< ValueType >::Factory
C gko::stop::Combined::Factory
C gko::stop::ImplicitResidualNorm< ValueType >::Factory
C gko::stop::Iteration::Factory
C gko::stop::RelativeResidualNorm< ValueType >::Factory
C gko::stop::ResidualNorm< ValueType >::Factory
C gko::stop::ResidualNormReduction< ValueType >::Factory
C gko::stop::Time::Factory
C gko::EnableDefaultFactory< ConcreteFactory, ProductType, ParametersType, PolymorphicBase > This mixin provides a default implementation of a concrete factory
C gko::ConvertibleTo< ConcreteLinOp >
C gko::EnablePolymorphicAssignment< ConcreteLinOp >
C gko::EnableLinOp< ConcreteLinOp, PolymorphicBase > The EnableLinOp mixin can be used to provide sensible default implementations of the majority of the LinOp and PolymorphicObject interface
C gko::Combination< ValueType >
C gko::Composition< ValueType >
C gko::Composition< value_type >
C gko::experimental::distributed::Vector< ValueType >
C gko::experimental::distributed::Vector< to_complex< value_type > >
C gko::experimental::distributed::Vector< previous_precision< ValueType > >
C gko::experimental::factorization::Factorization< value_type, index_type >
C gko::matrix::Coo< ValueType, IndexType >
C gko::matrix::Csr< value_type, index_type >
C gko::matrix::Csr< ValueType, IndexType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Diagonal< ValueType >
C gko::matrix::Ell< value_type, index_type >
C gko::matrix::Ell< ValueType, IndexType >
C gko::matrix::Fbcsr< ValueType, IndexType >
C gko::matrix::Identity< ValueType >
C gko::matrix::Permutation< index_type >
C gko::matrix::Permutation< IndexType >
C gko::matrix::SparsityCsr< value_type, index_type >
C gko::matrix::SparsityCsr< IndexType, ValueType >
C gko::matrix::SparsityCsr< ValueType, IndexType >
C gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >
C gko::preconditioner::Jacobi< ValueType, IndexType >
C gko::solver::Bicg< ValueType >
C gko::solver::Bicgstab< ValueType >
C gko::solver::Cg< ValueType >
C gko::solver::Cgs< ValueType >
C gko::solver::Chebyshev< ValueType >
C gko::solver::Fcg< ValueType >
C gko::solver::Gcr< ValueType >
C gko::solver::Gmres< ValueType >
C gko::solver::Idr< ValueType >
C gko::solver::Ir< ValueType >
C gko::solver::LowerTrs< value_type, index_type >
C gko::solver::LowerTrs< ValueType, IndexType >
C gko::solver::Minres< ValueType >
C gko::solver::PipeCg< ValueType >
C gko::solver::UpperTrs< value_type, index_type >
C gko::solver::UpperTrs< ValueType, IndexType >
C gko::ConvertibleTo< ConcreteSolver >
C gko::EnablePolymorphicAssignment< ConcreteSolver >
C gko::batch::EnableBatchLinOp< ConcreteSolver, BatchLinOp >
C gko::ConvertibleTo< ConcreteType >
C gko::EnablePolymorphicAssignment< ConcreteType, ResultType > This mixin is used to enable a default PolymorphicObject::copy_from() implementation for objects that have implemented conversions between them
C gko::experimental::distributed::Partition< LocalIndexType, GlobalIndexType >
C gko::ConvertibleTo< Coo< default_precision, int32 > >
C gko::EnablePolymorphicAssignment< Coo< default_precision, int32 > >
C gko::EnableLinOp< Coo< default_precision, int32 > >
C gko::matrix::Coo< ValueType, IndexType > COO stores a matrix in the coordinate matrix format
C gko::matrix::Csr< ValueType, IndexType > CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matrix (compressed sparse row format)
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::ConvertibleTo< Coo< default_precision, int64 > >
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::ConvertibleTo< Coo< next_precision< default_precision >, int32 > >
C gko::matrix::Coo< ValueType, IndexType > COO stores a matrix in the coordinate matrix format
C gko::ConvertibleTo< Csr< default_precision, int32 > >
C gko::EnablePolymorphicAssignment< Csr< default_precision, int32 > >
C gko::EnableLinOp< Csr< default_precision, int32 > >
C gko::matrix::Csr< ValueType, IndexType > CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matrix (compressed sparse row format)
C gko::batch::EnableBatchLinOp< Csr< default_precision, int32 > >
C gko::matrix::Coo< ValueType, IndexType > COO stores a matrix in the coordinate matrix format
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::matrix::Diagonal< ValueType > This class is a utility which efficiently implements the diagonal matrix (a linear operator which scales a vector row wise)
C gko::matrix::Ell< ValueType, IndexType > ELL is a matrix format where stride with explicit zeros is used such that all rows have the same number of stored elements
C gko::matrix::Fbcsr< ValueType, IndexType > Fixed-block compressed sparse row storage matrix format
C gko::matrix::Hybrid< ValueType, IndexType > HYBRID is a matrix format which splits the matrix into ELLPACK and COO format
C gko::matrix::Sellp< ValueType, IndexType > SELL-P is a matrix format similar to ELL format
C gko::matrix::SparsityCsr< ValueType, IndexType > 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)
C gko::ConvertibleTo< Csr< default_precision, int64 > >
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::matrix::Diagonal< ValueType > This class is a utility which efficiently implements the diagonal matrix (a linear operator which scales a vector row wise)
C gko::ConvertibleTo< Csr< next_precision< default_precision >, int32 > >
C gko::batch::matrix::Csr< ValueType, IndexType > 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
C gko::matrix::Csr< ValueType, IndexType > CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matrix (compressed sparse row format)
C gko::ConvertibleTo< Dense< default_precision > >
C gko::EnablePolymorphicAssignment< Dense< default_precision > >
C gko::EnableLinOp< Dense< default_precision > >
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::batch::EnableBatchLinOp< Dense< default_precision > >
C gko::matrix::Coo< ValueType, IndexType > COO stores a matrix in the coordinate matrix format
C gko::matrix::Csr< ValueType, IndexType > CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matrix (compressed sparse row format)
C gko::matrix::Ell< ValueType, IndexType > ELL is a matrix format where stride with explicit zeros is used such that all rows have the same number of stored elements
C gko::matrix::Fbcsr< ValueType, IndexType > Fixed-block compressed sparse row storage matrix format
C gko::matrix::Hybrid< ValueType, IndexType > HYBRID is a matrix format which splits the matrix into ELLPACK and COO format
C gko::matrix::Sellp< ValueType, IndexType > SELL-P is a matrix format similar to ELL format
C gko::matrix::SparsityCsr< ValueType, IndexType > 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)
C gko::ConvertibleTo< Dense< next_precision< default_precision > > >
C gko::batch::matrix::Dense< ValueType > Dense is a batch matrix format which explicitly stores all values of the matrix in each of the batches
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::ConvertibleTo< Diagonal< default_precision > >
C gko::EnablePolymorphicAssignment< Diagonal< default_precision > >
C gko::EnableLinOp< Diagonal< default_precision > >
C gko::matrix::Diagonal< ValueType > This class is a utility which efficiently implements the diagonal matrix (a linear operator which scales a vector row wise)
C gko::ConvertibleTo< Diagonal< next_precision< default_precision > > >
C gko::matrix::Diagonal< ValueType > This class is a utility which efficiently implements the diagonal matrix (a linear operator which scales a vector row wise)
C gko::ConvertibleTo< Direct< ValueType, IndexType > >
C gko::EnablePolymorphicAssignment< Direct< ValueType, IndexType > >
C gko::EnableLinOp< Direct< ValueType, IndexType > >
C gko::experimental::solver::Direct< ValueType, IndexType > A direct solver based on a factorization into lower and upper triangular factors (with an optional diagonal scaling)
C gko::ConvertibleTo< Ell< default_precision, int32 > >
C gko::EnablePolymorphicAssignment< Ell< default_precision, int32 > >
C gko::EnableLinOp< Ell< default_precision, int32 > >
C gko::matrix::Ell< ValueType, IndexType > ELL is a matrix format where stride with explicit zeros is used such that all rows have the same number of stored elements
C gko::batch::EnableBatchLinOp< Ell< default_precision, int32 > >
C gko::matrix::Csr< ValueType, IndexType > CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matrix (compressed sparse row format)
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::ConvertibleTo< Ell< default_precision, int64 > >
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::ConvertibleTo< Ell< next_precision< default_precision >, int32 > >
C gko::batch::matrix::Ell< ValueType, IndexType > Ell is a sparse matrix format that stores the same number of nonzeros in each row, enabling coalesced accesses
C gko::matrix::Ell< ValueType, IndexType > ELL is a matrix format where stride with explicit zeros is used such that all rows have the same number of stored elements
C gko::ConvertibleTo< Factorization< ValueType, IndexType > >
C gko::EnablePolymorphicAssignment< Factorization< ValueType, IndexType > >
C gko::EnableLinOp< Factorization< ValueType, IndexType > >
C gko::experimental::factorization::Factorization< ValueType, IndexType > Represents a generic factorization consisting of two triangular factors (upper and lower) and an optional diagonal scaling matrix
C gko::ConvertibleTo< Fbcsr< default_precision, int32 > >
C gko::EnablePolymorphicAssignment< Fbcsr< default_precision, int32 > >
C gko::EnableLinOp< Fbcsr< default_precision, int32 > >
C gko::matrix::Fbcsr< ValueType, IndexType > Fixed-block compressed sparse row storage matrix format
C gko::matrix::Csr< ValueType, IndexType > CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matrix (compressed sparse row format)
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::ConvertibleTo< Fbcsr< default_precision, int64 > >
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::ConvertibleTo< Fbcsr< next_precision< default_precision >, int32 > >
C gko::matrix::Fbcsr< ValueType, IndexType > Fixed-block compressed sparse row storage matrix format
C gko::ConvertibleTo< Fcg< default_precision > >
C gko::EnablePolymorphicAssignment< Fcg< default_precision > >
C gko::EnableLinOp< Fcg< default_precision > >
C gko::solver::Fcg< ValueType > FCG or the flexible conjugate gradient method is an iterative type Krylov subspace method which is suitable for symmetric positive definite methods
C gko::ConvertibleTo< Fft >
C gko::EnablePolymorphicAssignment< Fft >
C gko::EnableLinOp< Fft >
C gko::matrix::Fft This LinOp implements a 1D Fourier matrix using the FFT algorithm
C gko::ConvertibleTo< Fft2 >
C gko::EnablePolymorphicAssignment< Fft2 >
C gko::EnableLinOp< Fft2 >
C gko::matrix::Fft2 This LinOp implements a 2D Fourier matrix using the FFT algorithm
C gko::ConvertibleTo< Fft3 >
C gko::EnablePolymorphicAssignment< Fft3 >
C gko::EnableLinOp< Fft3 >
C gko::matrix::Fft3 This LinOp implements a 3D Fourier matrix using the FFT algorithm
C gko::ConvertibleTo< FixedCoarsening< default_precision, int32 > >
C gko::EnablePolymorphicAssignment< FixedCoarsening< default_precision, int32 > >
C gko::EnableLinOp< FixedCoarsening< default_precision, int32 > >
C gko::multigrid::FixedCoarsening< ValueType, IndexType > FixedCoarsening is a very simple coarse grid generation algorithm
C gko::ConvertibleTo< GaussSeidel< default_precision, int32 > >
C gko::EnablePolymorphicAssignment< GaussSeidel< default_precision, int32 > >
C gko::preconditioner::GaussSeidel< ValueType, IndexType > This class generates the Gauss-Seidel preconditioner
C gko::ConvertibleTo< Gcr< default_precision > >
C gko::EnablePolymorphicAssignment< Gcr< default_precision > >
C gko::EnableLinOp< Gcr< default_precision > >
C gko::solver::Gcr< ValueType > GCR or the generalized conjugate residual method is an iterative type Krylov subspace method similar to GMRES which is suitable for nonsymmetric linear systems
C gko::ConvertibleTo< Gmres< default_precision > >
C gko::EnablePolymorphicAssignment< Gmres< default_precision > >
C gko::EnableLinOp< Gmres< default_precision > >
C gko::solver::Gmres< ValueType > GMRES or the generalized minimal residual method is an iterative type Krylov subspace method which is suitable for nonsymmetric linear systems
C gko::ConvertibleTo< Hybrid< default_precision, int32 > >
C gko::EnablePolymorphicAssignment< Hybrid< default_precision, int32 > >
C gko::EnableLinOp< Hybrid< default_precision, int32 > >
C gko::matrix::Hybrid< ValueType, IndexType > HYBRID is a matrix format which splits the matrix into ELLPACK and COO format
C gko::matrix::Csr< ValueType, IndexType > CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matrix (compressed sparse row format)
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::ConvertibleTo< Hybrid< default_precision, int64 > >
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::ConvertibleTo< Hybrid< next_precision< default_precision >, int32 > >
C gko::matrix::Hybrid< ValueType, IndexType > HYBRID is a matrix format which splits the matrix into ELLPACK and COO format
C gko::ConvertibleTo< Ic< solver::LowerTrs<>, int32 > >
C gko::EnablePolymorphicAssignment< Ic< solver::LowerTrs<>, int32 > >
C gko::EnableLinOp< Ic< solver::LowerTrs<>, int32 > >
C gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType > 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)
C gko::ConvertibleTo< Identity< default_precision > >
C gko::EnablePolymorphicAssignment< Identity< default_precision > >
C gko::EnableLinOp< Identity< default_precision > >
C gko::matrix::Identity< ValueType > This class is a utility which efficiently implements the identity matrix (a linear operator which maps each vector to itself)
C gko::batch::EnableBatchLinOp< Identity< default_precision > >
C gko::ConvertibleTo< Idr< default_precision > >
C gko::EnablePolymorphicAssignment< Idr< default_precision > >
C gko::EnableLinOp< Idr< default_precision > >
C gko::solver::Idr< ValueType > IDR(s) is an efficient method for solving large nonsymmetric systems of linear equations
C gko::ConvertibleTo< Ir< default_precision > >
C gko::EnablePolymorphicAssignment< Ir< default_precision > >
C gko::EnableLinOp< Ir< default_precision > >
C gko::solver::Ir< ValueType > Iterative refinement (IR) is an iterative method that uses another coarse method to approximate the error of the current solution via the current residual
C gko::ConvertibleTo< Isai< IsaiType, ValueType, IndexType > >
C gko::EnablePolymorphicAssignment< Isai< IsaiType, ValueType, IndexType > >
C gko::EnableLinOp< Isai< IsaiType, ValueType, IndexType > >
C gko::preconditioner::Isai< IsaiType==isai_type::general ? isai_type::general :IsaiType==isai_type::spd ? isai_type::spd :IsaiType==isai_type::lower ? isai_type::upper :isai_type::lower, ValueType, IndexType >
C gko::preconditioner::Isai< isai_type::lower, ValueType, IndexType >
C gko::preconditioner::Isai< isai_type::upper, ValueType, IndexType >
C gko::preconditioner::Isai< isai_type::general, ValueType, IndexType >
C gko::preconditioner::Isai< isai_type::spd, ValueType, IndexType >
C gko::preconditioner::Isai< IsaiType, ValueType, IndexType > 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
C gko::ConvertibleTo< Jacobi< default_precision, int32 > >
C gko::EnablePolymorphicAssignment< Jacobi< default_precision, int32 > >
C gko::EnableLinOp< Jacobi< default_precision, int32 > >
C gko::preconditioner::Jacobi< ValueType, IndexType > A block-Jacobi preconditioner is a block-diagonal linear operator, obtained by inverting the diagonal blocks of the source operator
C gko::batch::EnableBatchLinOp< Jacobi< default_precision, int32 > >
C gko::ConvertibleTo< LowerTrs< default_precision, int32 > >
C gko::EnablePolymorphicAssignment< LowerTrs< default_precision, int32 > >
C gko::EnableLinOp< LowerTrs< default_precision, int32 > >
C gko::solver::LowerTrs< ValueType, IndexType > LowerTrs is the triangular solver which solves the system L x = b, when L is a lower triangular matrix
C gko::ConvertibleTo< Lu< ValueType, IndexType > >
C gko::EnablePolymorphicAssignment< Lu< ValueType, IndexType > >
C gko::experimental::factorization::Lu< ValueType, IndexType > Computes an LU factorization of a sparse matrix
C gko::ConvertibleTo< matrix::Dense< default_precision > >
C gko::preconditioner::Jacobi< ValueType, IndexType > A block-Jacobi preconditioner is a block-diagonal linear operator, obtained by inverting the diagonal blocks of the source operator
C gko::ConvertibleTo< Matrix< default_precision, int32, int64 > >
C gko::EnablePolymorphicAssignment< Matrix< default_precision, int32, int64 > >
C gko::EnableLinOp< Matrix< default_precision, int32, int64 > >
C gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType > The Matrix class defines a (MPI-)distributed matrix
C gko::ConvertibleTo< Matrix< next_precision< default_precision >, int32, int64 > >
C gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType > The Matrix class defines a (MPI-)distributed matrix
C gko::ConvertibleTo< Mc64< default_precision, int32 > >
C gko::EnablePolymorphicAssignment< Mc64< default_precision, int32 > >
C gko::experimental::reorder::Mc64< ValueType, IndexType > MC64 is an algorithm for permuting large entries to the diagonal of a sparse matrix
C gko::ConvertibleTo< Minres< default_precision > >
C gko::EnablePolymorphicAssignment< Minres< default_precision > >
C gko::EnableLinOp< Minres< default_precision > >
C gko::solver::Minres< ValueType > Minres is an iterative type Krylov subspace method, which is suitable for indefinite and full-rank symmetric/hermitian operators
C gko::ConvertibleTo< Multigrid >
C gko::EnablePolymorphicAssignment< Multigrid >
C gko::EnableLinOp< Multigrid >
C gko::solver::Multigrid Multigrid methods have a hierarchy of many levels, whose corase level is a subset of the fine level, of the problem
C gko::ConvertibleTo< MultiVector< default_precision > >
C gko::EnablePolymorphicAssignment< MultiVector< default_precision > >
C gko::batch::MultiVector< ValueType > MultiVector stores multiple vectors in a batched fashion and is useful for batched operations
C gko::ConvertibleTo< MultiVector< next_precision< default_precision > > >
C gko::batch::MultiVector< ValueType > MultiVector stores multiple vectors in a batched fashion and is useful for batched operations
C gko::ConvertibleTo< Partition< int32, int64 > >
C gko::EnablePolymorphicAssignment< Partition< int32, int64 > >
C gko::experimental::distributed::Partition< LocalIndexType, GlobalIndexType > Represents a partition of a range of indices [0, size) into a disjoint set of parts
C gko::ConvertibleTo< Permutation< int32 > >
C gko::EnablePolymorphicAssignment< Permutation< int32 > >
C gko::EnableLinOp< Permutation< int32 > >
C gko::matrix::Permutation< IndexType > Permutation is a matrix format that represents a permutation matrix, i.e
C gko::ConvertibleTo< Perturbation< default_precision > >
C gko::EnablePolymorphicAssignment< Perturbation< default_precision > >
C gko::EnableLinOp< Perturbation< default_precision > >
C gko::Perturbation< ValueType > The Perturbation class can be used to construct a LinOp to represent the operation (identity + scalar * basis * projector)
C gko::ConvertibleTo< Pgm< default_precision, int32 > >
C gko::EnablePolymorphicAssignment< Pgm< default_precision, int32 > >
C gko::EnableLinOp< Pgm< default_precision, int32 > >
C gko::multigrid::Pgm< ValueType, IndexType > Parallel graph match (Pgm ) is the aggregate method introduced in the paper M
C gko::ConvertibleTo< PipeCg< default_precision > >
C gko::EnablePolymorphicAssignment< PipeCg< default_precision > >
C gko::EnableLinOp< PipeCg< default_precision > >
C gko::solver::PipeCg< ValueType > PIPE_CG or the pipelined conjugate gradient method is an iterative type Krylov subspace method which is suitable for symmetric positive definite methods
C gko::ConvertibleTo< Rcm< default_precision, int32 > >
C gko::EnablePolymorphicAssignment< Rcm< default_precision, int32 > >
C gko::reorder::Rcm< ValueType, IndexType > Rcm (Reverse Cuthill-McKee) is a reordering algorithm minimizing the bandwidth of a matrix
C gko::ConvertibleTo< Rcm< int32 > >
C gko::EnablePolymorphicAssignment< Rcm< int32 > >
C gko::experimental::reorder::Rcm< IndexType > Rcm (Reverse Cuthill-McKee) is a reordering algorithm minimizing the bandwidth of a matrix
C gko::ConvertibleTo< RowGatherer< int32 > >
C gko::EnablePolymorphicAssignment< RowGatherer< int32 > >
C gko::EnableLinOp< RowGatherer< int32 > >
C gko::matrix::RowGatherer< IndexType > RowGatherer is a matrix "format" which stores the gather indices arrays which can be used to gather rows to another matrix
C gko::experimental::distributed::RowGatherer< LocalIndexType > The distributed::RowGatherer gathers the rows of distributed::Vector that are located on other processes
C gko::ConvertibleTo< ScaledPermutation< default_precision, int32 > >
C gko::EnablePolymorphicAssignment< ScaledPermutation< default_precision, int32 > >
C gko::EnableLinOp< ScaledPermutation< default_precision, int32 > >
C gko::matrix::ScaledPermutation< ValueType, IndexType > ScaledPermutation is a matrix combining a permutation with scaling factors
C gko::ConvertibleTo< ScaledReordered< default_precision, int32 > >
C gko::EnablePolymorphicAssignment< ScaledReordered< default_precision, int32 > >
C gko::EnableLinOp< ScaledReordered< default_precision, int32 > >
C gko::experimental::reorder::ScaledReordered< ValueType, IndexType > Provides an interface to wrap reorderings like Rcm and diagonal scaling like equilibration around a LinOp like e.g
C gko::ConvertibleTo< Schwarz< default_precision, int32, int64 > >
C gko::EnablePolymorphicAssignment< Schwarz< default_precision, int32, int64 > >
C gko::EnableLinOp< Schwarz< default_precision, int32, int64 > >
C gko::experimental::distributed::preconditioner::Schwarz< ValueType, LocalIndexType, GlobalIndexType > 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
C gko::ConvertibleTo< Sellp< default_precision, int32 > >
C gko::EnablePolymorphicAssignment< Sellp< default_precision, int32 > >
C gko::EnableLinOp< Sellp< default_precision, int32 > >
C gko::matrix::Sellp< ValueType, IndexType > SELL-P is a matrix format similar to ELL format
C gko::matrix::Csr< ValueType, IndexType > CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matrix (compressed sparse row format)
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::ConvertibleTo< Sellp< default_precision, int64 > >
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::ConvertibleTo< Sellp< next_precision< default_precision >, int32 > >
C gko::matrix::Sellp< ValueType, IndexType > SELL-P is a matrix format similar to ELL format
C gko::ConvertibleTo< Sor< default_precision, int32 > >
C gko::EnablePolymorphicAssignment< Sor< default_precision, int32 > >
C gko::preconditioner::Sor< ValueType, IndexType > This class generates the (S)SOR preconditioner
C gko::ConvertibleTo< SparsityCsr< default_precision, int32 > >
C gko::EnablePolymorphicAssignment< SparsityCsr< default_precision, int32 > >
C gko::EnableLinOp< SparsityCsr< default_precision, int32 > >
C gko::matrix::SparsityCsr< ValueType, IndexType > 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)
C gko::matrix::Csr< ValueType, IndexType > CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matrix (compressed sparse row format)
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::matrix::Fbcsr< ValueType, IndexType > Fixed-block compressed sparse row storage matrix format
C gko::ConvertibleTo< SparsityCsr< default_precision, int64 > >
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::ConvertibleTo< UpperTrs< default_precision, int32 > >
C gko::EnablePolymorphicAssignment< UpperTrs< default_precision, int32 > >
C gko::EnableLinOp< UpperTrs< default_precision, int32 > >
C gko::solver::UpperTrs< ValueType, IndexType > UpperTrs is the triangular solver which solves the system U x = b, when U is an upper triangular matrix
C gko::ConvertibleTo< Vector< double > >
C gko::EnablePolymorphicAssignment< Vector< double > >
C gko::EnableLinOp< Vector< double > >
C gko::experimental::distributed::Vector< ValueType > Vector is a format which explicitly stores (multiple) distributed column vectors in a dense storage format
C gko::ConvertibleTo< Vector< next_precision< double > > >
C gko::experimental::distributed::Vector< ValueType > Vector is a format which explicitly stores (multiple) distributed column vectors in a dense storage format
C gko::matrix::CooBuilder< ValueType, IndexType >
C gko::cpx_real_type< T > Access the underlying real type of a complex number
C Criterion
C gko::EnableAbstractPolymorphicObject< ResidualNormBase< default_precision >, Criterion >
C gko::EnablePolymorphicObject< ResidualNormBase< default_precision >, Criterion >
C gko::stop::ResidualNormBase< default_precision >
C gko::stop::AbsoluteResidualNorm< ValueType > The AbsoluteResidualNorm class is a stopping criterion which stops the iteration process when the residual norm is below a certain threshold, i.e
C gko::stop::ImplicitResidualNorm< ValueType > The ImplicitResidualNorm class is a stopping criterion which stops the iteration process when the implicit residual norm is below a certain threshold relative to
C gko::stop::RelativeResidualNorm< ValueType > 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
C gko::stop::ResidualNorm< ValueType > The ResidualNorm class is a stopping criterion which stops the iteration process when the actual residual norm is below a certain threshold relative to
C gko::stop::ResidualNormReduction< ValueType > 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
C gko::EnableAbstractPolymorphicObject< Combined, Criterion >
C gko::EnablePolymorphicObject< Combined, Criterion >
C gko::stop::Combined Used to combine multiple criterions together through an OR operation
C gko::EnableAbstractPolymorphicObject< Iteration, Criterion >
C gko::EnablePolymorphicObject< Iteration, Criterion >
C gko::stop::Iteration Stopping criterion which stops the iteration process after a preset number of iterations
C gko::EnableAbstractPolymorphicObject< ResidualNormBase< ValueType >, Criterion >
C gko::EnablePolymorphicObject< ResidualNormBase< ValueType >, Criterion >
C gko::stop::ResidualNormBase< ValueType > The ResidualNormBase class provides a framework for stopping criteria related to the residual norm
C gko::EnableAbstractPolymorphicObject< Time, Criterion >
C gko::EnablePolymorphicObject< Time, Criterion >
C gko::stop::Time Stopping criterion which stops the iteration process after a certain amount of time has passed
C gko::log::criterion_data Struct representing Criterion related data
C gko::stop::CriterionArgs This struct is used to pass parameters to the EnableDefaultCriterionFactoryCriterionFactory::generate() method
C gko::matrix::CsrBuilder< ValueType, IndexType >
C gko::cuda_stream An RAII wrapper for a custom CUDA stream
C gko::default_converter< S, R > Used to convert objects of type S to objects of type R using static_cast
C gko::deferred_factory_parameter< FactoryType > 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
C gko::device_matrix_data< ValueType, IndexType > This type is a device-side equivalent to matrix_data
C gko::DiagonalLinOpExtractable The diagonal of a LinOp can be extracted
C gko::DiagonalExtractable< default_precision >
C gko::matrix::Coo< ValueType, IndexType > COO stores a matrix in the coordinate matrix format
C gko::matrix::Csr< ValueType, IndexType > CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matrix (compressed sparse row format)
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::matrix::Ell< ValueType, IndexType > ELL is a matrix format where stride with explicit zeros is used such that all rows have the same number of stored elements
C gko::matrix::Fbcsr< ValueType, IndexType > Fixed-block compressed sparse row storage matrix format
C gko::matrix::Hybrid< ValueType, IndexType > HYBRID is a matrix format which splits the matrix into ELLPACK and COO format
C gko::matrix::Sellp< ValueType, IndexType > SELL-P is a matrix format similar to ELL format
C gko::DiagonalExtractable< ValueType > The diagonal of a LinOp implementing this interface can be extracted
C gko::matrix::Coo< ValueType, IndexType >
C gko::matrix::Csr< value_type, index_type >
C gko::matrix::Csr< ValueType, IndexType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Ell< value_type, index_type >
C gko::matrix::Ell< ValueType, IndexType >
C gko::matrix::Fbcsr< ValueType, IndexType >
C gko::dim< Dimensionality, DimensionType > A type representing the dimensions of a multidimensional object
C gko::dim< 1u, DimensionType >
C gko::experimental::distributed::DistributedBase A base class for distributed objects
C gko::experimental::distributed::Vector< ValueType >
C gko::experimental::distributed::Vector< to_complex< value_type > >
C gko::experimental::distributed::Vector< previous_precision< ValueType > >
C gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType > The Matrix class defines a (MPI-)distributed matrix
C gko::experimental::distributed::RowGatherer< LocalIndexType > The distributed::RowGatherer gathers the rows of distributed::Vector that are located on other processes
C gko::experimental::distributed::Vector< ValueType > Vector is a format which explicitly stores (multiple) distributed column vectors in a dense storage format
C gko::enable_parameters_type< ConcreteParametersType, Factory > The enable_parameters_type mixin is used to create a base implementation of the factory parameters structure
C gko::enable_parameters_type< Parameters, Factory >
C gko::batch::solver::enable_preconditioned_iterative_solver_factory_parameters< Parameters, Factory >
C gko::solver::enable_iterative_solver_factory_parameters< Parameters, Factory >
C gko::solver::enable_preconditioned_iterative_solver_factory_parameters< Parameters, Factory >
C gko::enable_parameters_type< parameters_type, Amd< IndexType > >
C gko::experimental::reorder::Amd< IndexType >::parameters_type
C gko::enable_parameters_type< parameters_type, Cholesky >
C gko::experimental::factorization::Cholesky< ValueType, IndexType >::parameters_type
C gko::enable_parameters_type< parameters_type, Factory >
C gko::batch::solver::enable_preconditioned_iterative_solver_factory_parameters< parameters_type, Factory >
C gko::batch::solver::Bicgstab< ValueType >::parameters_type
C gko::batch::solver::Cg< ValueType >::parameters_type
C gko::solver::enable_iterative_solver_factory_parameters< parameters_type, Factory >
C gko::solver::enable_preconditioned_iterative_solver_factory_parameters< parameters_type, Factory >
C gko::solver::Bicg< ValueType >::parameters_type
C gko::solver::Bicgstab< ValueType >::parameters_type
C gko::solver::CbGmres< ValueType >::parameters_type
C gko::solver::Cg< ValueType >::parameters_type
C gko::solver::Cgs< ValueType >::parameters_type
C gko::solver::Chebyshev< ValueType >::parameters_type
C gko::solver::Fcg< ValueType >::parameters_type
C gko::solver::Gcr< ValueType >::parameters_type
C gko::solver::Gmres< ValueType >::parameters_type
C gko::solver::Idr< ValueType >::parameters_type
C gko::solver::Minres< ValueType >::parameters_type
C gko::solver::PipeCg< ValueType >::parameters_type
C gko::solver::Ir< ValueType >::parameters_type
C gko::solver::Multigrid::parameters_type
C gko::batch::preconditioner::Jacobi< ValueType, IndexType >::parameters_type
C gko::experimental::distributed::preconditioner::Schwarz< ValueType, LocalIndexType, GlobalIndexType >::parameters_type
C gko::experimental::reorder::ScaledReordered< ValueType, IndexType >::parameters_type
C gko::experimental::solver::Direct< ValueType, IndexType >::parameters_type
C gko::factorization::Ic< ValueType, IndexType >::parameters_type
C gko::factorization::Ilu< ValueType, IndexType >::parameters_type
C gko::factorization::ParIc< ValueType, IndexType >::parameters_type
C gko::factorization::ParIct< ValueType, IndexType >::parameters_type
C gko::factorization::ParIlu< ValueType, IndexType >::parameters_type
C gko::factorization::ParIlut< ValueType, IndexType >::parameters_type
C gko::multigrid::FixedCoarsening< ValueType, IndexType >::parameters_type
C gko::multigrid::Pgm< ValueType, IndexType >::parameters_type
C gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >::parameters_type
C gko::preconditioner::Ilu< LSolverTypeOrValueType, USolverTypeOrValueType, ReverseApply, IndexType >::parameters_type
C gko::preconditioner::Isai< IsaiType, ValueType, IndexType >::parameters_type
C gko::preconditioner::Jacobi< ValueType, IndexType >::parameters_type
C gko::reorder::Rcm< ValueType, IndexType >::parameters_type
C gko::solver::LowerTrs< ValueType, IndexType >::parameters_type
C gko::solver::UpperTrs< ValueType, IndexType >::parameters_type
C gko::stop::AbsoluteResidualNorm< ValueType >::parameters_type
C gko::stop::Combined::parameters_type
C gko::stop::ImplicitResidualNorm< ValueType >::parameters_type
C gko::stop::Iteration::parameters_type
C gko::stop::RelativeResidualNorm< ValueType >::parameters_type
C gko::stop::ResidualNorm< ValueType >::parameters_type
C gko::stop::ResidualNormReduction< ValueType >::parameters_type
C gko::stop::Time::parameters_type
C gko::enable_parameters_type< parameters_type, GaussSeidel >
C gko::preconditioner::GaussSeidel< ValueType, IndexType >::parameters_type
C gko::enable_parameters_type< parameters_type, Lu >
C gko::experimental::factorization::Lu< ValueType, IndexType >::parameters_type
C gko::enable_parameters_type< parameters_type, Mc64 >
C gko::experimental::reorder::Mc64< ValueType, IndexType >::parameters_type
C gko::enable_parameters_type< parameters_type, Rcm< IndexType > >
C gko::experimental::reorder::Rcm< IndexType >::parameters_type
C gko::enable_parameters_type< parameters_type, Sor >
C gko::preconditioner::Sor< ValueType, IndexType >::parameters_type
C std::enable_shared_from_this
C gko::CudaExecutor This is the Executor subclass which represents the CUDA device
C gko::DpcppExecutor This is the Executor subclass which represents a DPC++ enhanced device
C gko::HipExecutor This is the Executor subclass which represents the HIP enhanced device
C gko::OmpExecutor This is the Executor subclass which represents the OpenMP device (typically CPU)
C gko::ReferenceExecutor This is a specialization of the OmpExecutor , which runs the reference implementations of the kernels used for debugging purposes
C gko::EnableCreateMethod< ConcreteType > 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
C gko::Combination< ValueType >
C gko::Composition< ValueType >
C gko::Composition< value_type >
C gko::EnableCreateMethod< Combination< default_precision > >
C gko::Combination< ValueType > The Combination class can be used to construct a linear combination of multiple linear operators c1 * op1 + c2 * op2 + ... + ck * opk
C gko::EnableCreateMethod< Composition< default_precision > >
C gko::Composition< default_precision >
C gko::Composition< ValueType > The Composition class can be used to compose linear operators op1, op2, ...,
opn and obtain the operator op1 * op2 * ... * opn
C gko::EnableCreateMethod< Composition< gko::default_precision > >
C gko::Composition< gko::default_precision >
C gko::EnableCreateMethod< Perturbation< default_precision > >
C gko::Perturbation< ValueType > The Perturbation class can be used to construct a LinOp to represent the operation (identity + scalar * basis * projector)
C gko::detail::EnableDeviceReset Controls whether the DeviceReset function should be called thanks to a boolean
C gko::CudaExecutor This is the Executor subclass which represents the CUDA device
C gko::HipExecutor This is the Executor subclass which represents the HIP enhanced device
C EnableLinOp< Ilu< solver::LowerTrs<>, gko::detail::transposed_type< solver::LowerTrs<> >, false, int32 > >
C gko::preconditioner::Ilu< LSolverTypeOrValueType, USolverTypeOrValueType, ReverseApply, IndexType > 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)
C gko::experimental::mpi::environment Class that sets up and finalizes the MPI environment
C gko::err< T >
C std::exception STL class
C gko::Error Used to report exceptional behaviour in library functions
C gko::AllocationError AllocationError is thrown if a memory allocation fails
C gko::BadDimension BadDimension is thrown if an operation is being applied to a LinOp with bad dimensions
C gko::BlockSizeError< IndexType > Error that denotes issues between block sizes and matrix dimensions
C gko::CublasError CublasError is thrown when a cuBLAS routine throws a non-zero error code
C gko::CudaError CudaError is thrown when a CUDA routine throws a non-zero error code
C gko::CufftError CufftError is thrown when a cuFFT routine throws a non-zero error code
C gko::CurandError CurandError is thrown when a cuRAND routine throws a non-zero error code
C gko::CusparseError CusparseError is thrown when a cuSPARSE routine throws a non-zero error code
C gko::DimensionMismatch DimensionMismatch is thrown if an operation is being applied to LinOps of incompatible size
C gko::HipError HipError is thrown when a HIP routine throws a non-zero error code
C gko::HipblasError HipblasError is thrown when a hipBLAS routine throws a non-zero error code
C gko::HipfftError HipfftError is thrown when a hipFFT routine throws a non-zero error code
C gko::HiprandError HiprandError is thrown when a hipRAND routine throws a non-zero error code
C gko::HipsparseError HipsparseError is thrown when a hipSPARSE routine throws a non-zero error code
C gko::InvalidStateError Exception thrown if an object is in an invalid state
C gko::KernelNotFound KernelNotFound is thrown if Ginkgo cannot find a kernel which satisfies the criteria imposed by the input arguments
C gko::MetisError MetisError is thrown when METIS routine throws an error code
C gko::MpiError MpiError is thrown when a MPI routine throws a non-zero error code
C gko::NotCompiled NotCompiled is thrown when attempting to call an operation which is a part of a module that was not compiled on the system
C gko::NotImplemented NotImplemented is thrown in case an operation has not yet been implemented (but will be implemented in the future)
C gko::NotSupported NotSupported is thrown in case it is not possible to perform the requested operation on the given object type
C gko::OutOfBoundsError OutOfBoundsError is thrown if a memory access is detected to be out-of-bounds
C gko::OverflowError OverflowError is thrown when an index calculation for storage requirements overflows
C gko::StreamError StreamError is thrown if accessing a stream failed
C gko::UnsupportedMatrixProperty Exception throws if a matrix does not have a property required by a numerical method
C gko::ValueMismatch ValueMismatch is thrown if two values are not equal
C gko::log::executor_data Struct representing Executor related data
C gko::executor_deleter< T > This is a deleter that uses an executor's free method to deallocate the data
C gko::executor_deleter< T[]>
C std::false_type
C gko::solver::has_with_criteria< SolverType, typename > Helper structure to test if the Factory of SolverType has a function with_criteria
C gko::matrix::FbcsrBuilder< ValueType, IndexType >
C gko::half A class providing basic support for half precision floating point types
C gko::hip_stream An RAII wrapper for a custom HIP stream
C hwloc_obj_t
C hwloc_obj_type_t
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::add >
C gko::accessor::add< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::bitwise_and >
C gko::accessor::bitwise_and< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::bitwise_or >
C gko::accessor::bitwise_or< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::bitwise_xor >
C gko::accessor::bitwise_xor< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::div >
C gko::accessor::div< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::equal >
C gko::accessor::equal< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::greater >
C gko::accessor::greater< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::greater_or_equal >
C gko::accessor::greater_or_equal< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::left_shift >
C gko::accessor::left_shift< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::less >
C gko::accessor::less< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::less_or_equal >
C gko::accessor::less_or_equal< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::logical_and >
C gko::accessor::logical_and< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::logical_or >
C gko::accessor::logical_or< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::max_operation >
C gko::accessor::max_operation< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::min_operation >
C gko::accessor::min_operation< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::mod >
C gko::accessor::mod< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::mul >
C gko::accessor::mul< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::not_equal >
C gko::accessor::not_equal< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::right_shift >
C gko::accessor::right_shift< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_binary_operation< Kind, FirstOperand, SecondOperand, ::gko::accessor::detail::sub >
C gko::accessor::sub< Kind, FirstOperand, SecondOperand >
C gko::detail::implement_unary_operation< Operand, ::gko::accessor::detail::abs_operation >
C gko::accessor::abs_operation< Operand >
C gko::accessor::abs_operaton< Operand >
C gko::detail::implement_unary_operation< Operand, ::gko::accessor::detail::bitwise_not >
C gko::accessor::bitwise_not< Operand >
C gko::detail::implement_unary_operation< Operand, ::gko::accessor::detail::conj_operation >
C gko::accessor::conj_operation< Operand >
C gko::accessor::conj_operaton< Operand >
C gko::detail::implement_unary_operation< Operand, ::gko::accessor::detail::imag_operation >
C gko::accessor::imag_operation< Operand >
C gko::accessor::imag_operaton< Operand >
C gko::detail::implement_unary_operation< Operand, ::gko::accessor::detail::logical_not >
C gko::accessor::logical_not< Operand >
C gko::detail::implement_unary_operation< Operand, ::gko::accessor::detail::one_operation >
C gko::accessor::one_operation< Operand >
C gko::accessor::one_operaton< Operand >
C gko::detail::implement_unary_operation< Operand, ::gko::accessor::detail::real_operation >
C gko::accessor::real_operation< Operand >
C gko::accessor::real_operaton< Operand >
C gko::detail::implement_unary_operation< Operand, ::gko::accessor::detail::squared_norm_operation >
C gko::accessor::squared_norm_operation< Operand >
C gko::accessor::squared_norm_operaton< Operand >
C gko::detail::implement_unary_operation< Operand, ::gko::accessor::detail::unary_minus >
C gko::accessor::unary_minus< Operand >
C gko::detail::implement_unary_operation< Operand, ::gko::accessor::detail::unary_plus >
C gko::accessor::unary_plus< Operand >
C gko::detail::implement_unary_operation< Operand, ::gko::accessor::detail::zero_operation >
C gko::accessor::zero_operation< Operand >
C gko::experimental::distributed::index_map< LocalIndexType, GlobalIndexType > This class defines mappings between global and local indices
C gko::index_set< IndexType > An index set class represents an ordered set of intervals
C gko::log::iteration_complete_data Struct representing iteration complete related data
C gko::solver::IterativeBase A LinOp implementing this interface stores a stopping criterion factory
C gko::solver::EnableIterativeBase< Bicg< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Bicg< default_precision > >
C gko::solver::Bicg< ValueType > BICG or the Biconjugate gradient method is a Krylov subspace solver
C gko::solver::EnableIterativeBase< Bicgstab< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Bicgstab< default_precision > >
C gko::solver::Bicgstab< ValueType > BiCGSTAB or the Bi-Conjugate Gradient-Stabilized is a Krylov subspace solver
C gko::solver::EnableIterativeBase< CbGmres< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, CbGmres< default_precision > >
C gko::solver::CbGmres< ValueType > CB-GMRES or the compressed basis generalized minimal residual method is an iterative type Krylov subspace method which is suitable for nonsymmetric linear systems
C gko::solver::EnableIterativeBase< Cg< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Cg< default_precision > >
C gko::solver::Cg< ValueType > CG or the conjugate gradient method is an iterative type Krylov subspace method which is suitable for symmetric positive definite methods
C gko::solver::EnableIterativeBase< Cgs< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Cgs< default_precision > >
C gko::solver::Cgs< ValueType > CGS or the conjugate gradient square method is an iterative type Krylov subspace method which is suitable for general systems
C gko::solver::EnableIterativeBase< Chebyshev< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Chebyshev< default_precision > >
C gko::solver::Chebyshev< ValueType > Chebyshev iteration is an iterative method for solving nonsymmetric problems based on some knowledge of the spectrum of the (preconditioned) system matrix
C gko::solver::EnableIterativeBase< Fcg< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Fcg< default_precision > >
C gko::solver::Fcg< ValueType > FCG or the flexible conjugate gradient method is an iterative type Krylov subspace method which is suitable for symmetric positive definite methods
C gko::solver::EnableIterativeBase< Gcr< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Gcr< default_precision > >
C gko::solver::Gcr< ValueType > GCR or the generalized conjugate residual method is an iterative type Krylov subspace method similar to GMRES which is suitable for nonsymmetric linear systems
C gko::solver::EnableIterativeBase< Gmres< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Gmres< default_precision > >
C gko::solver::Gmres< ValueType > GMRES or the generalized minimal residual method is an iterative type Krylov subspace method which is suitable for nonsymmetric linear systems
C gko::solver::EnableIterativeBase< Idr< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Idr< default_precision > >
C gko::solver::Idr< ValueType > IDR(s) is an efficient method for solving large nonsymmetric systems of linear equations
C gko::solver::EnableIterativeBase< Ir< default_precision > >
C gko::solver::Ir< ValueType > Iterative refinement (IR) is an iterative method that uses another coarse method to approximate the error of the current solution via the current residual
C gko::solver::EnableIterativeBase< Minres< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Minres< default_precision > >
C gko::solver::Minres< ValueType > Minres is an iterative type Krylov subspace method, which is suitable for indefinite and full-rank symmetric/hermitian operators
C gko::solver::EnableIterativeBase< Multigrid >
C gko::solver::Multigrid Multigrid methods have a hierarchy of many levels, whose corase level is a subset of the fine level, of the problem
C gko::solver::EnableIterativeBase< PipeCg< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, PipeCg< default_precision > >
C gko::solver::PipeCg< ValueType > PIPE_CG or the pipelined conjugate gradient method is an iterative type Krylov subspace method which is suitable for symmetric positive definite methods
C gko::solver::EnableIterativeBase< DerivedType > A LinOp deriving from this CRTP class stores a stopping criterion factory and allows applying with a guess
C gko::solver::Ir< ValueType >
C gko::solver::EnablePreconditionedIterativeSolver< ValueType, DerivedType > A LinOp implementing this interface stores a system matrix and stopping criterion factory
C gko::solver::Bicg< ValueType >
C gko::solver::Bicgstab< ValueType >
C gko::solver::Cg< ValueType >
C gko::solver::Cgs< ValueType >
C gko::solver::Chebyshev< ValueType >
C gko::solver::Fcg< ValueType >
C gko::solver::Gcr< ValueType >
C gko::solver::Gmres< ValueType >
C gko::solver::Idr< ValueType >
C gko::solver::Minres< ValueType >
C gko::solver::PipeCg< ValueType >
C gko::log::linop_data Struct representing LinOp related data
C gko::log::linop_factory_data Struct representing LinOp factory related data
C gko::log::Loggable Loggable class is an interface which should be implemented by classes wanting to support logging
C gko::log::EnableLogging< Executor >
C gko::Executor The first step in using the Ginkgo library consists of creating an executor
C gko::detail::ExecutorBase< CudaExecutor >
C gko::CudaExecutor This is the Executor subclass which represents the CUDA device
C gko::detail::ExecutorBase< DpcppExecutor >
C gko::DpcppExecutor This is the Executor subclass which represents a DPC++ enhanced device
C gko::detail::ExecutorBase< HipExecutor >
C gko::HipExecutor This is the Executor subclass which represents the HIP enhanced device
C gko::detail::ExecutorBase< OmpExecutor >
C gko::OmpExecutor This is the Executor subclass which represents the OpenMP device (typically CPU)
C gko::log::EnableLogging< PolymorphicObject >
C gko::PolymorphicObject A PolymorphicObject is the abstract base for all "heavy" objects in Ginkgo that behave polymorphically
C gko::EnableAbstractPolymorphicObject< AbstractFactory< AbstractProductType, ComponentsType > >
C gko::AbstractFactory< AbstractProductType, ComponentsType > The AbstractFactory is a generic interface template that enables easy implementation of the abstract factory design pattern
C gko::EnableAbstractPolymorphicObject< ConcreteObject, PolymorphicObject >
C gko::EnablePolymorphicObject< ConcreteObject, PolymorphicBase > This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a new concrete polymorphic object
C gko::experimental::distributed::Partition< LocalIndexType, GlobalIndexType >
C gko::EnableAbstractPolymorphicObject< LinOp >
C gko::LinOp
C gko::EnableAbstractPolymorphicObject< BlockOperator, LinOp >
C gko::EnablePolymorphicObject< BlockOperator, LinOp >
C gko::EnableLinOp< BlockOperator >
C gko::EnableAbstractPolymorphicObject< Combination< default_precision >, LinOp >
C gko::EnablePolymorphicObject< Combination< default_precision >, LinOp >
C gko::EnableLinOp< Combination< default_precision > >
C gko::EnableAbstractPolymorphicObject< Composition< default_precision >, LinOp >
C gko::EnablePolymorphicObject< Composition< default_precision >, LinOp >
C gko::EnableLinOp< Composition< default_precision > >
C gko::EnableAbstractPolymorphicObject< ConcreteLinOp, LinOp >
C gko::EnablePolymorphicObject< ConcreteLinOp, LinOp >
C gko::EnableLinOp< ConcreteLinOp, PolymorphicBase > The EnableLinOp mixin can be used to provide sensible default implementations of the majority of the LinOp and PolymorphicObject interface
C gko::EnableAbstractPolymorphicObject< Perturbation< default_precision >, LinOp >
C gko::EnablePolymorphicObject< Perturbation< default_precision >, LinOp >
C gko::EnableLinOp< Perturbation< default_precision > >
C gko::EnableAbstractPolymorphicObject< Matrix< default_precision, int32, int64 >, LinOp >
C gko::EnablePolymorphicObject< Matrix< default_precision, int32, int64 >, LinOp >
C gko::EnableLinOp< Matrix< default_precision, int32, int64 > >
C gko::EnableAbstractPolymorphicObject< Vector< double >, LinOp >
C gko::EnablePolymorphicObject< Vector< double >, LinOp >
C gko::EnableLinOp< Vector< double > >
C gko::EnableAbstractPolymorphicObject< Schwarz< default_precision, int32, int64 >, LinOp >
C gko::EnablePolymorphicObject< Schwarz< default_precision, int32, int64 >, LinOp >
C gko::EnableLinOp< Schwarz< default_precision, int32, int64 > >
C gko::EnableAbstractPolymorphicObject< Factorization< ValueType, IndexType >, LinOp >
C gko::EnablePolymorphicObject< Factorization< ValueType, IndexType >, LinOp >
C gko::EnableLinOp< Factorization< ValueType, IndexType > >
C gko::EnableAbstractPolymorphicObject< ScaledReordered< default_precision, int32 >, LinOp >
C gko::EnablePolymorphicObject< ScaledReordered< default_precision, int32 >, LinOp >
C gko::EnableLinOp< ScaledReordered< default_precision, int32 > >
C gko::EnableAbstractPolymorphicObject< Direct< ValueType, IndexType >, LinOp >
C gko::EnablePolymorphicObject< Direct< ValueType, IndexType >, LinOp >
C gko::EnableLinOp< Direct< ValueType, IndexType > >
C gko::EnableAbstractPolymorphicObject< Composition< gko::default_precision >, LinOp >
C gko::EnablePolymorphicObject< Composition< gko::default_precision >, LinOp >
C gko::EnableLinOp< Composition< gko::default_precision > >
C gko::EnableAbstractPolymorphicObject< Coo< default_precision, int32 >, LinOp >
C gko::EnablePolymorphicObject< Coo< default_precision, int32 >, LinOp >
C gko::EnableLinOp< Coo< default_precision, int32 > >
C gko::EnableAbstractPolymorphicObject< Csr< default_precision, int32 >, LinOp >
C gko::EnablePolymorphicObject< Csr< default_precision, int32 >, LinOp >
C gko::EnableLinOp< Csr< default_precision, int32 > >
C gko::EnableAbstractPolymorphicObject< Dense< default_precision >, LinOp >
C gko::EnablePolymorphicObject< Dense< default_precision >, LinOp >
C gko::EnableLinOp< Dense< default_precision > >
C gko::EnableAbstractPolymorphicObject< Diagonal< default_precision >, LinOp >
C gko::EnablePolymorphicObject< Diagonal< default_precision >, LinOp >
C gko::EnableLinOp< Diagonal< default_precision > >
C gko::EnableAbstractPolymorphicObject< Ell< default_precision, int32 >, LinOp >
C gko::EnablePolymorphicObject< Ell< default_precision, int32 >, LinOp >
C gko::EnableLinOp< Ell< default_precision, int32 > >
C gko::EnableAbstractPolymorphicObject< Fbcsr< default_precision, int32 >, LinOp >
C gko::EnablePolymorphicObject< Fbcsr< default_precision, int32 >, LinOp >
C gko::EnableLinOp< Fbcsr< default_precision, int32 > >
C gko::EnableAbstractPolymorphicObject< Fft, LinOp >
C gko::EnablePolymorphicObject< Fft, LinOp >
C gko::EnableLinOp< Fft >
C gko::EnableAbstractPolymorphicObject< Fft2, LinOp >
C gko::EnablePolymorphicObject< Fft2, LinOp >
C gko::EnableLinOp< Fft2 >
C gko::EnableAbstractPolymorphicObject< Fft3, LinOp >
C gko::EnablePolymorphicObject< Fft3, LinOp >
C gko::EnableLinOp< Fft3 >
C gko::EnableAbstractPolymorphicObject< Hybrid< default_precision, int32 >, LinOp >
C gko::EnablePolymorphicObject< Hybrid< default_precision, int32 >, LinOp >
C gko::EnableLinOp< Hybrid< default_precision, int32 > >
C gko::EnableAbstractPolymorphicObject< Identity< default_precision >, LinOp >
C gko::EnablePolymorphicObject< Identity< default_precision >, LinOp >
C gko::EnableLinOp< Identity< default_precision > >
C gko::EnableAbstractPolymorphicObject< Permutation< int32 >, LinOp >
C gko::EnablePolymorphicObject< Permutation< int32 >, LinOp >
C gko::EnableLinOp< Permutation< int32 > >
C gko::EnableAbstractPolymorphicObject< RowGatherer< int32 >, LinOp >
C gko::EnablePolymorphicObject< RowGatherer< int32 >, LinOp >
C gko::EnableLinOp< RowGatherer< int32 > >
C gko::EnableAbstractPolymorphicObject< ScaledPermutation< default_precision, int32 >, LinOp >
C gko::EnablePolymorphicObject< ScaledPermutation< default_precision, int32 >, LinOp >
C gko::EnableLinOp< ScaledPermutation< default_precision, int32 > >
C gko::EnableAbstractPolymorphicObject< Sellp< default_precision, int32 >, LinOp >
C gko::EnablePolymorphicObject< Sellp< default_precision, int32 >, LinOp >
C gko::EnableLinOp< Sellp< default_precision, int32 > >
C gko::EnableAbstractPolymorphicObject< SparsityCsr< default_precision, int32 >, LinOp >
C gko::EnablePolymorphicObject< SparsityCsr< default_precision, int32 >, LinOp >
C gko::EnableLinOp< SparsityCsr< default_precision, int32 > >
C gko::EnableAbstractPolymorphicObject< FixedCoarsening< default_precision, int32 >, LinOp >
C gko::EnablePolymorphicObject< FixedCoarsening< default_precision, int32 >, LinOp >
C gko::EnableLinOp< FixedCoarsening< default_precision, int32 > >
C gko::EnableAbstractPolymorphicObject< Pgm< default_precision, int32 >, LinOp >
C gko::EnablePolymorphicObject< Pgm< default_precision, int32 >, LinOp >
C gko::EnableLinOp< Pgm< default_precision, int32 > >
C gko::EnableAbstractPolymorphicObject< Ic< solver::LowerTrs<>, int32 >, LinOp >
C gko::EnablePolymorphicObject< Ic< solver::LowerTrs<>, int32 >, LinOp >
C gko::EnableLinOp< Ic< solver::LowerTrs<>, int32 > >
C gko::EnableAbstractPolymorphicObject< Isai< IsaiType, ValueType, IndexType >, LinOp >
C gko::EnablePolymorphicObject< Isai< IsaiType, ValueType, IndexType >, LinOp >
C gko::EnableLinOp< Isai< IsaiType, ValueType, IndexType > >
C gko::EnableAbstractPolymorphicObject< Jacobi< default_precision, int32 >, LinOp >
C gko::EnablePolymorphicObject< Jacobi< default_precision, int32 >, LinOp >
C gko::EnableLinOp< Jacobi< default_precision, int32 > >
C gko::EnableAbstractPolymorphicObject< Bicg< default_precision >, LinOp >
C gko::EnablePolymorphicObject< Bicg< default_precision >, LinOp >
C gko::EnableLinOp< Bicg< default_precision > >
C gko::EnableAbstractPolymorphicObject< Bicgstab< default_precision >, LinOp >
C gko::EnablePolymorphicObject< Bicgstab< default_precision >, LinOp >
C gko::EnableLinOp< Bicgstab< default_precision > >
C gko::EnableAbstractPolymorphicObject< CbGmres< default_precision >, LinOp >
C gko::EnablePolymorphicObject< CbGmres< default_precision >, LinOp >
C gko::EnableLinOp< CbGmres< default_precision > >
C gko::EnableAbstractPolymorphicObject< Cg< default_precision >, LinOp >
C gko::EnablePolymorphicObject< Cg< default_precision >, LinOp >
C gko::EnableLinOp< Cg< default_precision > >
C gko::EnableAbstractPolymorphicObject< Cgs< default_precision >, LinOp >
C gko::EnablePolymorphicObject< Cgs< default_precision >, LinOp >
C gko::EnableLinOp< Cgs< default_precision > >
C gko::EnableAbstractPolymorphicObject< Chebyshev< default_precision >, LinOp >
C gko::EnablePolymorphicObject< Chebyshev< default_precision >, LinOp >
C gko::EnableLinOp< Chebyshev< default_precision > >
C gko::EnableAbstractPolymorphicObject< Fcg< default_precision >, LinOp >
C gko::EnablePolymorphicObject< Fcg< default_precision >, LinOp >
C gko::EnableLinOp< Fcg< default_precision > >
C gko::EnableAbstractPolymorphicObject< Gcr< default_precision >, LinOp >
C gko::EnablePolymorphicObject< Gcr< default_precision >, LinOp >
C gko::EnableLinOp< Gcr< default_precision > >
C gko::EnableAbstractPolymorphicObject< Gmres< default_precision >, LinOp >
C gko::EnablePolymorphicObject< Gmres< default_precision >, LinOp >
C gko::EnableLinOp< Gmres< default_precision > >
C gko::EnableAbstractPolymorphicObject< Idr< default_precision >, LinOp >
C gko::EnablePolymorphicObject< Idr< default_precision >, LinOp >
C gko::EnableLinOp< Idr< default_precision > >
C gko::EnableAbstractPolymorphicObject< Ir< default_precision >, LinOp >
C gko::EnablePolymorphicObject< Ir< default_precision >, LinOp >
C gko::EnableLinOp< Ir< default_precision > >
C gko::EnableAbstractPolymorphicObject< LowerTrs< default_precision, int32 >, LinOp >
C gko::EnablePolymorphicObject< LowerTrs< default_precision, int32 >, LinOp >
C gko::EnableLinOp< LowerTrs< default_precision, int32 > >
C gko::EnableAbstractPolymorphicObject< Minres< default_precision >, LinOp >
C gko::EnablePolymorphicObject< Minres< default_precision >, LinOp >
C gko::EnableLinOp< Minres< default_precision > >
C gko::EnableAbstractPolymorphicObject< Multigrid, LinOp >
C gko::EnablePolymorphicObject< Multigrid, LinOp >
C gko::EnableLinOp< Multigrid >
C gko::EnableAbstractPolymorphicObject< PipeCg< default_precision >, LinOp >
C gko::EnablePolymorphicObject< PipeCg< default_precision >, LinOp >
C gko::EnableLinOp< PipeCg< default_precision > >
C gko::EnableAbstractPolymorphicObject< UpperTrs< default_precision, int32 >, LinOp >
C gko::EnablePolymorphicObject< UpperTrs< default_precision, int32 >, LinOp >
C gko::EnableLinOp< UpperTrs< default_precision, int32 > >
C gko::EnableAbstractPolymorphicObject< AbstractFactory< LinOp, std::shared_ptr< const LinOp > > >
C gko::AbstractFactory< LinOp, std::shared_ptr< const LinOp > >
C gko::LinOpFactory A LinOpFactory represents a higher order mapping which transforms one linear operator into another
C gko::EnableAbstractPolymorphicObject< Cholesky< ValueType, IndexType >, LinOpFactory >
C gko::EnablePolymorphicObject< Cholesky< ValueType, IndexType >, LinOpFactory >
C gko::experimental::factorization::Cholesky< ValueType, IndexType > Computes a Cholesky factorization of a symmetric, positive-definite sparse matrix
C gko::EnableAbstractPolymorphicObject< Lu< ValueType, IndexType >, LinOpFactory >
C gko::EnablePolymorphicObject< Lu< ValueType, IndexType >, LinOpFactory >
C gko::experimental::factorization::Lu< ValueType, IndexType > Computes an LU factorization of a sparse matrix
C gko::EnableAbstractPolymorphicObject< Amd< int32 >, LinOpFactory >
C gko::EnablePolymorphicObject< Amd< int32 >, LinOpFactory >
C gko::experimental::reorder::Amd< IndexType > Computes a Approximate Minimum Degree (AMD) reordering of an input matrix
C gko::EnableAbstractPolymorphicObject< Mc64< default_precision, int32 >, LinOpFactory >
C gko::EnablePolymorphicObject< Mc64< default_precision, int32 >, LinOpFactory >
C gko::experimental::reorder::Mc64< ValueType, IndexType > MC64 is an algorithm for permuting large entries to the diagonal of a sparse matrix
C gko::EnableAbstractPolymorphicObject< Rcm< int32 >, LinOpFactory >
C gko::EnablePolymorphicObject< Rcm< int32 >, LinOpFactory >
C gko::experimental::reorder::Rcm< IndexType > Rcm (Reverse Cuthill-McKee) is a reordering algorithm minimizing the bandwidth of a matrix
C gko::EnableAbstractPolymorphicObject< IdentityFactory< default_precision >, LinOpFactory >
C gko::EnablePolymorphicObject< IdentityFactory< default_precision >, LinOpFactory >
C gko::matrix::IdentityFactory< ValueType > This factory is a utility which can be used to generate Identity operators
C gko::EnableAbstractPolymorphicObject< GaussSeidel< default_precision, int32 >, LinOpFactory >
C gko::EnablePolymorphicObject< GaussSeidel< default_precision, int32 >, LinOpFactory >
C gko::preconditioner::GaussSeidel< ValueType, IndexType > This class generates the Gauss-Seidel preconditioner
C gko::EnableAbstractPolymorphicObject< Sor< default_precision, int32 >, LinOpFactory >
C gko::EnablePolymorphicObject< Sor< default_precision, int32 >, LinOpFactory >
C gko::preconditioner::Sor< ValueType, IndexType > This class generates the (S)SOR preconditioner
C gko::EnableAbstractPolymorphicObject< BatchLinOp >
C gko::batch::BatchLinOp
C gko::EnableAbstractPolymorphicObject< AbstractFactory< BatchLinOp, std::shared_ptr< const BatchLinOp > > >
C gko::AbstractFactory< BatchLinOp, std::shared_ptr< const BatchLinOp > >
C gko::batch::BatchLinOpFactory A BatchLinOpFactory represents a higher order mapping which transforms one batch linear operator into another
C gko::EnableAbstractPolymorphicObject< MultiVector< default_precision >, PolymorphicObject >
C gko::EnablePolymorphicObject< MultiVector< default_precision > >
C gko::batch::MultiVector< ValueType > MultiVector stores multiple vectors in a batched fashion and is useful for batched operations
C gko::EnableAbstractPolymorphicObject< Partition< int32, int64 >, PolymorphicObject >
C gko::EnablePolymorphicObject< Partition< int32, int64 > >
C gko::experimental::distributed::Partition< LocalIndexType, GlobalIndexType > Represents a partition of a range of indices [0, size) into a disjoint set of parts
C gko::EnableAbstractPolymorphicObject< RowGatherer< int32 >, PolymorphicObject >
C gko::EnablePolymorphicObject< RowGatherer< int32 > >
C gko::experimental::distributed::RowGatherer< LocalIndexType > The distributed::RowGatherer gathers the rows of distributed::Vector that are located on other processes
C gko::EnableAbstractPolymorphicObject< ReorderingBase< int32 > >
C gko::reorder::ReorderingBase< int32 >
C gko::reorder::ReorderingBase< IndexType > The ReorderingBase class is a base class for all the reordering algorithms
C gko::EnableAbstractPolymorphicObject< Criterion >
C gko::stop::Criterion Base class for all stopping criteria
C gko::EnableAbstractPolymorphicObject< AbstractObject, PolymorphicBase > This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a new abstract object
C gko::AbstractFactory< ReorderingBase< IndexType >, ReorderingBaseArgs >
C gko::AbstractFactory< gko::reorder::ReorderingBase< IndexType >, gko::reorder::ReorderingBaseArgs >
C gko::AbstractFactory< Criterion, CriterionArgs >
C gko::log::EnableLogging< ConcreteLoggable, PolymorphicBase > EnableLogging is a mixin which should be inherited by any class which wants to enable logging
C gko::log::Record::logged_data Struct storing the actually logged data
C gko::log::Logger
C gko::batch::log::BatchConvergence< ValueType > Logs the final residuals and iteration counts for a batch solver
C gko::log::Convergence< ValueType > Convergence is a Logger which logs data strictly from the criterion_check_completed event
C gko::log::Papi< ValueType > Papi is a Logger which logs every event to the PAPI software
C gko::log::PerformanceHint PerformanceHint is a Logger which analyzes the performance of the application and outputs hints for unnecessary copies and allocations
C gko::log::ProfilerHook This Logger can be used to annotate the execution of Ginkgo functionality with profiler-specific ranges
C gko::log::Record Record is a Logger which logs every event to an object
C gko::log::SolverProgress This Logger outputs the value of all scalar values (and potentially vectors) stored internally by the solver after each iteration
C gko::log::Stream< ValueType > Stream is a Logger which logs every event to a stream
C gko::machine_topology The machine topology class represents the hierarchical topology of a machine, including NUMA nodes, cores and PCI Devices
C gko::matrix_assembly_data< ValueType, IndexType > This structure is used as an intermediate type to assemble a sparse matrix
C gko::matrix_data< ValueType, IndexType > This structure is used as an intermediate data type to store a sparse matrix
C gko::matrix_data_entry< ValueType, IndexType > Type used to store nonzeros
C gko::accessor::mmul_operation< Kind, FirstAccessor, SecondAccessor >
C gko::multigrid::MultigridLevel This class represents two levels in a multigrid hierarchy
C gko::multigrid::EnableMultigridLevel< default_precision >
C gko::multigrid::FixedCoarsening< ValueType, IndexType > FixedCoarsening is a very simple coarse grid generation algorithm
C gko::multigrid::Pgm< ValueType, IndexType > Parallel graph match (Pgm ) is the aggregate method introduced in the paper M
C gko::multigrid::EnableMultigridLevel< ValueType > The EnableMultigridLevel gives the default implementation of MultigridLevel with composition and provides set_multigrid_level function
C gko::log::ProfilerHook::nested_summary_entry
C gko::log::ProfilerHook::NestedSummaryWriter Receives the results from ProfilerHook::create_nested_summary()
C gko::log::ProfilerHook::TableSummaryWriter Writes the results from ProfilerHook::create_summary() and ProfilerHook::create_nested_summary() to a ASCII table in Markdown format
C gko::null_deleter< T > This is a deleter that does not delete the object
C gko::null_deleter< T[]>
C gko::nvidia_device Nvidia_device handles the number of executor on Nvidia devices and have the corresponding recursive_mutex
C gko::Operation Operations can be used to define functionalities whose implementations differ among devices
C gko::log::operation_data Struct representing Operator related data
C gko::Permutable< IndexType > Linear operators which support permutation should implement the Permutable interface
C gko::matrix::Csr< value_type, index_type >
C gko::matrix::Csr< ValueType, IndexType >
C gko::Permutable< int32 >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Csr< ValueType, IndexType > CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matrix (compressed sparse row format)
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::Permutable< int64 >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::matrix::Csr< ValueType, IndexType >::permuting_reuse_info A struct describing a transformation of the matrix that reorders the values of the matrix into the transformed matrix
C gko::config::pnode Pnode describes a tree of properties
C gko::log::polymorphic_object_data Struct representing PolymorphicObject related data
C PolymorphicBase
C gko::EnableAbstractPolymorphicObject< ConcreteFactory, PolymorphicBase >
C gko::EnablePolymorphicObject< ConcreteFactory, PolymorphicBase >
C gko::EnableDefaultFactory< ConcreteFactory, ConcreteBatchLinOp, ParametersType, PolymorphicBase >
C gko::EnableDefaultFactory< ConcreteFactory, ConcreteLinOp, ParametersType, PolymorphicBase >
C gko::EnableDefaultFactory< ConcreteFactory, ConcreteReorderingBase, ParametersType, PolymorphicBase >
C gko::EnableDefaultFactory< ConcreteFactory, ConcreteCriterion, ParametersType, PolymorphicBase >
C gko::EnableDefaultFactory< ConcreteFactory, ProductType, ParametersType, PolymorphicBase > This mixin provides a default implementation of a concrete factory
C gko::precision_reduction This class is used to encode storage precisions of low precision algorithms
C gko::Preconditionable A LinOp implementing this interface can be preconditioned
C gko::solver::EnablePreconditionable< Bicg< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Bicg< default_precision > >
C gko::solver::EnablePreconditionable< Bicgstab< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Bicgstab< default_precision > >
C gko::solver::EnablePreconditionable< CbGmres< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, CbGmres< default_precision > >
C gko::solver::EnablePreconditionable< Cg< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Cg< default_precision > >
C gko::solver::EnablePreconditionable< Cgs< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Cgs< default_precision > >
C gko::solver::EnablePreconditionable< Chebyshev< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Chebyshev< default_precision > >
C gko::solver::EnablePreconditionable< Fcg< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Fcg< default_precision > >
C gko::solver::EnablePreconditionable< Gcr< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Gcr< default_precision > >
C gko::solver::EnablePreconditionable< Gmres< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Gmres< default_precision > >
C gko::solver::EnablePreconditionable< Idr< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Idr< default_precision > >
C gko::solver::EnablePreconditionable< Minres< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Minres< default_precision > >
C gko::solver::EnablePreconditionable< PipeCg< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, PipeCg< default_precision > >
C gko::solver::EnablePreconditionable< DerivedType > Mixin providing default operation for Preconditionable with correct value semantics
C gko::solver::EnablePreconditionedIterativeSolver< ValueType, DerivedType > A LinOp implementing this interface stores a system matrix and stopping criterion factory
C gko::log::profiling_scope_guard Scope guard that annotates its scope with the provided profiler hooks
C gko::ptr_param< T > This class is used for function parameters in the place of raw pointers
C gko::range< Accessor > A range is a multidimensional view of the memory
C gko::syn::range< Start, End, Step > Range records start, end, step in template
C gko::ReadableFromMatrixData< ValueType, IndexType > A LinOp implementing this interface can read its data from a matrix_data structure
C gko::matrix::Coo< ValueType, IndexType >
C gko::matrix::Csr< value_type, index_type >
C gko::matrix::Csr< ValueType, IndexType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Diagonal< ValueType >
C gko::matrix::Diagonal< ValueType >
C gko::matrix::Ell< value_type, index_type >
C gko::matrix::Ell< ValueType, IndexType >
C gko::matrix::Fbcsr< ValueType, IndexType >
C gko::matrix::SparsityCsr< value_type, index_type >
C gko::matrix::SparsityCsr< IndexType, ValueType >
C gko::matrix::SparsityCsr< ValueType, IndexType >
C gko::ReadableFromMatrixData< default_precision, int32 >
C gko::matrix::Coo< ValueType, IndexType > COO stores a matrix in the coordinate matrix format
C gko::matrix::Csr< ValueType, IndexType > CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matrix (compressed sparse row format)
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::matrix::Diagonal< ValueType > This class is a utility which efficiently implements the diagonal matrix (a linear operator which scales a vector row wise)
C gko::matrix::Ell< ValueType, IndexType > ELL is a matrix format where stride with explicit zeros is used such that all rows have the same number of stored elements
C gko::matrix::Fbcsr< ValueType, IndexType > Fixed-block compressed sparse row storage matrix format
C gko::matrix::Hybrid< ValueType, IndexType > HYBRID is a matrix format which splits the matrix into ELLPACK and COO format
C gko::matrix::Sellp< ValueType, IndexType > SELL-P is a matrix format similar to ELL format
C gko::matrix::SparsityCsr< ValueType, IndexType > 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)
C gko::ReadableFromMatrixData< default_precision, int64 >
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::matrix::Diagonal< ValueType > This class is a utility which efficiently implements the diagonal matrix (a linear operator which scales a vector row wise)
C gko::config::registry This class stores additional context for creating Ginkgo objects from configuration files
C ReorderingBase
C gko::EnableAbstractPolymorphicObject< Rcm< default_precision, int32 >, ReorderingBase< int32 > >
C gko::EnablePolymorphicObject< Rcm< default_precision, int32 >, ReorderingBase< int32 > >
C gko::reorder::Rcm< ValueType, IndexType > Rcm (Reverse Cuthill-McKee) is a reordering algorithm minimizing the bandwidth of a matrix
C gko::reorder::ReorderingBaseArgs This struct is used to pass parameters to the EnableDefaultReorderingBaseFactory::generate() method
C gko::experimental::mpi::request Light, move-only wrapper around the MPI_Request handle
C gko::accessor::row_major< ValueType, Dimensionality > A row_major accessor is a bridge between a range and the row-major memory layout
C gko::ScaledIdentityAddable 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
C gko::matrix::Csr< value_type, index_type >
C gko::matrix::Csr< ValueType, IndexType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Csr< ValueType, IndexType > CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matrix (compressed sparse row format)
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::scoped_device_id_guard This move-only class uses RAII to set the device id within a scoped block, if necessary
C gko::segmented_array< T > A minimal interface for a segmented array
C gko::solver::detail::SolverBaseLinOp A LinOp implementing this interface stores a system matrix
C gko::solver::SolverBase< factorization::Factorization< ValueType, IndexType > >
C gko::solver::EnableSolverBase< Direct< ValueType, IndexType >, factorization::Factorization< ValueType, IndexType > >
C gko::experimental::solver::Direct< ValueType, IndexType > A direct solver based on a factorization into lower and upper triangular factors (with an optional diagonal scaling)
C gko::solver::SolverBase< LinOp >
C gko::solver::EnableSolverBase< Bicg< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Bicg< default_precision > >
C gko::solver::EnableSolverBase< Bicgstab< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Bicgstab< default_precision > >
C gko::solver::EnableSolverBase< CbGmres< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, CbGmres< default_precision > >
C gko::solver::EnableSolverBase< Cg< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Cg< default_precision > >
C gko::solver::EnableSolverBase< Cgs< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Cgs< default_precision > >
C gko::solver::EnableSolverBase< Chebyshev< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Chebyshev< default_precision > >
C gko::solver::EnableSolverBase< Fcg< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Fcg< default_precision > >
C gko::solver::EnableSolverBase< Gcr< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Gcr< default_precision > >
C gko::solver::EnableSolverBase< Gmres< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Gmres< default_precision > >
C gko::solver::EnableSolverBase< Idr< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Idr< default_precision > >
C gko::solver::EnableSolverBase< Ir< default_precision > >
C gko::solver::Ir< ValueType > Iterative refinement (IR) is an iterative method that uses another coarse method to approximate the error of the current solution via the current residual
C gko::solver::EnableSolverBase< Minres< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, Minres< default_precision > >
C gko::solver::EnableSolverBase< Multigrid >
C gko::solver::Multigrid Multigrid methods have a hierarchy of many levels, whose corase level is a subset of the fine level, of the problem
C gko::solver::EnableSolverBase< PipeCg< default_precision > >
C gko::solver::EnablePreconditionedIterativeSolver< default_precision, PipeCg< default_precision > >
C gko::solver::EnableSolverBase< DerivedType, MatrixType > A LinOp deriving from this CRTP class stores a system matrix
C gko::solver::Ir< ValueType >
C gko::solver::LowerTrs< value_type, index_type >
C gko::solver::LowerTrs< ValueType, IndexType >
C gko::solver::UpperTrs< value_type, index_type >
C gko::solver::UpperTrs< ValueType, IndexType >
C gko::solver::EnablePreconditionedIterativeSolver< ValueType, DerivedType > A LinOp implementing this interface stores a system matrix and stopping criterion factory
C gko::solver::SolverBase< matrix::Csr< default_precision, int32 > >
C gko::solver::EnableSolverBase< LowerTrs< default_precision, int32 >, matrix::Csr< default_precision, int32 > >
C gko::solver::LowerTrs< ValueType, IndexType > LowerTrs is the triangular solver which solves the system L x = b, when L is a lower triangular matrix
C gko::solver::EnableSolverBase< UpperTrs< default_precision, int32 >, matrix::Csr< default_precision, int32 > >
C gko::solver::UpperTrs< ValueType, IndexType > UpperTrs is the triangular solver which solves the system U x = b, when U is an upper triangular matrix
C gko::solver::SolverBase< MatrixType >
C gko::span A span is a lightweight structure used to create sub-ranges from other ranges
C gko::experimental::mpi::status The status struct is a light wrapper around the MPI_Status struct
C gko::stopping_status This class is used to keep track of the stopping status of one vector
C gko::matrix::Csr< ValueType, IndexType >::strategy_type Strategy_type is to decide how to set the csr algorithm
C gko::matrix::Csr< ValueType, IndexType >::automatical
C gko::matrix::Csr< ValueType, IndexType >::classical Classical is a strategy_type which uses the same number of threads on each row
C gko::matrix::Csr< ValueType, IndexType >::cusparse Cusparse is a strategy_type which uses the sparselib csr
C gko::matrix::Csr< ValueType, IndexType >::load_balance Load_balance is a strategy_type which uses the load balance algorithm
C gko::matrix::Csr< ValueType, IndexType >::merge_path Merge_path is a strategy_type which uses the merge_path algorithm
C gko::matrix::Csr< ValueType, IndexType >::sparselib Sparselib is a strategy_type which uses the sparselib csr
C gko::matrix::Hybrid< ValueType, IndexType >::strategy_type Strategy_type is to decide how to set the hybrid config
C gko::matrix::Hybrid< ValueType, IndexType >::automatic Automatic is a strategy_type which decides the number of stored elements per row of the ell part automatically
C gko::matrix::Hybrid< ValueType, IndexType >::column_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
C gko::matrix::Hybrid< ValueType, IndexType >::imbalance_bounded_limit Imbalance_bounded_limit is a strategy_type which decides the number of stored elements per row of the ell part
C gko::matrix::Hybrid< ValueType, IndexType >::imbalance_limit Imbalance_limit is a strategy_type which decides the number of stored elements per row of the ell part according to the percent
C gko::matrix::Hybrid< ValueType, IndexType >::minimal_storage_limit Minimal_storage_limit is a strategy_type which decides the number of stored elements per row of the ell part
C gko::log::ProfilerHook::summary_entry
C gko::log::ProfilerHook::SummaryWriter Receives the results from ProfilerHook::create_summary()
C gko::log::ProfilerHook::TableSummaryWriter Writes the results from ProfilerHook::create_summary() and ProfilerHook::create_nested_summary() to a ASCII table in Markdown format
C gko::time_point An opaque wrapper for a time point generated by a timer
C gko::Timer Represents a generic timer that can be used to record time points and measure time differences on host or device streams
C gko::CpuTimer A timer using std::chrono::steady_clock for timing
C gko::CudaTimer A timer using events for timing on a CudaExecutor
C gko::DpcppTimer A timer using kernels for timing on a DpcppExecutor in profiling mode
C gko::HipTimer A timer using events for timing on a HipExecutor
C gko::Transposable Linear operators which support transposition should implement the Transposable interface
C gko::Combination< ValueType >
C gko::Composition< ValueType >
C gko::Composition< value_type >
C gko::Composition< gko::default_precision >
C gko::Composition< default_precision >
C gko::matrix::Coo< ValueType, IndexType >
C gko::matrix::Csr< value_type, index_type >
C gko::matrix::Csr< ValueType, IndexType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Diagonal< ValueType >
C gko::matrix::Fbcsr< ValueType, IndexType >
C gko::matrix::Identity< ValueType >
C gko::matrix::SparsityCsr< value_type, index_type >
C gko::matrix::SparsityCsr< IndexType, ValueType >
C gko::matrix::SparsityCsr< ValueType, IndexType >
C gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >
C gko::preconditioner::Isai< IsaiType==isai_type::general ? isai_type::general :IsaiType==isai_type::spd ? isai_type::spd :IsaiType==isai_type::lower ? isai_type::upper :isai_type::lower, ValueType, IndexType >
C gko::preconditioner::Isai< isai_type::lower, ValueType, IndexType >
C gko::preconditioner::Isai< isai_type::upper, ValueType, IndexType >
C gko::preconditioner::Isai< isai_type::general, ValueType, IndexType >
C gko::preconditioner::Isai< isai_type::spd, ValueType, IndexType >
C gko::preconditioner::Jacobi< ValueType, IndexType >
C gko::solver::Bicg< ValueType >
C gko::solver::Bicgstab< ValueType >
C gko::solver::Cg< ValueType >
C gko::solver::Cgs< ValueType >
C gko::solver::Chebyshev< ValueType >
C gko::solver::Fcg< ValueType >
C gko::solver::Gcr< ValueType >
C gko::solver::Gmres< ValueType >
C gko::solver::Idr< ValueType >
C gko::solver::Ir< ValueType >
C gko::solver::LowerTrs< value_type, index_type >
C gko::solver::LowerTrs< ValueType, IndexType >
C gko::solver::Minres< ValueType >
C gko::solver::PipeCg< ValueType >
C gko::solver::UpperTrs< value_type, index_type >
C gko::solver::UpperTrs< ValueType, IndexType >
C gko::Combination< ValueType > The Combination class can be used to construct a linear combination of multiple linear operators c1 * op1 + c2 * op2 + ... + ck * opk
C gko::Composition< ValueType > The Composition class can be used to compose linear operators op1, op2, ...,
opn and obtain the operator op1 * op2 * ... * opn
C gko::experimental::solver::Direct< ValueType, IndexType > A direct solver based on a factorization into lower and upper triangular factors (with an optional diagonal scaling)
C gko::matrix::Coo< ValueType, IndexType > COO stores a matrix in the coordinate matrix format
C gko::matrix::Csr< ValueType, IndexType > CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matrix (compressed sparse row format)
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::matrix::Diagonal< ValueType > This class is a utility which efficiently implements the diagonal matrix (a linear operator which scales a vector row wise)
C gko::matrix::Fbcsr< ValueType, IndexType > Fixed-block compressed sparse row storage matrix format
C gko::matrix::Fft This LinOp implements a 1D Fourier matrix using the FFT algorithm
C gko::matrix::Fft2 This LinOp implements a 2D Fourier matrix using the FFT algorithm
C gko::matrix::Fft3 This LinOp implements a 3D Fourier matrix using the FFT algorithm
C gko::matrix::Identity< ValueType > This class is a utility which efficiently implements the identity matrix (a linear operator which maps each vector to itself)
C gko::matrix::SparsityCsr< ValueType, IndexType > 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)
C gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType > 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)
C gko::preconditioner::Ilu< LSolverTypeOrValueType, USolverTypeOrValueType, ReverseApply, IndexType > 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)
C gko::preconditioner::Isai< IsaiType, ValueType, IndexType > 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
C gko::preconditioner::Jacobi< ValueType, IndexType > A block-Jacobi preconditioner is a block-diagonal linear operator, obtained by inverting the diagonal blocks of the source operator
C gko::solver::Bicg< ValueType > BICG or the Biconjugate gradient method is a Krylov subspace solver
C gko::solver::Bicgstab< ValueType > BiCGSTAB or the Bi-Conjugate Gradient-Stabilized is a Krylov subspace solver
C gko::solver::Cg< ValueType > CG or the conjugate gradient method is an iterative type Krylov subspace method which is suitable for symmetric positive definite methods
C gko::solver::Cgs< ValueType > CGS or the conjugate gradient square method is an iterative type Krylov subspace method which is suitable for general systems
C gko::solver::Chebyshev< ValueType > Chebyshev iteration is an iterative method for solving nonsymmetric problems based on some knowledge of the spectrum of the (preconditioned) system matrix
C gko::solver::Fcg< ValueType > FCG or the flexible conjugate gradient method is an iterative type Krylov subspace method which is suitable for symmetric positive definite methods
C gko::solver::Gcr< ValueType > GCR or the generalized conjugate residual method is an iterative type Krylov subspace method similar to GMRES which is suitable for nonsymmetric linear systems
C gko::solver::Gmres< ValueType > GMRES or the generalized minimal residual method is an iterative type Krylov subspace method which is suitable for nonsymmetric linear systems
C gko::solver::Idr< ValueType > IDR(s) is an efficient method for solving large nonsymmetric systems of linear equations
C gko::solver::Ir< ValueType > Iterative refinement (IR) is an iterative method that uses another coarse method to approximate the error of the current solution via the current residual
C gko::solver::LowerTrs< ValueType, IndexType > LowerTrs is the triangular solver which solves the system L x = b, when L is a lower triangular matrix
C gko::solver::Minres< ValueType > Minres is an iterative type Krylov subspace method, which is suitable for indefinite and full-rank symmetric/hermitian operators
C gko::solver::PipeCg< ValueType > PIPE_CG or the pipelined conjugate gradient method is an iterative type Krylov subspace method which is suitable for symmetric positive definite methods
C gko::solver::UpperTrs< ValueType, IndexType > UpperTrs is the triangular solver which solves the system U x = b, when U is an upper triangular matrix
C gko::accessor::transpose_operation< Accessor >
C std::true_type
C gko::are_all_integral< First, Args... >
C gko::are_all_integral< Args > Evaluates if all template arguments Args fulfill std::is_integral
C gko::truncated< typename, size_t, size_t >
C std::conditional::type
C gko::are_all_integral< First, Args... >
C gko::config::type_descriptor This class describes the value and index types to be used when building a Ginkgo type from a configuration file
C gko::xstd::type_identity< T >
C gko::experimental::mpi::type_impl< T > A struct that is used to determine the MPI_Datatype of a specified type
C gko::experimental::mpi::type_impl< char >
C gko::experimental::mpi::type_impl< double >
C gko::experimental::mpi::type_impl< float >
C gko::experimental::mpi::type_impl< int >
C gko::experimental::mpi::type_impl< long >
C gko::experimental::mpi::type_impl< long double >
C gko::experimental::mpi::type_impl< long long >
C gko::experimental::mpi::type_impl< unsigned >
C gko::experimental::mpi::type_impl< unsigned char >
C gko::experimental::mpi::type_impl< unsigned long >
C gko::experimental::mpi::type_impl< unsigned long long >
C gko::experimental::mpi::type_impl< unsigned short >
C gko::syn::type_list< Types > Type_list records several types in template
C gko::stop::Criterion::Updater Serves for convenient argument passing to the Criterion 's check function
C gko::UseComposition< ValueType > The UseComposition class can be used to store the composition information in LinOp
C gko::UseComposition< default_precision >
C gko::multigrid::EnableMultigridLevel< default_precision >
C gko::UseComposition< ValueType >
C gko::multigrid::EnableMultigridLevel< ValueType > The EnableMultigridLevel gives the default implementation of MultigridLevel with composition and provides set_multigrid_level function
C gko::syn::value_list< T, Values > Value_list records several values with the same type in template
C gko::version This structure is used to represent versions of various Ginkgo modules
C gko::version_info Ginkgo uses version numbers to label new features and to communicate backward compatibility guarantees:
C gko::experimental::mpi::window< ValueType > This class wraps the MPI_Window class with RAII functionality
C gko::solver::workspace_traits< Solver > Traits class providing information on the type and location of workspace vectors inside a solver
C gko::solver::workspace_traits< Bicg< ValueType > >
C gko::solver::workspace_traits< Bicgstab< ValueType > >
C gko::solver::workspace_traits< Cg< ValueType > >
C gko::solver::workspace_traits< Cgs< ValueType > >
C gko::solver::workspace_traits< Chebyshev< ValueType > >
C gko::solver::workspace_traits< Fcg< ValueType > >
C gko::solver::workspace_traits< Gcr< ValueType > >
C gko::solver::workspace_traits< gko::experimental::solver::Direct< ValueType, IndexType > >
C gko::solver::workspace_traits< Gmres< ValueType > >
C gko::solver::workspace_traits< Idr< ValueType > >
C gko::solver::workspace_traits< Ir< ValueType > >
C gko::solver::workspace_traits< LowerTrs< ValueType, IndexType > >
C gko::solver::workspace_traits< Minres< ValueType > >
C gko::solver::workspace_traits< Multigrid >
C gko::solver::workspace_traits< PipeCg< ValueType > >
C gko::solver::workspace_traits< UpperTrs< ValueType, IndexType > >
C gko::WritableToMatrixData< ValueType, IndexType > A LinOp implementing this interface can write its data to a matrix_data structure
C gko::matrix::Coo< ValueType, IndexType >
C gko::matrix::Csr< value_type, index_type >
C gko::matrix::Csr< ValueType, IndexType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< ValueType >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< value_type >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< to_complex< ValueType > >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< absolute_type >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Dense< remove_complex< ValueType > >
C gko::matrix::Diagonal< ValueType >
C gko::matrix::Diagonal< ValueType >
C gko::matrix::Ell< value_type, index_type >
C gko::matrix::Ell< ValueType, IndexType >
C gko::matrix::Fbcsr< ValueType, IndexType >
C gko::matrix::Permutation< index_type >
C gko::matrix::Permutation< IndexType >
C gko::matrix::SparsityCsr< value_type, index_type >
C gko::matrix::SparsityCsr< IndexType, ValueType >
C gko::matrix::SparsityCsr< ValueType, IndexType >
C gko::preconditioner::Jacobi< ValueType, IndexType >
C gko::WritableToMatrixData< default_precision, int32 >
C gko::matrix::Coo< ValueType, IndexType > COO stores a matrix in the coordinate matrix format
C gko::matrix::Csr< ValueType, IndexType > CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matrix (compressed sparse row format)
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::matrix::Diagonal< ValueType > This class is a utility which efficiently implements the diagonal matrix (a linear operator which scales a vector row wise)
C gko::matrix::Ell< ValueType, IndexType > ELL is a matrix format where stride with explicit zeros is used such that all rows have the same number of stored elements
C gko::matrix::Fbcsr< ValueType, IndexType > Fixed-block compressed sparse row storage matrix format
C gko::matrix::Hybrid< ValueType, IndexType > HYBRID is a matrix format which splits the matrix into ELLPACK and COO format
C gko::matrix::Permutation< IndexType > Permutation is a matrix format that represents a permutation matrix, i.e
C gko::matrix::ScaledPermutation< ValueType, IndexType > ScaledPermutation is a matrix combining a permutation with scaling factors
C gko::matrix::Sellp< ValueType, IndexType > SELL-P is a matrix format similar to ELL format
C gko::matrix::SparsityCsr< ValueType, IndexType > 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)
C gko::preconditioner::Jacobi< ValueType, IndexType > A block-Jacobi preconditioner is a block-diagonal linear operator, obtained by inverting the diagonal blocks of the source operator
C gko::WritableToMatrixData< default_precision, int64 >
C gko::matrix::Dense< ValueType > Dense is a matrix format which explicitly stores all values of the matrix
C gko::matrix::Diagonal< ValueType > This class is a utility which efficiently implements the diagonal matrix (a linear operator which scales a vector row wise)
C gko::WritableToMatrixData< std::complex< double >, int32 >
C gko::matrix::Fft This LinOp implements a 1D Fourier matrix using the FFT algorithm
C gko::matrix::Fft2 This LinOp implements a 2D Fourier matrix using the FFT algorithm
C gko::matrix::Fft3 This LinOp implements a 3D Fourier matrix using the FFT algorithm
C gko::WritableToMatrixData< std::complex< double >, int64 >
C gko::matrix::Fft This LinOp implements a 1D Fourier matrix using the FFT algorithm
C gko::matrix::Fft2 This LinOp implements a 2D Fourier matrix using the FFT algorithm
C gko::matrix::Fft3 This LinOp implements a 3D Fourier matrix using the FFT algorithm
C gko::WritableToMatrixData< std::complex< float >, int32 >
C gko::matrix::Fft This LinOp implements a 1D Fourier matrix using the FFT algorithm
C gko::matrix::Fft2 This LinOp implements a 2D Fourier matrix using the FFT algorithm
C gko::matrix::Fft3 This LinOp implements a 3D Fourier matrix using the FFT algorithm
C gko::WritableToMatrixData< std::complex< float >, int64 >
C gko::matrix::Fft This LinOp implements a 1D Fourier matrix using the FFT algorithm
C gko::matrix::Fft2 This LinOp implements a 2D Fourier matrix using the FFT algorithm
C gko::matrix::Fft3 This LinOp implements a 3D Fourier matrix using the FFT algorithm