|
Morpheus 1.0.0
Dynamic matrix type and algorithms for sparse matrices
|
| ►NMorpheus | Generic Morpheus interfaces |
| NCustom | Namespace for Custom Backend definitions |
| NGeneric | Namespace for Generic Backend definitions |
| CBinaryContainer | A wrapper that constructs a new container type that holds two container types |
| Cconcat< TypeList< Ts... >, TypeList< Us... > > | Concatenates types from two TypeList in a single TypeList |
| CContainerTraits | Traits class for accessing attributes of a Container (Matrix or Vector) |
| CCooFormatTag | Tag used to mark containers as Matrix containers (Sparse) with Coordinate (COO) Storage Format |
| CCooMatrix | Implementation of the Coordinate (COO) Sparse Matrix Format Representation |
| Ccross_product< TypeList< Ts... >, TypeList< Us... > > | Generates the cross product of the types from two TypeList |
| CCsrFormatTag | Tag used to mark containers as Matrix containers (Sparse) with Compressed Sparse Row (CSR) Storage Format |
| CCsrMatrix | Implementation of the Compressed-Sparse Row (CSR) Sparse Matrix Format Representation |
| CCustomBackend | A wrapper that converts a valid space into a custom backend |
| CDefault | A Default tag is used to denote the use of default types |
| CDenseMatrix | 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 |
| CDenseMatrixFormatTag | Tag used to mark containers as Matrix containers (Dense) with Dense Format |
| CDenseVector | 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 |
| CDenseVectorFormatTag | Tag used to mark containers as Vector Containers (Dense) with Dense Format |
| CDevice | A type that binds together the execution, memory space and backend |
| CDiaFormatTag | Tag used to mark containers as Matrix containers (Sparse) with Diagonal (DIA) Storage Format |
| CDiaMatrix | Implementation of the Diagonal (DIA) Sparse Matrix Format Representation |
| CDynamicMatrix | Implementation of the Dynamic Sparse Matrix Format Representation |
| CDynamicMatrixFormatTag | Tag used to mark containers as Matrix container with Dynamic Storage Format |
| CException | |
| CFormatConversionException | |
| Cgenerate_binary_typelist | Generates a TypeList of all combinations of BinaryContainer from two TypeLists of containers |
| Cgenerate_unary_typelist | Generates a TypeList of UnaryContainer where each container type is generated from each combination of types in the U type list |
| CGenericBackend | A wrapper that converts a valid space into a generic backend |
| Chas_access | 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 |
| Chas_backend | Checks if the given type T has a valid supported backend |
| Chas_cuda_execution_space | Checks if the given type T has a Cuda execution space |
| Chas_custom_backend | Checks if the given type T has a valid custom backend i.e has a CustomBackend container |
| Chas_execution_space | Checks if the given type T has a valid supported execution space |
| Chas_generic_backend | 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 |
| Chas_hip_execution_space | Checks if the given type T has a HIP execution space |
| Chas_host_execution_space | Checks if the given type T has a supported Host execution space |
| Chas_host_memory_space | Checks if the given type T has a valid supported Host memory space |
| Chas_index_type | Checks if the given type T has a valid index type i.e an integral |
| Chas_layout | 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 |
| Chas_memory_space | Checks if the given type T has a valid supported memory space |
| Chas_openmp_execution_space | Checks if the given type T has an OpenMP execution space |
| Chas_same_format | Checks if the two types have the same format i.e both are valid containers and have the same tag member trait |
| Chas_same_index_type | Checks if the two types have the same valid index type |
| Chas_same_layout | Checks if the two types have the same valid supported layout |
| Chas_same_memory_space | Checks if the two types have the same valid supported memory space |
| Chas_same_value_type | Checks if the two types have the same valid value type |
| Chas_serial_execution_space | Checks if the given type T has a Serial execution space |
| Chas_tag_trait | Checks if T has tag as a member trait |
| Chas_value_type | Checks if the given type T has a valid value type i.e a scalar |
| CHostMirror | Given a space S, the HostMirror will generate the appropriate Host backend |
| CIndexedTypeList | Compile-time type list with indexed access |
| CIndexType | A wrapper that checks if the provided type is an integral type |
| CInitArguments | |
| CInvalidInputException | |
| CIOException | |
| Cis_compatible | 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 |
| Cis_container | 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 |
| Cis_coo_matrix_format_container | 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 |
| Cis_csr_matrix_format_container | 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 |
| Cis_cuda_execution_space | Checks if the given type T is a Cuda execution space |
| Cis_default | Checks if the given type T is a Default type |
| Cis_dense_matrix_container | A valid Dense Matrix container is the one that has a valid Dense Matrix tag i.e satisfies the has_dense_matrix_tag check |
| Cis_dense_matrix_format_container | 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 |
| Cis_dense_vector_format_container | 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 |
| Cis_dia_matrix_format_container | 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 |
| Cis_dynamic_matrix_container | 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 |
| Cis_dynamic_matrix_format_container | 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 |
| Cis_dynamically_compatible | 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 |
| Cis_execution_space | Checks if the given type T is a valid supported execution space |
| Cis_format_compatible | Checks if the two types are format compatible containers i.e are compatible containers and have the same storage format |
| Cis_format_compatible_different_space | 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 |
| Cis_generic_backend | 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 |
| Cis_hip_execution_space | Checks if the given type T is a HIP execution space |
| Cis_host_execution_space | Checks if the given type T is a supported Host execution space |
| Cis_host_memory_space | Checks if the given type T is a valid supported Host memory space |
| Cis_index_type | Checks if the given type T is a valid index type i.e an integral |
| Cis_layout | 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 |
| Cis_matrix_container | 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 |
| Cis_memory_space | Checks if the given type T is a valid supported memory space |
| Cis_openmp_execution_space | Checks if the given type T is an OpenMP execution space |
| Cis_same_index_type | Checks if the two types is of type index_type and are the same |
| Cis_same_layout | Checks if the two types have the same valid supported layout |
| Cis_same_memory_space | Checks if the two types are in the same valid supported memory space |
| Cis_same_value_type | Checks if the two types are of type value_type and the same |
| Cis_serial_execution_space | Checks if the given type T is a Serial execution space |
| Cis_space | Checks if the given type T is a valid supported space |
| Cis_sparse_matrix_container | 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 |
| Cis_value_type | Checks if the given type T is a valid value type i.e a scalar |
| Cis_variant_member | Checks if the given type T is a member of Variant container such as std::variant or mpark::variant |
| Cis_vector_container | 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 |
| CMatrixBase | Base class used to derive new matrices |
| CMatrixFormats | |
| CMatrixFormatTag | |
| CNotImplementedException | |
| Cremove_cvref | Provides the member type which is the same as T, except that its topmost const- and reference-qualifiers are removed |
| CRuntimeException | |
| CSet | Compile-time set |
| CTypeList | Compile-time type list |
| CTypeList< Set< Head_... >, Tail_... > | Compile-time linked-list like type list specialisation for when the types passed are Set |
| CUnaryContainer | A wrapper that constructs a new container type from ContainerType using as arguments the types in TypeSet |
| CValueType | A wrapper that checks if the provided type is a scalar type |
| CVectorFormatTag |
1.9.5