This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 123]

CMorpheus::Impl::activate_impl< I, ValueType, Properties >
CMorpheus::Impl::activate_impl< 0, ValueType, Properties... >
CMorpheus::Impl::any_type_allocate
CMorpheus::Impl::any_type_assign
CMorpheus::Impl::any_type_resize_from_mat
CMorpheus::BinaryContainer< ContainerType1, ContainerType2 >	A wrapper that constructs a new container type that holds two container types
CMorpheus::concat< TypeList< Ts... >, TypeList< Us... > >	Concatenates types from two `TypeList` in a single `TypeList`
►CMorpheus::ContainerTraits< Container, ValueType, Properties >	Traits class for accessing attributes of a Container (Matrix or Vector)
CMorpheus::DenseVector< index_type, size_type, array_layout, backend, memory_traits >
CMorpheus::DenseVector< value_type, size_type, array_layout, backend, memory_traits >
►CMorpheus::MatrixBase< CooMatrix, ValueType, Properties... >
CMorpheus::CooMatrix< ValueType, Properties >	Implementation of the Coordinate (COO) Sparse Matrix Format Representation
►CMorpheus::MatrixBase< CsrMatrix, ValueType, Properties... >
CMorpheus::CsrMatrix< ValueType, Properties >	Implementation of the Compressed-Sparse Row (CSR) Sparse Matrix Format Representation
►CMorpheus::MatrixBase< DenseMatrix, ValueType, Properties... >
CMorpheus::DenseMatrix< ValueType, Properties >	The DenseMatrix container is a two-dimensional dense container that contains contiguous elements. It is a polymorphic container in the sense that it can store scalar or integer type values, on host or device depending how the template parameters are selected
►CMorpheus::MatrixBase< DiaMatrix, ValueType, Properties... >
CMorpheus::DiaMatrix< ValueType, Properties >	Implementation of the Diagonal (DIA) Sparse Matrix Format Representation
►CMorpheus::MatrixBase< DynamicMatrix, ValueType, Properties... >
CMorpheus::DynamicMatrix< ValueType, Properties >	Implementation of the Dynamic Sparse Matrix Format Representation
CMorpheus::MatrixBase< DenseMatrix, value_type, Properties... >
CMorpheus::Impl::ContainerTraits< ValueType, Properties >
►CMorpheus::ContainerTraits< any_type_resize, ValueType, Properties... >
CMorpheus::Impl::any_type_resize< ValueType, Properties >
►CMorpheus::ContainerTraits< Container, ValueType, Properties... >
►CMorpheus::MatrixBase< Container, ValueType, Properties >	Base class used to derive new matrices
CMorpheus::DenseMatrix< value_type, size_type, array_layout, backend, memory_traits >
CMorpheus::ContainerTraits< CooMatrix, ValueType, Properties... >
CMorpheus::ContainerTraits< CsrMatrix, ValueType, Properties... >
CMorpheus::ContainerTraits< DenseMatrix, value_type, Properties... >
CMorpheus::ContainerTraits< DenseMatrix, ValueType, Properties... >
CMorpheus::ContainerTraits< DenseVector, index_type, Properties... >
CMorpheus::ContainerTraits< DenseVector, value_type, Properties... >
►CMorpheus::ContainerTraits< DenseVector, ValueType, Properties... >
CMorpheus::DenseVector< ValueType, Properties >	The DenseVector container is a one-dimensional container that contains contiguous elements. It is a polymorphic container in the sense that it can store scalar or integer type values, on host or device depending how the template parameters are selected
CMorpheus::ContainerTraits< DiaMatrix, ValueType, Properties... >
CMorpheus::ContainerTraits< DynamicMatrix, ValueType, Properties... >
CMorpheus::Impl::ContainerTraits< typename std::enable_if< Kokkos::is_memory_traits< MemoryTraits >::value >::type, MemoryTraits, Prop... >
CMorpheus::Impl::ContainerTraits< typename std::enable_if< Morpheus::is_space< Space >::value >::type, Space, Prop... >
CMorpheus::Impl::ContainerTraits< typename std::enable_if_t< Morpheus::is_layout< ArrayLayout >::value >, ArrayLayout, Prop... >
CMorpheus::Impl::ContainerTraits< typename std::enable_if_t< std::is_integral< IndexType >::value >, IndexType, Prop... >
CMorpheus::Impl::ContainerTraits< void >
CMorpheus::Impl::ContainerTraits< void, void, Prop... >
CMorpheus::Impl::convert_fn< ExecSpace >
CMorpheus::Impl::copy_fn
CMorpheus::cross_product< TypeList< Ts... >, TypeList< Us... > >	Generates the cross product of the types from two `TypeList`
►CMorpheus::Impl::CudaWorkspace
CMorpheus::Impl::CublasWorkspace
CMorpheus::CustomBackend< Space >	A wrapper that converts a valid space into a custom backend
CMorpheus::Default	A `Default` tag is used to denote the use of default types
CMorpheus::Device< ExecutionSpace, MemorySpace, BackendSpace >	A type that binds together the execution, memory space and backend
►Cstd::exception
►CMorpheus::Exception
CMorpheus::FormatConversionException
CMorpheus::IOException
CMorpheus::InvalidInputException
CMorpheus::NotImplementedException
CMorpheus::RuntimeException
CMorpheus::generate_binary_typelist< List1, List2 >	Generates a `TypeList` of all combinations of `BinaryContainer` from two TypeLists of containers
CMorpheus::generate_unary_typelist< Container, U >	Generates a `TypeList` of `UnaryContainer` where each container type is generated from each combination of types in the `U` type list
CMorpheus::GenericBackend< Space >	A wrapper that converts a valid space into a generic backend
CMorpheus::has_access< ExecSpace, Ts >	Takes arbitrary number of containers and checks if `ExecSpace` has access to the memory space of all of them. Note that each container must have a valid `memory_space` trait
CMorpheus::has_backend< T >	Checks if the given type `T` has a valid supported backend
CMorpheus::has_cuda_execution_space< T >	Checks if the given type `T` has a Cuda execution space
CMorpheus::has_custom_backend< T >	Checks if the given type `T` has a valid custom backend i.e has a `CustomBackend` container
CMorpheus::Impl::has_dense_matrix_tag< T >	Checks if the given type `T` has a valid Dense Matrix Tag i.e has a `tag` member trait that is a derived class of `DenseMatrixTag`
CMorpheus::Impl::has_dense_vector_tag< T >	Checks if the given type `T` has a valid Dense Vector Tag i.e has a `tag` member trait that is a derived class of `DenseVectorTag`
CMorpheus::Impl::has_dynamic_matrix_tag< T >	Checks if the given type `T` has a valid Dynamic Matrix Tag i.e has a `tag` member trait that is a derived class of `DynamicMatrixTag`
CMorpheus::has_execution_space< T >	Checks if the given type `T` has a valid supported execution space
CMorpheus::has_generic_backend< T >	Checks if the given type `T` has a valid generic backend i.e has a `GenericBackend` container. A valid generic backend is also assumed to be any valid Kokkos Execution Space, Memory Space or Device
CMorpheus::has_hip_execution_space< T >	Checks if the given type `T` has a HIP execution space
CMorpheus::has_host_execution_space< T >	Checks if the given type `T` has a supported Host execution space
CMorpheus::has_host_memory_space< T >	Checks if the given type `T` has a valid supported Host memory space
CMorpheus::has_index_type< T >	Checks if the given type `T` has a valid index type i.e an integral
CMorpheus::has_layout< T >	Checks if the given type `T` has a layout i.e has as a `array_layout` member trait it self and is one of the supported layouts
CMorpheus::Impl::has_matrix_tag< T >	Checks if the given type `T` has a tag trait of type `MatrixTag`
CMorpheus::has_memory_space< T >	Checks if the given type `T` has a valid supported memory space
CMorpheus::has_openmp_execution_space< T >	Checks if the given type `T` has an OpenMP execution space
CMorpheus::has_same_format< T1, T2 >	Checks if the two types have the same format i.e both are valid containers and have the same `tag` member trait
CMorpheus::has_same_index_type< T1, T2 >	Checks if the two types have the same valid index type
CMorpheus::has_same_layout< T1, T2 >	Checks if the two types have the same valid supported layout
CMorpheus::has_same_memory_space< T1, T2 >	Checks if the two types have the same valid supported memory space
CMorpheus::has_same_value_type< T1, T2 >	Checks if the two types have the same valid value type
CMorpheus::has_serial_execution_space< T >	Checks if the given type `T` has a Serial execution space
CMorpheus::Impl::has_sparse_matrix_tag< T >	Checks if the given type `T` has a valid Sparse Matrix Tag i.e has a `tag` member trait that is a derived class of `SparseMatrixTag`
CMorpheus::Impl::has_sparse_vector_tag< T >	Checks if the given type `T` has a valid Sparse Vector Tag i.e has a `tag` member trait that is a derived class of `SparseVectorTag`
CMorpheus::has_tag_trait< T >	Checks if `T` has `tag` as a member trait
CMorpheus::has_value_type< T >	Checks if the given type `T` has a valid value type i.e a scalar
CMorpheus::Impl::has_vector_tag< T >	Checks if the given type `T` has a valid Vector Tag i.e has a `tag` member trait that is a derived class of `VectorTag`
►CMorpheus::Impl::HIPWorkspace
CMorpheus::Impl::HIPblasWorkspace
CMorpheus::HostMirror< S >	Given a space S, the HostMirror will generate the appropriate Host backend
CMorpheus::IndexedTypeList< Ts >	Compile-time type list with indexed access
CMorpheus::IndexType< T >	A wrapper that checks if the provided type is an integral type
►CKokkos::InitArguments
CMorpheus::InitArguments
►Cstd::integral_constant
CMorpheus::is_format_compatible< T1, T2 >	Checks if the two types are format compatible containers i.e are compatible containers and have the same storage format
CMorpheus::is_compatible< T1, T2 >	Checks if the two types are compatible containers i.e are in the same memory space and have the same layout, index and value type
CMorpheus::is_container< T >	Checks if the given type `T` is a valid Morpheus Container i.e is either a valid matrix or a vector container that satisfies `is_matrix_container` or `is_vector_container`
CMorpheus::is_coo_matrix_format_container< T >	Checks if the given type `T` is a valid COO Sparse Matrix Format Container i.e is valid matrix container and has `CooFormatTag` as `tag` member trait
CMorpheus::is_csr_matrix_format_container< T >	Checks if the given type `T` is a valid CSR Sparse Matrix Format Container i.e is valid matrix container and has `CsrFormatTag` as `tag` member trait
CMorpheus::is_cuda_execution_space< T >	Checks if the given type `T` is a Cuda execution space
CMorpheus::is_default< T >	Checks if the given type `T` is a `Default` type
CMorpheus::is_dense_matrix_container< T >	A valid Dense Matrix container is the one that has a valid Dense Matrix tag i.e satisfies the `has_dense_matrix_tag` check
CMorpheus::is_dense_matrix_format_container< T >	Checks if the given type `T` is a valid Dense Matrix Format Container i.e is valid matrix container and has `DenseMatrixFormatTag` as `tag` member trait
CMorpheus::Impl::is_dense_matrix_tag< T >	Checks if the given type `T` is a valid Dense Matrix Container i.e it is a derived class of `DenseMatrixTag`
CMorpheus::is_dense_vector_format_container< T >	Checks if the given type `T` is a valid Dense Vector Format Container i.e is valid vector container and has `DenseVectorFormatTag` as `tag` member trait
CMorpheus::Impl::is_dense_vector_tag< T >	Checks if the given type `T` is a valid Dense Vector Tag i.e it is a derived class of `DenseVectorTag`
CMorpheus::is_dia_matrix_format_container< T >	Checks if the given type `T` is a valid DIA Sparse Matrix Format Container i.e is valid matrix container and has `DiaFormatTag` as `tag` member trait
CMorpheus::is_dynamic_matrix_container< T >	A valid Dynamic Matrix container is the one that has a valid Dynamic Matrix tag i.e satisfies the `has_dynamic_matrix_tag` check. Note that any supported dynamic matrix storage format should be a valid Dynamic Matrix Container
CMorpheus::is_dynamic_matrix_format_container< T >	Checks if the given type `T` is a valid Dynamic Matrix Format Container i.e is valid matrix container and has `DynamicMatrixFormatTag` as `tag` member trait
CMorpheus::Impl::is_dynamic_matrix_tag< T >	Checks if the given type `T` is a valid Dynamic Matrix Container i.e it is a derived class of `DynamicMatrixTag`
CMorpheus::is_dynamically_compatible< T1, T2 >	Checks if the two types are dynamically compatible containers i.e are compatible containers and at least one of them is also a dynamic container
CMorpheus::is_execution_space< T >	Checks if the given type `T` is a valid supported execution space
CMorpheus::is_format_compatible_different_space< T1, T2 >	Checks if the two types are format compatible containers but from different memory space i.e have the same storage format and are compatible containers with relaxed memory space and layout requirements
CMorpheus::is_generic_backend< T >	Checks if the given type `T` is a valid generic backend i.e is a `GenericBackend` container. A valid generic backend is also assumed to be any valid Kokkos Execution Space, Memory Space or Device
CMorpheus::is_hip_execution_space< T >	Checks if the given type `T` is a HIP execution space
CMorpheus::is_host_execution_space< T >	Checks if the given type `T` is a supported Host execution space
CMorpheus::is_host_memory_space< T >	Checks if the given type `T` is a valid supported Host memory space
CMorpheus::is_index_type< T >	Checks if the given type `T` is a valid index type i.e an integral
CMorpheus::is_layout< T >	Checks if the given type `T` is a layout i.e has as a `array_layout` member trait it self and is one of the supported layouts
CMorpheus::is_matrix_container< T >	A valid Matrix container is the one that has a valid Matrix tag i.e satisfies the `has_matrix_tag` check. Note that both dense and sparse matrices should be valid matrix containers
CMorpheus::Impl::is_matrix_tag< T >	Checks if the given type `T` is a valid Matrix Tag i.e is a derived class of `MatrixTag`
CMorpheus::is_memory_space< T >	Checks if the given type `T` is a valid supported memory space
CMorpheus::is_openmp_execution_space< T >	Checks if the given type `T` is an OpenMP execution space
CMorpheus::is_same_index_type< T1, T2 >	Checks if the two types is of type index_type and are the same
CMorpheus::is_same_layout< T1, T2 >	Checks if the two types have the same valid supported layout
CMorpheus::is_same_memory_space< T1, T2 >	Checks if the two types are in the same valid supported memory space
CMorpheus::is_same_value_type< T1, T2 >	Checks if the two types are of type value_type and the same
CMorpheus::is_serial_execution_space< T >	Checks if the given type `T` is a Serial execution space
CMorpheus::is_space< T >	Checks if the given type `T` is a valid supported space
CMorpheus::is_sparse_matrix_container< T >	A valid Sparse Matrix container is the one that has a valid Sparse Matrix tag i.e satisfies the `has_sparse_matrix_tag` check. Note that any supported sparse matrix storage format should be a valid Sparse Matrix Container
CMorpheus::Impl::is_sparse_matrix_tag< T >	Checks if the given type `T` is a valid Sparse Matrix Tag i.e is a derived class of `SparseMatrixTag`
CMorpheus::Impl::is_sparse_vector_tag< T >	Checks if the given type `T` is a valid Sparse Vector Tag i.e it is a derived class of `SparseVectorTag`
CMorpheus::is_value_type< T >	Checks if the given type `T` is a valid value type i.e a scalar
CMorpheus::is_variant_member< T, Variant >	Checks if the given type `T` is a member of `Variant` container such as `std::variant` or `mpark::variant`
CMorpheus::is_vector_container< T >	A valid Vector container is the one that has a valid Vector tag i.e satisfies the `has_vector_tag` check. Note that a Vector container could be either dense or sparse
CMorpheus::Impl::is_vector_tag< T >	Checks if the given type `T` is a valid Vector Tag i.e it is a derived class of `VectorTag`
CMorpheus::IO::Impl::matrix_market_banner
CMorpheus::Impl::MatrixBase< Container, ValueType, Properties >
CMorpheus::MatrixFormats< ValueType, Properties >
CMorpheus::MatrixFormats< ValueType, Properties... >
CMorpheus::Impl::MatrixFormatsProxy< Formats >
CMorpheus::MatrixFormatTag< T >
►CMorpheus::Impl::MatrixTag	Tag used to mark containers as Matrices
►CMorpheus::Impl::DenseMatrixTag	Tag used to mark containers as Dense Matrices
CMorpheus::DenseMatrixFormatTag	Tag used to mark containers as Matrix containers (Dense) with Dense Format
►CMorpheus::Impl::DynamicMatrixTag	Tag used to mark containers as Dynamic Matrices
CMorpheus::DynamicMatrixFormatTag	Tag used to mark containers as Matrix container with Dynamic Storage Format
►CMorpheus::Impl::SparseMatrixTag	Tag used to mark containers as Sparse Matrices
CMorpheus::CooFormatTag	Tag used to mark containers as Matrix containers (Sparse) with Coordinate (COO) Storage Format
CMorpheus::CsrFormatTag	Tag used to mark containers as Matrix containers (Sparse) with Compressed Sparse Row (CSR) Storage Format
CMorpheus::DiaFormatTag	Tag used to mark containers as Matrix containers (Sparse) with Diagonal (DIA) Storage Format
CMorpheus::Impl::MirrorContainerType< Space, Container, T, P >
CMorpheus::Impl::MirrorType< Space, Container, T, P >
CMorpheus::remove_cvref< T >	Provides the member type which is the same as T, except that its topmost const- and reference-qualifiers are removed
CMorpheus::Set< Ts >	Compile-time set
CMorpheus::Impl::set_functor< View, Types >
CMorpheus::Impl::set_functor< View, ValueType >
CMorpheus::Impl::set_functor< View, ValueType, IndexType >
CMorpheus::Impl::Kernels::SharedMemory< T >
CMorpheus::Impl::Kernels::SharedMemory< double >
CMorpheus::TypeList< Ts >	Compile-time type list
CMorpheus::TypeList< Set< Head_... >, Tail_... >	Compile-time linked-list like type list specialisation for when the types passed are `Set`
CMorpheus::UnaryContainer< ContainerType, TypeSet >	A wrapper that constructs a new container type from `ContainerType` using as arguments the types in `TypeSet`
CMorpheus::ValueType< T >	A wrapper that checks if the provided type is a scalar type
CMorpheus::VectorFormatTag< T >
►CMorpheus::Impl::VectorTag	Tag used to mark containers as Vectors
►CMorpheus::Impl::DenseVectorTag	Tag used to mark containers as Dense Vectors
CMorpheus::DenseVectorFormatTag	Tag used to mark containers as Vector Containers (Dense) with Dense Format
CMorpheus::Impl::SparseVectorTag	Tag used to mark containers as Sparse Vectors