| CAlgorithms::Segments::isCSRSegments::type | |
| CTNL::Matrices::isSparseCSRMatrix< SparseMatrix< Real, Device, Index, MatrixType, Segments, ComputeReal, RealAllocator, IndexAllocator > > | |
| CTNL::Matrices::isSparseCSRMatrix< SparseMatrixView< Real, Device, Index, MatrixType, SegmentsView, ComputeReal > > | |
| CConfigValidator | |
| CTNL::Meshes::Mesh< MeshConfig, Device > | |
| CTNL::Meshes::Mesh< MeshConfig, Device > | |
| CEntityTags::LayerFamily | |
| CTNL::Meshes::Mesh< MeshConfig, Device > | |
| CTNL::Meshes::Mesh< MeshConfig, Device > | |
| Cgko::EnableCreateMethod | |
| CTNL::Matrices::GinkgoOperator< Matrix > | Wraps a general TNL matrix as a Ginkgo LinOp |
| Cgko::EnableLinOp | |
| CTNL::Matrices::GinkgoOperator< Matrix > | Wraps a general TNL matrix as a Ginkgo LinOp |
| Cgko::log::Convergence | |
| CTNL::Solvers::GinkgoConvergenceLoggerMonitor< ValueType, IndexType > | A Ginkgo Convergence logger with a TNL iterative solver monitor |
| Cgko::matrix::Dense | |
| CTNL::Containers::GinkgoVector< Value, Device > | Wrapper for representing vectors using Ginkgo data structure |
| CIndexer | |
| CTNL::Containers::NDArrayStorage< Array, Indexer, Permutation, Device > | Base storage class for NDArray and StaticNDArray |
| CTNL::Containers::NDArray< Real, TNL::Containers::SizesHolder< Index, 0, 0, 0 >, xyz_permutation, Device, Index, xyz_overlaps > | |
| CTNL::Containers::NDArray< Real, TNL::Containers::SizesHolder< Index, 0, 0, 0, 0 >, txyz_permutation, Device, Index, txyz_overlaps > | |
| CTNL::Containers::NDArray< typename DistributedNDArray::ValueType, typename DistributedNDArray::SizesHolderType, typename DistributedNDArray::PermutationType, typename DistributedNDArray::DeviceType > | |
| CTNL::Containers::NDArrayView< Value, Device, Indexer, Permutation > | Simple data structure which provides a non-owning encapsulation of N-dimensional array data |
| CIndexerType | |
| CTNL::Containers::NDArrayView< ValueType, DeviceType, IndexerType, PermutationType > | |
| CTNL::Containers::NDArrayView< std::add_const_t< ValueType >, DeviceType, IndexerType, PermutationType > | |
| CParentConfig | |
| CTNL::Meshes::TetrahedronConfig< ParentConfig > | |
| CTNL::Meshes::TriangleConfig< ParentConfig > | |
| CSegments | |
| CTNL::Algorithms::Segments::GrowingSegments< Segments > | |
| Cstd::atomic< T > [external] | STL class |
| CTNL::Atomic< T, Devices::Host > | Atomic wrapper for the host device |
| CTNL::Atomic< T, Devices::Sequential > | Atomic wrapper for the sequential device |
| Cstd::basic_string< Char > [external] | STL class |
| Cstd::string [external] | STL class |
| CTNL::String | Class for managing strings |
| Cstd::bit_and< void > [external] | |
| CTNL::BitAnd | Extension of std::bit_and<void> for use with TNL::Algorithms::reduce |
| Cstd::bit_or< void > [external] | |
| CTNL::BitOr | Extension of std::bit_or<void> for use with TNL::Algorithms::reduce |
| Cstd::bit_xor< void > [external] | |
| CTNL::BitXor | Extension of std::bit_xor<void> for use with TNL::Algorithms::reduce |
| Cstd::conjunction | |
| CTNL::IsArrayType< T > | Type trait for checking if T is an array type, e.g. Containers::Array or Containers::Vector |
| Cstd::exception [external] | STL class |
| Cstd::bad_alloc [external] | STL class |
| CTNL::Exceptions::BackendBadAlloc | |
| Cstd::runtime_error [external] | STL class |
| CTNL::Exceptions::BackendRuntimeError | |
| CTNL::Exceptions::BackendSupportMissing | |
| CTNL::Exceptions::ConfigError | |
| CTNL::Exceptions::FileDeserializationError | |
| CTNL::Exceptions::FileSerializationError | |
| CTNL::Exceptions::MPISupportMissing | |
| CTNL::Exceptions::NotImplementedError | |
| CTNL::Meshes::MeshBuilderError | |
| CTNL::Meshes::Readers::MeshReaderError | |
| Cstd::false_type [external] | |
| CTNL::Algorithms::Segments::isAdaptiveCSRSegments< AdaptiveCSR< Device, Index, IndexAllocator > > | |
| CTNL::Algorithms::Segments::isAdaptiveCSRSegments< AdaptiveCSRView< Device, Index > > | |
| CTNL::Algorithms::Segments::isBiEllpackSegments< BiEllpack< Device, Index, IndexAllocator, Organization, WarpSize_ > > | |
| CTNL::Algorithms::Segments::isBiEllpackSegments< BiEllpackView< Device, Index, Organization, WarpSize_ > > | |
| CTNL::Algorithms::Segments::isCSRSegments< CSR< Device, Index, IndexAllocator > > | |
| CTNL::Algorithms::Segments::isCSRSegments< CSRView< Device, Index > > | |
| CTNL::Algorithms::Segments::isChunkedEllpackSegments< ChunkedEllpack< Device, Index, IndexAllocator, Organization > > | |
| CTNL::Algorithms::Segments::isChunkedEllpackSegments< ChunkedEllpackView< Device, Index, Organization > > | |
| CTNL::Algorithms::Segments::isEllpackSegments< Ellpack< Device, Index, IndexAllocator, Organization, Alignment > > | |
| CTNL::Algorithms::Segments::isEllpackSegments< EllpackView< Device, Index, Organization, Alignment > > | |
| CTNL::Algorithms::Segments::isSlicedEllpackSegments< SlicedEllpack< Device, Index, IndexAllocator, Organization, SliceSize > > | |
| CTNL::Algorithms::Segments::isSlicedEllpackSegments< SlicedEllpackView< Device, Index, Organization, SliceSize > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedAdaptiveCSR< Device, Index, IndexAllocator > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedAdaptiveCSRView< Device, Index > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedBiEllpack< Device, Index, IndexAllocator, Organization, WarpSize_ > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedBiEllpackView< Device, Index, Organization, WarpSize_ > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedCSRView< Device, Index > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedChunkedEllpack< Device, Index, IndexAllocator, Organization > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedChunkedEllpackView< Device, Index, Organization > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedEllpack< Device, Index, IndexAllocator, Organization, Alignment > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedEllpackView< Device, Index, Organization, Alignment > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedSegments< CSR< Device, Index, IndexAllocator > > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedSegments< EmbeddedSegments > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedSegmentsView< EmbeddedSegments > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedSlicedEllpack< Device, Index, IndexAllocator, Organization, SliceSize > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedSlicedEllpackView< Device, Index, Organization, SliceSize > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< BiEllpackKernel< Index, Device > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< CSRAdaptiveKernel< Index, Device > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< CSRAdaptiveKernelView< Index, Device > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< CSRHybridKernel< Index, Device > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< CSRLightKernel< Index, Device > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< CSRScalarKernel< Index, Device > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< CSRVectorKernel< Index, Device > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< ChunkedEllpackKernel< Index, Device > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< EllpackKernel< Index, Device > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< SlicedEllpackKernel< Index, Device > > | |
| CTNL::Containers::Expressions::HasEnabledDistributedExpressionTemplates< DistributedBinaryExpressionTemplate< T1, T2, Operation, T1Type, T2Type > > | |
| CTNL::Containers::Expressions::HasEnabledDistributedExpressionTemplates< DistributedUnaryExpressionTemplate< T1, Operation > > | |
| CTNL::Containers::Expressions::HasEnabledDistributedExpressionTemplates< DistributedVector< Real, Device, Index, Allocator > > | |
| CTNL::Containers::Expressions::HasEnabledDistributedExpressionTemplates< DistributedVectorView< Real, Device, Index > > | |
| CTNL::Containers::Expressions::HasEnabledExpressionTemplates< BinaryExpressionTemplate< T1, T2, Operation, T1Type, T2Type > > | |
| CTNL::Containers::Expressions::HasEnabledExpressionTemplates< UnaryExpressionTemplate< T1, Operation > > | |
| CTNL::Containers::Expressions::HasEnabledExpressionTemplates< Vector< Real, Device, Index, Allocator > > | |
| CTNL::Containers::Expressions::HasEnabledExpressionTemplates< VectorView< Real, Device, Index > > | |
| CTNL::Containers::Expressions::HasEnabledStaticExpressionTemplates< StaticBinaryExpressionTemplate< T1, T2, Operation, T1Type, T2Type > > | |
| CTNL::Containers::Expressions::HasEnabledStaticExpressionTemplates< StaticUnaryExpressionTemplate< T1, Operation > > | |
| CTNL::Containers::Expressions::HasEnabledStaticExpressionTemplates< StaticVector< Size, Real > > | |
| CTNL::Matrices::isSparseCSRMatrix< SparseMatrix< Real, Device, Index, MatrixType, Segments, ComputeReal, RealAllocator, IndexAllocator > > | |
| CTNL::Matrices::isSparseCSRMatrix< SparseMatrixView< Real, Device, Index, MatrixType, SegmentsView, ComputeReal > > | |
| CTNL::Meshes::DistributedMeshes::HasMeshType< T, typename enable_if_type< typename T::MeshType >::type > | |
| CTNL::Meshes::isDistributedGrid< DistributedMeshes::DistributedMesh< Grid< Dimension, Real, Device, Index > > > | |
| CTNL::Meshes::isDistributedMesh< DistributedMeshes::DistributedMesh< Mesh< Config, Device > > > | |
| CTNL::Meshes::isGrid< Grid< Dimension, Real, Device, Index > > | |
| CTNL::Meshes::isMesh< Mesh< Config, Device > > | |
| CTNL::is_complex< Arithmetics::Complex< T > > | |
| CTNL::is_complex< const T > | |
| CTNL::is_complex< std::complex< T > > | |
| CTNL::is_complex< volatile T > | |
| CTNL::is_complex< volatile const T > | |
| CTNL::Algorithms::Segments::isAdaptiveCSRSegments< Segments > | |
| CTNL::Algorithms::Segments::isBiEllpackSegments< Segments > | |
| CTNL::Algorithms::Segments::isCSRSegments< Segments > | |
| CTNL::Algorithms::Segments::isChunkedEllpackSegments< Segments > | |
| CTNL::Algorithms::Segments::isEllpackSegments< Segments > | |
| CTNL::Algorithms::Segments::isSlicedEllpackSegments< Segments > | |
| CTNL::Algorithms::Segments::isSortedSegments< Segments > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< Kernel > | |
| CTNL::Containers::Expressions::HasEnabledDistributedExpressionTemplates< T > | |
| CTNL::Containers::Expressions::HasEnabledExpressionTemplates< T > | |
| CTNL::Containers::Expressions::HasEnabledStaticExpressionTemplates< T > | |
| CTNL::Containers::Expressions::IsArithmeticSubtype< T, T, false > | |
| CTNL::Containers::Expressions::IsArithmeticSubtype< T, T, true > | |
| CTNL::Matrices::isSparseCSRMatrix< Matrix > | This checks if the sparse matrix is in CSR format |
| CTNL::Meshes::DistributedMeshes::HasMeshType< T, Enable > | |
| CTNL::Meshes::Topologies::IsDynamicTopology< Vertex, 0 > | Specialization for Vertex Topology |
| CTNL::Meshes::isDistributedGrid< T > | |
| CTNL::Meshes::isDistributedMesh< T > | |
| CTNL::Meshes::isGrid< T > | |
| CTNL::Meshes::isMesh< T > | |
| CTNL::allocates_host_accessible_data< Allocators::Cuda< T > > | |
| CTNL::allocates_host_accessible_data< Allocators::Hip< T > > | |
| CTNL::is_complex< T > | |
| CTNL::is_complex< const T > | |
| CTNL::is_complex< volatile T > | |
| CTNL::is_complex< volatile const T > | |
| Cstd::integral_constant [external] | |
| CTNL::Containers::Expressions::IsArithmeticSubtype< T, T, false > | |
| CTNL::Containers::Expressions::IsArithmeticSubtype< T, T, true > | |
| Cstd::integral_constant< bool, compatibleForVectorAssignment< V::RealType, T >() > [external] | |
| CTNL::Containers::Expressions::IsArithmeticSubtype< T, V, false > | |
| CTNL::Containers::Expressions::IsArithmeticSubtype< T, V, enabled > | |
| Cstd::integral_constant< bool, HasConstexprGetSizeMethod< T >::value &&HasSubscriptOperator< T >::value > [external] | |
| CTNL::IsStaticArrayType< T > | Type trait for checking if T is a static array type |
| Cstd::integral_constant< bool, IsArrayType< T >::value &&HasAddAssignmentOperator< T >::value > [external] | |
| CTNL::IsVectorType< T > | Type trait for checking if T is a vector type, e.g. Containers::Vector or Containers::VectorView |
| Cstd::integral_constant< bool, std::is_arithmetic_v< T >||is_complex_v< T > > [external] | |
| CTNL::IsScalarType< T > | Type trait for checking if T is a scalar type (in the mathematical sense). Not to be confused with std::is_scalar |
| Cstd::integral_constant< std::size_t, N > [external] | |
| Cstd::tuple_size< TNL::Containers::StaticArray< N, T > > | |
| Cstd::tuple_size< TNL::Containers::StaticVector< N, T > > | |
| Cstd::is_arithmetic< T > [external] | |
| CTNL::Containers::Expressions::IsArithmeticSubtype< T, V, false > | |
| Cstd::logical_and< void > [external] | |
| CTNL::LogicalAnd | Function object implementing x && y |
| Cstd::logical_or< void > [external] | |
| CTNL::LogicalOr | Function object implementing x || y |
| Cstd::multiplies< void > [external] | |
| CTNL::Multiplies | Function object implementing x * y |
| Cstd::plus< void > [external] | |
| CTNL::Plus | Function object implementing x + y |
| Cstd::true_type [external] | |
| CTNL::allocates_host_accessible_data< Allocators::Cuda< T > > | |
| CTNL::allocates_host_accessible_data< Allocators::Hip< T > > | |
| CTNL::Algorithms::Segments::isAdaptiveCSRSegments< AdaptiveCSR< Device, Index, IndexAllocator > > | |
| CTNL::Algorithms::Segments::isAdaptiveCSRSegments< AdaptiveCSRView< Device, Index > > | |
| CTNL::Algorithms::Segments::isBiEllpackSegments< BiEllpack< Device, Index, IndexAllocator, Organization, WarpSize_ > > | |
| CTNL::Algorithms::Segments::isBiEllpackSegments< BiEllpackView< Device, Index, Organization, WarpSize_ > > | |
| CTNL::Algorithms::Segments::isCSRSegments< CSR< Device, Index, IndexAllocator > > | |
| CTNL::Algorithms::Segments::isCSRSegments< CSRView< Device, Index > > | |
| CTNL::Algorithms::Segments::isChunkedEllpackSegments< ChunkedEllpack< Device, Index, IndexAllocator, Organization > > | |
| CTNL::Algorithms::Segments::isChunkedEllpackSegments< ChunkedEllpackView< Device, Index, Organization > > | |
| CTNL::Algorithms::Segments::isEllpackSegments< Ellpack< Device, Index, IndexAllocator, Organization, Alignment > > | |
| CTNL::Algorithms::Segments::isEllpackSegments< EllpackView< Device, Index, Organization, Alignment > > | |
| CTNL::Algorithms::Segments::isSlicedEllpackSegments< SlicedEllpack< Device, Index, IndexAllocator, Organization, SliceSize > > | |
| CTNL::Algorithms::Segments::isSlicedEllpackSegments< SlicedEllpackView< Device, Index, Organization, SliceSize > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedAdaptiveCSR< Device, Index, IndexAllocator > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedAdaptiveCSRView< Device, Index > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedBiEllpack< Device, Index, IndexAllocator, Organization, WarpSize_ > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedBiEllpackView< Device, Index, Organization, WarpSize_ > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedCSRView< Device, Index > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedChunkedEllpack< Device, Index, IndexAllocator, Organization > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedChunkedEllpackView< Device, Index, Organization > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedEllpack< Device, Index, IndexAllocator, Organization, Alignment > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedEllpackView< Device, Index, Organization, Alignment > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedSegments< CSR< Device, Index, IndexAllocator > > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedSegments< EmbeddedSegments > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedSegmentsView< EmbeddedSegments > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedSlicedEllpack< Device, Index, IndexAllocator, Organization, SliceSize > > | |
| CTNL::Algorithms::Segments::isSortedSegments< SortedSlicedEllpackView< Device, Index, Organization, SliceSize > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< BiEllpackKernel< Index, Device > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< CSRAdaptiveKernel< Index, Device > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< CSRAdaptiveKernelView< Index, Device > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< CSRHybridKernel< Index, Device > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< CSRLightKernel< Index, Device > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< CSRScalarKernel< Index, Device > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< CSRVectorKernel< Index, Device > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< ChunkedEllpackKernel< Index, Device > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< EllpackKernel< Index, Device > > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentsReductionKernel< SlicedEllpackKernel< Index, Device > > | |
| CTNL::Containers::Expressions::HasEnabledDistributedExpressionTemplates< DistributedBinaryExpressionTemplate< T1, T2, Operation, T1Type, T2Type > > | |
| CTNL::Containers::Expressions::HasEnabledDistributedExpressionTemplates< DistributedUnaryExpressionTemplate< T1, Operation > > | |
| CTNL::Containers::Expressions::HasEnabledDistributedExpressionTemplates< DistributedVector< Real, Device, Index, Allocator > > | |
| CTNL::Containers::Expressions::HasEnabledDistributedExpressionTemplates< DistributedVectorView< Real, Device, Index > > | |
| CTNL::Containers::Expressions::HasEnabledExpressionTemplates< BinaryExpressionTemplate< T1, T2, Operation, T1Type, T2Type > > | |
| CTNL::Containers::Expressions::HasEnabledExpressionTemplates< UnaryExpressionTemplate< T1, Operation > > | |
| CTNL::Containers::Expressions::HasEnabledExpressionTemplates< Vector< Real, Device, Index, Allocator > > | |
| CTNL::Containers::Expressions::HasEnabledExpressionTemplates< VectorView< Real, Device, Index > > | |
| CTNL::Containers::Expressions::HasEnabledStaticExpressionTemplates< StaticBinaryExpressionTemplate< T1, T2, Operation, T1Type, T2Type > > | |
| CTNL::Containers::Expressions::HasEnabledStaticExpressionTemplates< StaticUnaryExpressionTemplate< T1, Operation > > | |
| CTNL::Containers::Expressions::HasEnabledStaticExpressionTemplates< StaticVector< Size, Real > > | |
| CTNL::Meshes::DistributedMeshes::HasMeshType< T, typename enable_if_type< typename T::MeshType >::type > | |
| CTNL::Meshes::isDistributedGrid< DistributedMeshes::DistributedMesh< Grid< Dimension, Real, Device, Index > > > | |
| CTNL::Meshes::isDistributedMesh< DistributedMeshes::DistributedMesh< Mesh< Config, Device > > > | |
| CTNL::Meshes::isGrid< Grid< Dimension, Real, Device, Index > > | |
| CTNL::Meshes::isMesh< Mesh< Config, Device > > | |
| CTNL::allocates_host_accessible_data< Allocator > | A trait-class that determines if an allocator allocates data that are directly accessible from the host code without the need for explicit copy operations |
| CTNL::is_complex< Arithmetics::Complex< T > > | |
| CTNL::is_complex< std::complex< T > > | |
| Cstd::tuple_element< I, TNL::Containers::StaticArray< N, T > > | |
| Cstd::tuple_element< I, TNL::Containers::StaticVector< N, T > > | |
| CStorageLayerFamily | |
| CTNL::Meshes::Mesh< MeshConfig, Device > | |
| CTNL::Meshes::Mesh< MeshConfig, Device > | |
| CTNL::Algorithms::AtomicOperations< Device > | |
| CTNL::Algorithms::AtomicOperations< Devices::Cuda > | |
| CTNL::Algorithms::AtomicOperations< Devices::Host > | |
| CTNL::Algorithms::AtomicOperations< Devices::Sequential > | |
| CTNL::Algorithms::CudaReductionBuffer | |
| CTNL::Algorithms::Reduction2D< Device > | |
| CTNL::Algorithms::Reduction2D< Devices::Cuda > | |
| CTNL::Algorithms::Reduction2D< Devices::Host > | |
| CTNL::Algorithms::Reduction2D< Devices::Sequential > | |
| CTNL::Algorithms::Reduction3D< Device > | |
| CTNL::Algorithms::Reduction3D< Devices::Cuda > | |
| CTNL::Algorithms::Reduction3D< Devices::Host > | |
| CTNL::Algorithms::Reduction3D< Devices::Sequential > | |
| CTNL::Algorithms::SegmentedScan< Device, Type > | Computes segmented scan (or prefix sum) on a vector |
| CTNL::Algorithms::SegmentedScan< Devices::Cuda, Type > | |
| CTNL::Algorithms::SegmentedScan< Devices::Host, Type > | |
| CTNL::Algorithms::SegmentedScan< Devices::Sequential, Type > | |
| CTNL::Algorithms::Segments::BiEllpackBase< Device, Index, Organization, WarpSize > | BiEllpackBase serves as a base class for TNL::Algorithms::Segments::BiEllpack and TNL::Algorithms::Segments::BiEllpackView |
| CTNL::Algorithms::Segments::BiEllpack< Device_, Index_, IndexAllocator_, Organization_, WarpSize_ > | |
| CTNL::Algorithms::Segments::BiEllpack< Device, Index, IndexAllocator, RowMajorOrder, WarpSize > | |
| CTNL::Algorithms::Segments::BiEllpack< Device, Index, IndexAllocator, ColumnMajorOrder, WarpSize > | |
| CTNL::Algorithms::Segments::BiEllpackView< Device, Index, Organization, WarpSize > | |
| CTNL::Algorithms::Segments::BiEllpackView< Device_, Index_, Organization, WarpSize > | |
| CTNL::Algorithms::Segments::BiEllpackView< Device, std::add_const_t< Index >, Organization, WarpSize > | |
| CTNL::Algorithms::Segments::BiEllpackView< Device, Index, RowMajorOrder, WarpSize > | |
| CTNL::Algorithms::Segments::BiEllpackView< Device, Index, ColumnMajorOrder, WarpSize > | |
| CTNL::Algorithms::Segments::BiEllpackBase< Device, Index, Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization(), 32 > | |
| CTNL::Algorithms::Segments::BiEllpackView< Device, Index, Organization, WarpSize > | BiEllpackView provides a non-owning encapsulation of meta-data stored in the TNL::Algorithms::Segments::BiEllpack segments |
| CTNL::Algorithms::Segments::BiEllpackBase< Device, Index, DefaultElementsOrganization< Device >::getOrganization(), 32 > | |
| CTNL::Algorithms::Segments::BiEllpack< Device, Index, IndexAllocator, Organization, WarpSize > | Data structure for Bisection Ellpack segments |
| CTNL::Algorithms::Segments::BiEllpackSegmentView< Index, Organization, WarpSize > | Data structure for accessing particular segment of BiEllpack segments |
| CTNL::Algorithms::Segments::ChunkedEllpackBase< Device, Index, Organization > | ChunkedEllpackBase serves as a base class for TNL::Algorithms::Segments::ChunkedEllpack and TNL::Algorithms::Segments::ChunkedEllpackView |
| CTNL::Algorithms::Segments::ChunkedEllpack< Device, Index, IndexAllocator, RowMajorOrder > | |
| CTNL::Algorithms::Segments::ChunkedEllpack< Device, Index, IndexAllocator, ColumnMajorOrder > | |
| CTNL::Algorithms::Segments::ChunkedEllpackView< Device, Index, Organization > | |
| CTNL::Algorithms::Segments::ChunkedEllpackView< Device, std::add_const_t< Index >, Organization > | |
| CTNL::Algorithms::Segments::ChunkedEllpackView< Device, Index, RowMajorOrder > | |
| CTNL::Algorithms::Segments::ChunkedEllpackView< Device, Index, ColumnMajorOrder > | |
| CTNL::Algorithms::Segments::ChunkedEllpackBase< Device, Index, Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization() > | |
| CTNL::Algorithms::Segments::ChunkedEllpackView< Device, Index, Organization > | ChunkedEllpackView provides a non-owning encapsulation of meta-data stored in the TNL::Algorithms::Segments::ChunkedEllpack segments |
| CTNL::Algorithms::Segments::ChunkedEllpackBase< Device, Index, DefaultElementsOrganization< Device >::getOrganization() > | |
| CTNL::Algorithms::Segments::ChunkedEllpack< Device, Index, IndexAllocator, Organization > | Data structure for Chunked Ellpack segments |
| CTNL::Algorithms::Segments::ChunkedEllpackBase< Device_, Index_, Organization > | |
| CTNL::Algorithms::Segments::ChunkedEllpack< Device_, Index_, IndexAllocator_, Organization_ > | |
| CTNL::Algorithms::Segments::ChunkedEllpackView< Device_, Index_, Organization > | |
| CTNL::Algorithms::Segments::ChunkedEllpackSegmentView< Index, Organization > | |
| CTNL::Algorithms::Segments::ChunkedEllpackSegmentView< Index, ColumnMajorOrder > | Data structure for accessing particular segment of column-major Chunked Ellpack segments |
| CTNL::Algorithms::Segments::ChunkedEllpackSegmentView< Index, RowMajorOrder > | Data structure for accessing particular segment of row-major Chunked Ellpack segments |
| CTNL::Algorithms::Segments::CSRBase< Device, Index > | CSRBase serves as a base class for TNL::Algorithms::Segments::CSR and TNL::Algorithms::Segments::CSRView |
| CTNL::Algorithms::Segments::CSR< Device, Index, IndexAllocator > | |
| CTNL::Algorithms::Segments::CSR< Device_, Index_, IndexAllocator_ > | |
| CTNL::Algorithms::Segments::AdaptiveCSR< Device_, Index_, IndexAllocator_ > | |
| CTNL::Algorithms::Segments::CSR< Device, Index, typename Allocators::Default< Device >::template Allocator< Index > > | |
| CTNL::Algorithms::Segments::AdaptiveCSR< Device, Index, IndexAllocator > | Data structure for the Adaptive CSR segments format |
| CTNL::Algorithms::Segments::CSRView< Device, std::add_const_t< Index > > | |
| CTNL::Algorithms::Segments::CSRView< Device_, Index_ > | |
| CTNL::Algorithms::Segments::AdaptiveCSRView< Device_, Index_ > | |
| CTNL::Algorithms::Segments::CSRView< DeviceType, IndexType > | |
| CTNL::Algorithms::Segments::CSRView< DeviceType, std::add_const_t< IndexType > > | |
| CTNL::Algorithms::Segments::CSR< Device, Index, IndexAllocator > | Data structure for CSR segments |
| CTNL::Algorithms::Segments::CSRView< Device, Index > | CSRView provides a non-owning encapsulation of meta-data stored in the TNL::Algorithms::Segments::CSR segments |
| CTNL::Algorithms::Segments::AdaptiveCSRView< Device, std::add_const_t< Index > > | |
| CTNL::Algorithms::Segments::AdaptiveCSRView< Device, Index > | AdaptiveCSRView provides a non-owning encapsulation of meta-data stored in the AdaptiveCSR segments |
| CTNL::Algorithms::Segments::CSRBase< Devices::Host, int > | |
| CTNL::Algorithms::Segments::CSR< Devices::Host, int, typename Allocators::Default< Devices::Host >::template Allocator< int > > | |
| CTNL::Algorithms::Segments::DefaultElementsOrganization< Device > | |
| CTNL::Algorithms::Segments::EllpackBase< Device, Index, Organization, Alignment > | EllpackBase serves as a base class for TNL::Algorithms::Segments::Ellpack and TNL::Algorithms::Segments::EllpackView |
| CTNL::Algorithms::Segments::Ellpack< Device_, Index_, IndexAllocator_, Organization_, Alignment_ > | |
| CTNL::Algorithms::Segments::Ellpack< Device, Index, IndexAllocator, RowMajorOrder, Alignment > | |
| CTNL::Algorithms::Segments::Ellpack< Device, Index, IndexAllocator, ColumnMajorOrder, Alignment > | |
| CTNL::Algorithms::Segments::EllpackView< Device, Index, Organization, Alignment > | |
| CTNL::Algorithms::Segments::EllpackView< Device_, Index_, Organization, Alignment > | |
| CTNL::Algorithms::Segments::EllpackView< Device, Index, RowMajorOrder, Alignment > | |
| CTNL::Algorithms::Segments::EllpackView< Device, Index, ColumnMajorOrder, Alignment > | |
| CTNL::Algorithms::Segments::EllpackBase< Device, Index, Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization(), 32 > | |
| CTNL::Algorithms::Segments::Ellpack< Device, Index, IndexAllocator, Organization, Alignment > | Data structure for Ellpack segments |
| CTNL::Algorithms::Segments::EllpackBase< Device, Index, Segments::DefaultElementsOrganization< Device >::getOrganization(), 32 > | |
| CTNL::Algorithms::Segments::EllpackView< Device, Index, Organization, Alignment > | EllpackView provides a non-owning encapsulation of meta-data stored in the TNL::Algorithms::Segments::Ellpack segments |
| CTNL::Algorithms::Segments::HasGetSegmentCountMethod< T > | |
| CTNL::Algorithms::Segments::LaunchConfigurationSetter_Default< Segments > | Creates default launch configuration for segments |
| CTNL::Algorithms::Segments::LaunchConfigurationSetter_HybridCSR< Segments > | Launch configuration setter for CSR segments |
| CTNL::Algorithms::Segments::LaunchConfigurationSetter_LightCSR< Segments > | Launch configuration setter for CSR segments |
| CTNL::Algorithms::Segments::SegmentElement< Index > | Simple structure representing one element of a segment |
| CTNL::Algorithms::Segments::SegmentsPrinter< SegmentsView, Fetch > | |
| CTNL::Algorithms::Segments::SegmentView< Index, Organization > | Data structure for accessing particular segment |
| CTNL::Algorithms::Segments::SegmentView< Index, ColumnMajorOrder > | Data structure for accessing particular segment |
| CTNL::Algorithms::Segments::SegmentView< Index, RowMajorOrder > | |
| CTNL::Algorithms::Segments::SegmentViewIterator< SegmentView > | Iterator for iterating over elements of a segment |
| CTNL::Algorithms::Segments::SlicedEllpackBase< Device, Index, Organization, SliceSize > | SlicedEllpackBase serves as a base class for TNL::Algorithms::Segments::SlicedEllpack and TNL::Algorithms::Segments::SlicedEllpackView |
| CTNL::Algorithms::Segments::SlicedEllpack< Device_, Index_, IndexAllocator_, Organization_, SliceSize_ > | |
| CTNL::Algorithms::Segments::SlicedEllpack< Device, Index, IndexAllocator, RowMajorOrder, SliceSize > | |
| CTNL::Algorithms::Segments::SlicedEllpack< Device, Index, IndexAllocator, ColumnMajorOrder, SliceSize > | |
| CTNL::Algorithms::Segments::SlicedEllpackView< Device, Index, Organization, SliceSize > | |
| CTNL::Algorithms::Segments::SlicedEllpackView< Device, std::add_const_t< Index >, Organization, SliceSize > | |
| CTNL::Algorithms::Segments::SlicedEllpackView< Device_, Index_, Organization, SliceSize > | |
| CTNL::Algorithms::Segments::SlicedEllpackView< Device, Index, RowMajorOrder, SliceSize > | |
| CTNL::Algorithms::Segments::SlicedEllpackView< Device, Index, ColumnMajorOrder, SliceSize > | |
| CTNL::Algorithms::Segments::SlicedEllpackBase< Device, Index, Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization(), 32 > | |
| CTNL::Algorithms::Segments::SlicedEllpack< Device, Index, IndexAllocator, Organization, SliceSize > | Data structure for Sliced Ellpack segments |
| CTNL::Algorithms::Segments::SlicedEllpackView< Device, Index, Organization, SliceSize > | SlicedEllpackView provides a non-owning encapsulation of meta-data stored in the TNL::Algorithms::Segments::SlicedEllpack segments |
| CTNL::Algorithms::Segments::SortedSegmentsBase< EmbeddedSegmentsView_ > | SortedSegmentsBase serves as a base class for TNL::Algorithms::Segments::SortedSegments and TNL::Algorithms::Segments::SortedSegmentsView |
| CTNL::Algorithms::Segments::SortedSegments< AdaptiveCSR< Device, Index, IndexAllocator > > | |
| CTNL::Algorithms::Segments::SortedSegments< BiEllpack< Device, Index, IndexAllocator, Organization, WarpSize > > | |
| CTNL::Algorithms::Segments::SortedSegments< RowMajorBiEllpack< Device, Index, IndexAllocator, WarpSize > > | |
| CTNL::Algorithms::Segments::SortedSegments< ColumnMajorBiEllpack< Device, Index, IndexAllocator, WarpSize > > | |
| CTNL::Algorithms::Segments::SortedSegments< ChunkedEllpack< Device, Index, IndexAllocator, Organization > > | |
| CTNL::Algorithms::Segments::SortedSegments< RowMajorChunkedEllpack< Device, Index, IndexAllocator > > | |
| CTNL::Algorithms::Segments::SortedSegments< ColumnMajorChunkedEllpack< Device, Index, IndexAllocator > > | |
| CTNL::Algorithms::Segments::SortedSegments< CSR< Device, Index, IndexAllocator > > | |
| CTNL::Algorithms::Segments::SortedSegments< Ellpack< Device, Index, IndexAllocator, Organization, Alignment > > | |
| CTNL::Algorithms::Segments::SortedSegments< RowMajorEllpack< Device, Index, IndexAllocator, Alignment > > | |
| CTNL::Algorithms::Segments::SortedSegments< ColumnMajorEllpack< Device, Index, IndexAllocator, Alignment > > | |
| CTNL::Algorithms::Segments::SortedSegments< SlicedEllpack< Device, Index, IndexAllocator, Organization, SliceSize > > | |
| CTNL::Algorithms::Segments::SortedSegments< RowMajorSlicedEllpack< Device, Index, IndexAllocator, SliceSize > > | |
| CTNL::Algorithms::Segments::SortedSegments< ColumnMajorSlicedEllpack< Device, Index, IndexAllocator, SliceSize > > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< AdaptiveCSRView< Device, Index > > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< BiEllpackView< Device, Index, Organization, WarpSize > > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< RowMajorBiEllpackView< Device, Index, WarpSize > > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< ColumnMajorBiEllpackView< Device, Index, WarpSize > > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< ChunkedEllpackView< Device, Index, Organization > > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< RowMajorChunkedEllpackView< Device, Index > > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< ColumnMajorChunkedEllpackView< Device, Index > > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< CSRView< Device, Index > > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< EmbeddedSegmentsView > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< EllpackView< Device, Index, Organization, Alignment > > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< RowMajorEllpackView< Device, Index, Alignment > > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< ColumnMajorEllpackView< Device, Index, Alignment > > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< SlicedEllpackView< Device, Index, Organization, SliceSize > > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< RowMajorSlicedEllpackView< Device, Index, SliceSize > > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< ColumnMajorSlicedEllpackView< Device, Index, SliceSize > > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< typename EmbeddedSegments::ConstViewType > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< typename EmbeddedSegments::template ViewTemplate< Device_, Index_ > > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< EmbeddedSegmentsConstView > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< typename EmbeddedSegmentsView::template ViewTemplate< Device_, Index_ > > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< EmbeddedSegmentsView_ > | SortedSegmentsView provides a non-owning encapsulation of meta-data stored in the TNL::Algorithms::Segments::SortedSegments segments |
| CTNL::Algorithms::Segments::SortedSegmentsBase< EmbeddedSegments::ViewType > | |
| CTNL::Algorithms::Segments::SortedSegments< EmbeddedSegments, IndexAllocator > | Data structure for sorted segments |
| CTNL::Algorithms::Segments::SortedSegmentsBase< typename EmbeddedSegments::ViewType > | |
| CTNL::Algorithms::Segments::SortedSegmentsView< typename EmbeddedSegments::ViewType > | |
| CTNL::Algorithms::SegmentsReductionKernels::BiEllpackKernel< Index, Device > | |
| CTNL::Algorithms::SegmentsReductionKernels::ChunkedEllpackKernel< Index, Device > | |
| CTNL::Algorithms::SegmentsReductionKernels::CSRAdaptiveKernel< Index, Device > | |
| CTNL::Algorithms::SegmentsReductionKernels::CSRAdaptiveKernelView< Index, Device > | |
| CTNL::Algorithms::SegmentsReductionKernels::CSRHybridKernel< Index, Device, ThreadsInBlock > | |
| CTNL::Algorithms::SegmentsReductionKernels::CSRLightKernel< Index, Device > | |
| CTNL::Algorithms::SegmentsReductionKernels::CSRScalarKernel< Index, Device > | |
| CTNL::Algorithms::SegmentsReductionKernels::CSRVectorKernel< Index, Device > | |
| CTNL::Algorithms::SegmentsReductionKernels::DefaultKernel< SegmentsView > | |
| CTNL::Algorithms::SegmentsReductionKernels::DefaultKernel< Segments::AdaptiveCSRView< Device, Index > > | |
| CTNL::Algorithms::SegmentsReductionKernels::DefaultKernel< Segments::BiEllpackView< Device, Index, Organization, WarpSize > > | |
| CTNL::Algorithms::SegmentsReductionKernels::DefaultKernel< Segments::ChunkedEllpackView< Device, Index, Organization > > | |
| CTNL::Algorithms::SegmentsReductionKernels::DefaultKernel< Segments::CSRView< Device, Index > > | |
| CTNL::Algorithms::SegmentsReductionKernels::DefaultKernel< Segments::EllpackView< Device, Index, Organization, Alignment > > | |
| CTNL::Algorithms::SegmentsReductionKernels::DefaultKernel< Segments::SlicedEllpackView< Device, Index, Organization, SliceSize > > | |
| CTNL::Algorithms::SegmentsReductionKernels::DefaultKernel< Segments::SortedSegmentsView< EmbeddedSegments > > | |
| CTNL::Algorithms::SegmentsReductionKernels::EllpackKernel< Index, Device > | |
| CTNL::Algorithms::SegmentsReductionKernels::isSegmentReductionKernel< SegmentReductionKernel > | |
| CTNL::Algorithms::SegmentsReductionKernels::SlicedEllpackKernel< Index, Device > | |
| CTNL::Algorithms::SequentialFor< Device > | Wrapper to ParallelFor which makes it run sequentially |
| CTNL::Algorithms::Sorting::BitonicSort | |
| CTNL::Algorithms::Sorting::BubbleSort | |
| CTNL::Algorithms::Sorting::CUBMergeSort | CUDA merge sort using CUB's DeviceMergeSort |
| CTNL::Algorithms::Sorting::CUBRadixSort | CUDA radix sort using CUB's DeviceRadixSort |
| CTNL::Algorithms::Sorting::DefaultInplaceSorter< Device > | |
| CTNL::Algorithms::Sorting::DefaultInplaceSorter< Devices::Cuda > | |
| CTNL::Algorithms::Sorting::DefaultInplaceSorter< Devices::Host > | |
| CTNL::Algorithms::Sorting::DefaultInplaceSorter< Devices::Sequential > | |
| CTNL::Algorithms::Sorting::DefaultSorter< Device > | |
| CTNL::Algorithms::Sorting::DefaultSorter< Devices::Cuda > | |
| CTNL::Algorithms::Sorting::DefaultSorter< Devices::Host > | |
| CTNL::Algorithms::Sorting::DefaultSorter< Devices::Sequential > | |
| CTNL::Algorithms::Sorting::experimental::Quicksort | Parallel quicksort for CUDA |
| CTNL::Algorithms::Sorting::STLSort | |
| CTNL::Allocators::Cuda< T > | Allocator for the CUDA device memory space |
| CTNL::Allocators::CudaHost< T > | Allocator for page-locked memory on the host |
| CTNL::Allocators::CudaManaged< T > | Allocator for the CUDA Unified Memory system |
| CTNL::Allocators::Default< Device > | A trait-like class used for the selection of a default allocators for given device |
| CTNL::Allocators::Default< Devices::Cuda > | Sets Allocators::Cuda as the default allocator for Devices::Cuda |
| CTNL::Allocators::Default< Devices::Host > | Sets Allocators::Host as the default allocator for Devices::Host |
| CTNL::Allocators::Default< Devices::Sequential > | Sets Allocators::Host as the default allocator for Devices::Sequential |
| CTNL::Allocators::Hip< T > | Allocator for the HIP device memory space |
| CTNL::Allocators::HipHost< T > | Allocator for page-locked memory on the host |
| CTNL::Allocators::HipManaged< T > | Allocator for the HIP Unified Memory system |
| CTNL::AnyWithArg | Function object implementing argany(x, y, i, j), i.e. returning the first true value and its index |
| CTNL::Arithmetics::Complex< Value > | Implementation of complex types |
| CTNL::Arithmetics::experimental::Double< T > | |
| CTNL::Arithmetics::experimental::MultiPrecision | |
| CTNL::Arithmetics::experimental::Quad< T > | |
| CTNL::Arithmetics::experimental::Real< T > | |
| CTNL::Arithmetics::experimental::tnlFlopsCounter | |
| CTNL::Atomic< T, Device > | |
| CTNL::Atomic< T, Devices::Cuda > | Atomic wrapper for the CUDA/HIP device |
| CTNL::Backend::LaunchConfiguration | Holds the parameters necessary to launch a CUDA or HIP kernel (i.e. schedule it for execution on some stream of some device) |
| CTNL::Algorithms::Segments::LaunchConfiguration | Launch configuration for segment operations |
| CTNL::Backend::SharedMemory< T, _alignment > | |
| CTNL::Backend::SharedMemory< T, 16 > | |
| CTNL::Backend::SharedMemory< T, 32 > | |
| CTNL::Backend::SharedMemory< T, 64 > | |
| CTNL::Backend::SharedMemory< T, 8 > | |
| CTNL::Backend::Stream | |
| CTNL::Backend::StreamPool | |
| CTNL::Backend::Uninitialized< T, maxWordSize > | Storage wrapper for type-punning through an array of device words |
| CTNL::Benchmarks::Benchmark | Base class for running benchmarks with timing and logging support |
| CTNL::Benchmarks::BenchmarkResult | Container for benchmark measurement results |
| CTNL::Benchmarks::Logging | Abstract base class for benchmark result loggers |
| CTNL::Benchmarks::JsonLogging | Logger that outputs benchmark results as JSON lines (JSONL) |
| CTNL::Benchmarks::TerminalLogger | Logger that outputs benchmark results to terminal/console |
| CTNL::Benchmarks::LoggingRowElements | Container for formatted row data in benchmark output |
| CTNL::Cast< ResultType > | |
| CTNL::Cast< ResultType >::Operation | |
| CTNL::CFD::TurbulenceGenerator< Real, Device, Index > | Synthetic turbulence generator based on the code from [1, 2]. Usable for initial as well as inlet boundary conditions |
| CTNL::Config::ConfigDescription | |
| CTNL::Config::ConfigEntryBase | |
| CTNL::Config::ConfigEntry< EntryType, std::vector< EntryType > > | |
| CTNL::Config::ConfigEntryList< EntryType > | |
| CTNL::Config::ConfigDelimiter | |
| CTNL::Config::ConfigEntry< EntryType, DefaultValueType > | |
| CTNL::Config::ParameterContainer | |
| CTNL::Config::ParameterTypeCoercion< T > | |
| CTNL::Config::ParameterTypeCoercion< std::vector< T > > | |
| CTNL::Containers::Array< Value, Device, Index, Allocator > | Array is responsible for memory management, access to array elements, and general array operations |
| CTNL::Containers::Vector< Index, Device, typename Base::IndexType, IndexAllocator > | |
| CTNL::Containers::Vector< IndexType, DeviceType, IndexType > | |
| CTNL::Containers::Vector< IndexType, DeviceType, IndexType, IndexAllocatorType > | |
| CTNL::Containers::Vector< Real, Device, unsigned > | |
| CTNL::Containers::Vector< RealType, DeviceType, IndexType > | |
| CTNL::Containers::Vector< _Real, _Device, _Index, _Allocator > | |
| CTNL::Containers::Vector< Real, Device, Index, RealAllocator > | |
| CTNL::Containers::Vector< Index, Device, Index > | |
| CTNL::Containers::Vector< Index, Device, Index, IndexAllocator > | |
| CTNL::Containers::Vector< Index, Devices::Host, Index > | |
| CTNL::Containers::Vector< bool, Devices::Host, GlobalIndexType > | |
| CTNL::Containers::Vector< RealType, Devices::Host, IndexType > | |
| CTNL::Containers::Vector< typename Matrix::RealType, typename Matrix::DeviceType, typename Matrix::IndexType > | |
| CTNL::Containers::Array< double, Devices::Host, int, Allocator > | |
| CTNL::Containers::Vector< double, Devices::Host, int, typename Allocators::Default< Devices::Host >::template Allocator< double > > | |
| CTNL::Containers::Array< double, Devices::Host, int, typename Allocators::Default< Devices::Host >::template Allocator< double > > | |
| CTNL::Containers::Vector< Real, Device, Index, Allocator > | Vector extends Array with algebraic operations |
| CTNL::Containers::Array< GlobalIndexType, DeviceType, GlobalIndexType, typename Allocators::Default< DeviceType >::template Allocator< GlobalIndexType > > | |
| CTNL::Containers::Vector< GlobalIndexType, DeviceType, GlobalIndexType > | |
| CTNL::Containers::Array< GlobalIndexType, TNL::Devices::Host, int, Allocator > | |
| CTNL::Containers::Vector< GlobalIndexType, TNL::Devices::Host, int, typename Allocators::Default< TNL::Devices::Host >::template Allocator< GlobalIndexType > > | |
| CTNL::Containers::Array< Index, Device, Index, Allocator > | |
| CTNL::Containers::Vector< Index, Device, Index, typename Allocators::Default< Device >::template Allocator< Index > > | |
| CTNL::Containers::Array< Index, Device, typename Base::IndexType, Allocator > | |
| CTNL::Containers::Vector< Index, Device, typename Base::IndexType, typename Allocators::Default< Device >::template Allocator< Index > > | |
| CTNL::Containers::Array< IndexType, TNL::Devices::Host, IndexType, Allocator > | |
| CTNL::Containers::Vector< IndexType, TNL::Devices::Host, IndexType, typename Allocators::Default< TNL::Devices::Host >::template Allocator< IndexType > > | |
| CTNL::Containers::Array< int, Devices::Host, int, Allocator > | |
| CTNL::Containers::Vector< int, Devices::Host, int, typename Allocators::Default< Devices::Host >::template Allocator< int > > | |
| CTNL::Containers::Array< int, Devices::Host, int, typename Allocators::Default< Devices::Host >::template Allocator< int > > | |
| CTNL::Containers::Vector< int, Devices::Host, int > | |
| CTNL::Containers::Array< int, Devices::Host, typename Base::IndexType, Allocator > | |
| CTNL::Containers::Vector< int, Devices::Host, typename Base::IndexType, typename Allocators::Default< Devices::Host >::template Allocator< int > > | |
| CTNL::Containers::Array< RealType, TNL::Devices::Host, IndexType, Allocator > | |
| CTNL::Containers::Vector< RealType, TNL::Devices::Host, IndexType, typename Allocators::Default< TNL::Devices::Host >::template Allocator< RealType > > | |
| CTNL::Containers::Array< Value, Device, Index, Allocator > | |
| CTNL::Containers::Vector< Value, Device, Index, typename Allocators::Default< Device >::template Allocator< Value > > | |
| CTNL::Containers::ArrayView< Value, Device, Index > | ArrayView is a simple data structure which provides a non-owning encapsulation of array data. That is, ArrayView is like Array without memory management |
| CTNL::Containers::VectorView< Index, DeviceType, IndexType > | |
| CTNL::Containers::VectorView< std::add_const_t< Index >, DeviceType, IndexType > | |
| CTNL::Containers::VectorView< RealType, DeviceType, IndexType > | |
| CTNL::Containers::VectorView< _Real, _Device, _Index > | |
| CTNL::Containers::VectorView< ValueType, typename Matrix::DeviceType, typename Matrix::IndexType > | |
| CTNL::Containers::VectorView< std::add_const_t< RealType >, DeviceType, IndexType > | |
| CTNL::Containers::VectorView< typename Matrix::RealType, typename Matrix::DeviceType, typename Matrix::IndexType > | |
| CTNL::Containers::ArrayView< double, Devices::Host, int > | |
| CTNL::Containers::VectorView< double, Devices::Host, int > | |
| CTNL::Containers::VectorView< Real, Device, Index > | VectorView extends ArrayView with algebraic operations |
| CTNL::Containers::ArrayView< GlobalIndexType, TNL::Devices::Host, int > | |
| CTNL::Containers::VectorView< GlobalIndexType, TNL::Devices::Host, int > | |
| CTNL::Containers::ArrayView< IndexType, DeviceType, IndexType > | |
| CTNL::Containers::VectorView< IndexType, DeviceType, IndexType > | |
| CTNL::Containers::ArrayView< int, DeviceType, IndexType > | |
| CTNL::Containers::VectorView< int, DeviceType, IndexType > | |
| CTNL::Containers::ArrayView< Real, Device, Index > | |
| CTNL::Containers::VectorView< Real, Device, Index > | |
| CTNL::Containers::VectorView< std::add_const_t< Real >, Device, Index > | |
| CTNL::Containers::VectorView< std::conditional_t< std::is_const_v< Real >, std::add_const_t< Index >, Index >, Device, Index > | |
| CTNL::Containers::VectorView< typename TNL::copy_const< Index >::template from< Real >::type, Device, Index > | |
| CTNL::Containers::ArrayView< Real, Devices::Host, int > | |
| CTNL::Containers::VectorView< Real, Devices::Host, int > | |
| CTNL::Containers::VectorView< typename TNL::copy_const< int >::template from< Real >::type, Devices::Host, int > | |
| CTNL::Containers::ArrayView< RealType, TNL::Devices::Host, IndexType > | |
| CTNL::Containers::VectorView< RealType, TNL::Devices::Host, IndexType > | |
| CTNL::Containers::ArrayView< std::conditional_t< std::is_const_v< double >, std::add_const_t< int >, int >, Devices::Host, int > | |
| CTNL::Containers::VectorView< std::conditional_t< std::is_const_v< double >, std::add_const_t< int >, int >, Devices::Host, int > | |
| CTNL::Containers::ArrayView< typename TNL::copy_const< Index >::template from< Value >::type, Device, Index > | |
| CTNL::Containers::VectorView< typename TNL::copy_const< Index >::template from< Value >::type, Device, Index > | |
| CTNL::Containers::ArrayView< typename TNL::copy_const< IndexType >::template from< RealType >::type, TNL::Devices::Host, IndexType > | |
| CTNL::Containers::VectorView< typename TNL::copy_const< IndexType >::template from< RealType >::type, TNL::Devices::Host, IndexType > | |
| CTNL::Containers::ArrayView< typename TNL::copy_const< int >::template from< double >::type, Devices::Host, int > | |
| CTNL::Containers::VectorView< typename TNL::copy_const< int >::template from< double >::type, Devices::Host, int > | |
| CTNL::Containers::ArrayView< Value, Device, Index > | |
| CTNL::Containers::VectorView< Value, Device, Index > | |
| CTNL::Containers::Block< D, idx_ > | Minimal class representing a block of an equidistant D-dimensional lattice |
| CTNL::Containers::ByteArraySynchronizer< Device, Index > | |
| CTNL::Containers::ByteArraySynchronizer< DistributedArray::DeviceType, DistributedArray::IndexType > | |
| CTNL::Containers::DistributedArraySynchronizer< DistributedArray > | |
| CTNL::Containers::ByteArraySynchronizer< DistributedMesh::DeviceType, DistributedMesh::GlobalIndexType > | |
| CTNL::Meshes::DistributedMeshes::DistributedMeshSynchronizer< DistributedMesh< Grid< MeshDimension, GridReal, Device, Index > >, MeshDimension > | |
| CTNL::Meshes::DistributedMeshes::DistributedMeshSynchronizer< DistributedMesh, EntityDimension > | |
| CTNL::Containers::ConstStaticSizesHolder< Index, dimension, constSize > | |
| CTNL::Containers::DistributedArray< Value, Device, Index, Allocator > | Distributed array |
| CTNL::Containers::DistributedVector< _Real, _Device, _Index, _Allocator > | |
| CTNL::Containers::DistributedVector< RealType, DeviceType, IndexType > | |
| CTNL::Containers::DistributedVector< IndexType, DeviceType, IndexType > | |
| CTNL::Containers::DistributedVector< typename Matrix::RealType, typename Matrix::DeviceType, typename Matrix::IndexType > | |
| CTNL::Containers::DistributedArray< Real, Devices::Host, int, typename Allocators::Default< Devices::Host >::template Allocator< Real > > | |
| CTNL::Containers::DistributedVector< Real, Device, Index, Allocator > | DistributedVector extends DistributedArray with algebraic operations |
| CTNL::Containers::DistributedArrayView< Value, Device, Index > | Distributed array view |
| CTNL::Containers::DistributedVectorView< _Real, _Device, _Index > | |
| CTNL::Containers::DistributedVectorView< typename Matrix::RealType, typename Matrix::DeviceType, typename Matrix::IndexType > | |
| CTNL::Containers::DistributedVectorView< std::add_const_t< typename Matrix::RealType >, typename Matrix::DeviceType, typename Matrix::IndexType > | |
| CTNL::Containers::DistributedArrayView< Real, Device, Index > | |
| CTNL::Containers::DistributedVectorView< Real, Device, Index > | |
| CTNL::Containers::DistributedVectorView< std::add_const_t< Real >, Device, Index > | |
| CTNL::Containers::DistributedArrayView< Real, Devices::Host, int > | |
| CTNL::Containers::DistributedVectorView< Real, Device, Index > | DistributedVectorView extends DistributedArrayView with algebraic operations |
| CTNL::Containers::DistributedNDArray< NDArray > | Distributed N-dimensional array |
| CTNL::Containers::DistributedNDArraySynchronizer< DistributedNDArray > | Synchronizer for DistributedNDArray |
| CTNL::Containers::DistributedNDArraySynchronizer< DistributedNDArray >::CopyKernel< BufferView > | |
| CTNL::Containers::DistributedNDArrayView< NDArrayView > | Distributed N-dimensional array view |
| CTNL::Containers::Expressions::BinaryExpressionTemplate< T1, T2, Operation, T1Type, T2Type > | |
| CTNL::Containers::Expressions::BinaryExpressionTemplate< T1, T2, Operation, ArithmeticVariable, VectorExpressionVariable > | |
| CTNL::Containers::Expressions::BinaryExpressionTemplate< T1, T2, Operation, VectorExpressionVariable, ArithmeticVariable > | |
| CTNL::Containers::Expressions::BinaryExpressionTemplate< T1, T2, Operation, VectorExpressionVariable, VectorExpressionVariable > | |
| CTNL::Containers::Expressions::DistributedBinaryExpressionTemplate< T1, T2, Operation, T1Type, T2Type > | |
| CTNL::Containers::Expressions::DistributedBinaryExpressionTemplate< T1, T2, Operation, ArithmeticVariable, VectorExpressionVariable > | |
| CTNL::Containers::Expressions::DistributedBinaryExpressionTemplate< T1, T2, Operation, VectorExpressionVariable, ArithmeticVariable > | |
| CTNL::Containers::Expressions::DistributedBinaryExpressionTemplate< T1, T2, Operation, VectorExpressionVariable, VectorExpressionVariable > | |
| CTNL::Containers::Expressions::DistributedUnaryExpressionTemplate< T1, Operation > | |
| CTNL::Containers::Expressions::OperandMemberType< R, Enable > | |
| CTNL::Containers::Expressions::OperandMemberType< R, typename enable_if_type< typename R::VectorOperandType >::type > | |
| CTNL::Containers::Expressions::RemoveExpressionTemplate< R, Enable > | |
| CTNL::Containers::Expressions::RemoveExpressionTemplate< R, typename enable_if_type< typename std::decay_t< R >::VectorOperandType >::type > | |
| CTNL::Containers::Expressions::StaticBinaryExpressionTemplate< T1, T2, Operation, T1Type, T2Type > | |
| CTNL::Containers::Expressions::StaticBinaryExpressionTemplate< T1, T2, Operation, ArithmeticVariable, VectorExpressionVariable > | |
| CTNL::Containers::Expressions::StaticBinaryExpressionTemplate< T1, T2, Operation, VectorExpressionVariable, ArithmeticVariable > | |
| CTNL::Containers::Expressions::StaticBinaryExpressionTemplate< T1, T2, Operation, VectorExpressionVariable, VectorExpressionVariable > | |
| CTNL::Containers::Expressions::StaticUnaryExpressionTemplate< T1, Operation > | |
| CTNL::Containers::Expressions::UnaryExpressionTemplate< T1, Operation > | |
| CTNL::Containers::HypreParVector | Wrapper for Hypre's parallel vector |
| CTNL::Containers::HypreVector | Wrapper for Hypre's sequential vector |
| CTNL::Containers::IndexedMap< Value, Index, Key > | |
| CTNL::Containers::IndexedMap< Value, Index, Key >::DataWithIndex | |
| CTNL::Containers::IndexedSet< Key, Index, Compare, Allocator > | |
| CTNL::Containers::NDArrayIndexer< SizesHolder, StridesHolder, Overlaps > | Indexer for N-dimensional arrays. It does not store any data, only the sizes of each dimension |
| CTNL::Containers::NDArrayStorage< StaticArray< detail::getStaticStorageSize(SizesHolder{}), Value >, NDArrayIndexer< SizesHolder, detail::make_strides_holder< Permutation, SizesHolder > >, Permutation, Devices::Sequential > | |
| CTNL::Containers::StaticNDArray< Value, Containers::SizesHolder< int, Rows, Columns >, Permutation > | |
| CTNL::Containers::NDArrayIndexer< SizesHolder, detail::make_strides_holder< std::index_sequence< 0, 1 >, SizesHolder > > | |
| CTNL::Containers::NDArrayStorage< StaticArray< detail::getStaticStorageSize(SizesHolder{}), Value >, NDArrayIndexer< SizesHolder, detail::make_strides_holder< std::index_sequence< 0, 1 >, SizesHolder > >, std::index_sequence< 0, 1 >, Devices::Sequential > | |
| CTNL::Containers::StaticNDArray< Value, Containers::SizesHolder< int, Rows, Columns >, std::index_sequence< 0, 1 > > | |
| CTNL::Matrices::StaticMatrix< Value, Rows, Columns, Permutation > | |
| CTNL::Containers::NDArrayIndexer< SizesHolder, detail::make_strides_holder< std::make_index_sequence< SizesHolder::getDimension() >, SizesHolder > > | |
| CTNL::Containers::NDArrayStorage< StaticArray< detail::getStaticStorageSize(SizesHolder{}), Value >, NDArrayIndexer< SizesHolder, detail::make_strides_holder< std::make_index_sequence< SizesHolder::getDimension() >, SizesHolder > >, std::make_index_sequence< SizesHolder::getDimension() >, Devices::Sequential > | |
| CTNL::Containers::StaticNDArray< Value, SizesHolder, Permutation, Index > | Static N-dimensional array |
| CTNL::Containers::NDArrayIndexer< SizesHolder, detail::make_strides_holder< std::make_index_sequence< SizesHolder::getDimension() >, SizesHolder >, ConstStaticSizesHolder< typename SizesHolder::IndexType, SizesHolder::getDimension(), 0 > > | |
| CTNL::Containers::NDArrayStorage< Array< Value, Devices::Host, typename SizesHolder::IndexType, typename Allocators::Default< Devices::Host >::template Allocator< Value > >, NDArrayIndexer< SizesHolder, detail::make_strides_holder< std::make_index_sequence< SizesHolder::getDimension() >, SizesHolder >, ConstStaticSizesHolder< typename SizesHolder::IndexType, SizesHolder::getDimension(), 0 > >, std::make_index_sequence< SizesHolder::getDimension() > > | |
| CTNL::Containers::NDArray< Value, SizesHolder, Permutation, Device, Index, Overlaps, Allocator > | Dynamic N-dimensional array |
| CTNL::Containers::SizesHolder< Index, sizes > | Holds static and dynamic sizes of an N-dimensional array |
| CTNL::Containers::LocalBeginsHolder< SizesHolder, ConstValue > | Wrapper for local begins in DistributedNDArray |
| CTNL::Containers::StaticArray< Size, Value > | Array with constant size |
| CTNL::Containers::StaticVector< getGroupsCount(), IndexType > | |
| CTNL::Containers::StaticVector< Size, RealType > | |
| CTNL::Containers::StaticVector< Dimension, IndexType > | |
| CTNL::Containers::StaticVector< Dimension, Index > | |
| CTNL::Containers::StaticVector< Dimension, Real > | |
| CTNL::Containers::StaticVector< Dimension+1, Index > | |
| CTNL::Containers::StaticVector< 1<< Dimension, CoordinatesType > | |
| CTNL::Containers::StaticVector< std::integral_constant< Index, discretePow(spaceStepsPowersSize, Dimension) >::value, Real > | |
| CTNL::Containers::StaticArray< Size, double > | |
| CTNL::Containers::StaticVector< Dimension, double > | |
| CTNL::Containers::StaticVector< std::integral_constant< int, discretePow(spaceStepsPowersSize, Dimension) >::value, double > | |
| CTNL::Containers::StaticVector< Size, Real > | Vector with constant size |
| CTNL::Containers::StaticArray< Size, idx > | |
| CTNL::Containers::StaticVector< D, idx > | |
| CTNL::Containers::StaticVector< 3, idx > | |
| CTNL::Containers::StaticArray< Size, int > | |
| CTNL::Containers::StaticVector< Dimension, int > | |
| CTNL::Containers::StaticVector< Dimension+1, int > | |
| CTNL::Containers::StaticSizesHolder< Index, sizes > | Holds static sizes of an N-dimensional array |
| CTNL::Containers::Subrange< Index > | Specifies a subrange [begin, end) of a range [0, globalSize) |
| CTNL::Containers::UnorderedIndexedSet< Key, Index, Hash, KeyEqual, Allocator > | |
| CTNL::copy_const< Target > | Copy const qualifier from Source type to Target type |
| CTNL::copy_const< Target >::from< Source > | |
| CTNL::CPUCacheSizes | CPU cache sizes |
| CTNL::CPUInfo | CPU information |
| CTNL::Devices::GPU | |
| CTNL::Devices::Host | |
| CTNL::Devices::Host::LaunchConfiguration | For compatibility with TNL::Devices::Cuda only. In the future, it may be used to specify parameters for OpenMP execution |
| CTNL::Devices::Sequential | |
| CTNL::Devices::Sequential::LaunchConfiguration | Not used by any sequential algorithm, only for compatibility with parallel execution models |
| CTNL::enable_if_type< T, R > | |
| CTNL::File | This class serves for binary IO. It allows to do IO even for data allocated on GPU together with on-the-fly data type conversion |
| CTNL::Functions::experimental::CutMeshFunction< MeshFunctionType, OutMesh, OutDof, outDimension, codimension > | |
| CTNL::Functions::experimental::Domain< Dimension, DomainType_ > | |
| CTNL::Functions::experimental::MeshFunction< MeshType, MeshEntityDimension, RealType > | |
| CTNL::Functions::experimental::MeshFunctionView< MeshType, MeshEntityDimension, RealType > | |
| CTNL::Functions::experimental::VectorField< VectorFieldSize, MeshFunction< MeshType, 1, RealType > > | |
| CTNL::Functions::experimental::VectorField< VectorFieldSize, MeshFunction< MeshType, 0, RealType > > | |
| CTNL::Functions::experimental::VectorField< VectorFieldSize, MeshFunction< MeshType, 2, RealType > > | |
| CTNL::Functions::experimental::VectorField< VectorFieldSize, MeshFunction< MeshType, 3, RealType > > | |
| CTNL::Functions::experimental::Domain< Function::getDomainDimension(), Function::getDomainType() > | |
| CTNL::Functions::experimental::VectorField< Size, Function > | |
| CTNL::Functions::experimental::Domain< Mesh::getMeshDimension(), MeshDomain > | |
| CTNL::Functions::experimental::MeshFunction< Mesh, MeshEntityDimension, Real > | |
| CTNL::Functions::experimental::MeshFunction< Mesh, Mesh::getMeshDimension(), typename Mesh::RealType > | |
| CTNL::Functions::experimental::BoundaryMeshFunction< Mesh, MeshEntityDimension, Real > | |
| CTNL::Functions::experimental::MeshFunction< Mesh, MeshEntityDimension, Real > | |
| CTNL::Functions::experimental::MeshFunctionView< Mesh, MeshEntityDimension, Real > | |
| CTNL::Functions::experimental::Domain< MeshFunction< Mesh, MeshEntityDimension, Real >::getDomainDimension(), MeshFunction< Mesh, MeshEntityDimension, Real >::getDomainType() > | |
| CTNL::Functions::experimental::VectorField< Size, MeshFunction< Mesh, MeshEntityDimension, Real > > | |
| CTNL::Functions::experimental::VectorField< Size, MeshFunction< Mesh, MeshEntityDimension, Real > > | |
| CTNL::Functions::experimental::Domain< MeshFunctionView< Mesh, MeshEntityDimension, Real >::getDomainDimension(), MeshFunctionView< Mesh, MeshEntityDimension, Real >::getDomainType() > | |
| CTNL::Functions::experimental::VectorField< Size, MeshFunctionView< Mesh, MeshEntityDimension, Real > > | |
| CTNL::Functions::experimental::VectorField< Size, MeshFunctionView< Mesh, MeshEntityDimension, Real > > | |
| CTNL::Functions::experimental::FunctionAdapter< Mesh, Function, domainType > | |
| CTNL::Functions::experimental::FunctionAdapter< Mesh, Function, NonspaceDomain > | |
| CTNL::Functions::experimental::FunctionAdapter< Mesh, Function, SpaceDomain > | |
| CTNL::Functions::experimental::MeshFunctionEvaluator< OutMeshFunction, InFunction > | |
| CTNL::Functions::experimental::MeshFunctionEvaluatorAdditionEntitiesProcessor< MeshType, UserData > | |
| CTNL::Functions::experimental::MeshFunctionEvaluatorAssignmentEntitiesProcessor< MeshType, UserData > | |
| CTNL::Functions::experimental::MeshFunctionEvaluatorTraverserUserData< OutMeshFunction, InFunction, Real > | |
| CTNL::Functions::experimental::MeshFunctionGnuplotWriterBase | |
| CTNL::Functions::experimental::MeshFunctionGnuplotWriter< MeshFunction, Meshes::Grid< 2, Real, Device, Index >, EntityDimension > | |
| CTNL::Functions::experimental::MeshFunctionGnuplotWriter< MeshFunction, Meshes::Grid< 3, Real, Device, Index >, EntityDimension > | |
| CTNL::Functions::experimental::MeshFunctionGnuplotWriter< MeshFunction, Mesh, EntitiesDimension > | |
| CTNL::Functions::experimental::MeshFunctionGnuplotWriter< MeshFunction, Meshes::Grid< 2, Real, Device, Index >, EntityDimension > | |
| CTNL::Functions::experimental::MeshFunctionGnuplotWriter< MeshFunction, Meshes::Grid< 3, Real, Device, Index >, EntityDimension > | |
| CTNL::Functions::experimental::MeshFunctionGnuplotWriterBase::center< Entity, dim > | |
| CTNL::Functions::experimental::MeshFunctionGnuplotWriterBase::center< Entity, 0 > | |
| CTNL::Functions::experimental::MeshFunctionGnuplotWriterBase::center< TNL::Meshes::MeshEntity< MeshConfig, Device, Topology >, 0 > | |
| CTNL::Functions::experimental::MeshFunctionGnuplotWriterBase::center< TNL::Meshes::MeshEntity< MeshConfig, Device, Topology >, dim > | |
| CTNL::Functions::experimental::MeshFunctionNormGetter< Mesh > | |
| CTNL::Functions::experimental::MeshFunctionNormGetter< Meshes::Grid< Dimension, MeshReal, Devices::Cuda, MeshIndex > > | |
| CTNL::Functions::experimental::MeshFunctionNormGetter< Meshes::Grid< Dimension, MeshReal, Devices::Host, MeshIndex > > | |
| CTNL::Functions::experimental::VectorFieldEvaluator< OutVectorField, InVectorField > | |
| CTNL::Functions::experimental::VectorFieldEvaluatorAdditionEntitiesProcessor< MeshType, UserData > | |
| CTNL::Functions::experimental::VectorFieldEvaluatorAssignmentEntitiesProcessor< MeshType, UserData > | |
| CTNL::Functions::experimental::VectorFieldEvaluatorTraverserUserData< OutVectorField, InVectorField, Real > | |
| CTNL::Functions::experimental::VectorFieldGnuplotWriter< VectorField > | |
| CTNL::Functions::experimental::VectorFieldGnuplotWriter< VectorField< VectorFieldSize, MeshFunction< Meshes::Grid< 1, MeshReal, Device, MeshIndex >, 0, Real > > > | |
| CTNL::Functions::experimental::VectorFieldGnuplotWriter< VectorField< VectorFieldSize, MeshFunction< Meshes::Grid< 1, MeshReal, Device, MeshIndex >, 1, Real > > > | |
| CTNL::Functions::experimental::VectorFieldGnuplotWriter< VectorField< VectorFieldSize, MeshFunction< Meshes::Grid< 2, MeshReal, Device, MeshIndex >, 0, Real > > > | |
| CTNL::Functions::experimental::VectorFieldGnuplotWriter< VectorField< VectorFieldSize, MeshFunction< Meshes::Grid< 2, MeshReal, Device, MeshIndex >, 1, Real > > > | |
| CTNL::Functions::experimental::VectorFieldGnuplotWriter< VectorField< VectorFieldSize, MeshFunction< Meshes::Grid< 2, MeshReal, Device, MeshIndex >, 2, Real > > > | |
| CTNL::Functions::experimental::VectorFieldGnuplotWriter< VectorField< VectorFieldSize, MeshFunction< Meshes::Grid< 3, MeshReal, Device, MeshIndex >, 0, Real > > > | |
| CTNL::Functions::experimental::VectorFieldGnuplotWriter< VectorField< VectorFieldSize, MeshFunction< Meshes::Grid< 3, MeshReal, Device, MeshIndex >, 2, Real > > > | |
| CTNL::Functions::experimental::VectorFieldGnuplotWriter< VectorField< VectorFieldSize, MeshFunction< Meshes::Grid< 3, MeshReal, Device, MeshIndex >, 3, Real > > > | |
| CTNL::GetValueType< T > | Get the underlying value type of T |
| CTNL::Graphs::Edge< Real, Index > | Represents a weighted edge in a graph |
| CTNL::Graphs::GraphBase< Value, Device, Index, Orientation, AdjacencyMatrixView_ > | Graph class represents a mathematical graph using an adjacency matrix |
| CTNL::Graphs::Graph< Value_, Device_, Index_, Orientation_, Segments_, AdjacencyMatrix_ > | |
| CTNL::Graphs::GraphView< Value, Device, Index, Orientation, AdjacencyMatrix > | |
| CTNL::Graphs::GraphView< Value, Device, Index, Orientation, AdjacencyMatrixView > | |
| CTNL::Graphs::GraphView< std::add_const_t< Value >, Device, Index, Orientation, ConstAdjacencyMatrixView > | |
| CTNL::Graphs::GraphView< Value_, Device_, Index_, Orientation_, AdjacencyMatrixView__ > | |
| CTNL::Graphs::GraphView< Value, Device, Index, Orientation, AdjacencyMatrixView_ > | View type for Graph class |
| CTNL::Graphs::GraphBase< Value, Device, Index, DirectedGraph, TNL::Matrices::SparseMatrix< Value, Device, Index, TNL::Matrices::GeneralMatrix, TNL::Algorithms::Segments::CSR >::ViewType > | |
| CTNL::Graphs::Graph< Value, Device, Index, Orientation, Segments, AdjacencyMatrix > | Graph class represents a mathematical graph using an adjacency matrix |
| CTNL::Graphs::GraphOrientation< Directed > | Template structure for specifying graph orientation (directed or undirected) |
| CTNL::Graphs::GraphOrientation< false > | |
| CTNL::Graphs::UndirectedGraph | Type tag for undirected graphs |
| CTNL::Graphs::GraphOrientation< true > | |
| CTNL::Graphs::DirectedGraph | Type tag for directed graphs |
| CTNL::Graphs::GraphVertexView< MatrixView, Orientation > | View type for accessing individual graph vertices and their edges |
| CTNL::Graphs::Readers::EdgeListReader< Graph > | Reader for graphs in edge list format |
| CTNL::Graphs::Readers::MtxReader< Graph > | Reader for graphs in Matrix Market format |
| CTNL::Graphs::Writers::EdgeListWriter< Graph > | Writer for graphs in edge list format |
| CTNL::HasAddAssignmentOperator< T > | Type trait for checking if T has operator+= taking one argument of type T |
| CTNL::HasConstexprGetSizeMethod< T > | Type trait for checking if T has a constexpr getSize method |
| CTNL::HasCountMember< T > | Type trait for checking if T has a count member |
| CTNL::HasGetArrayDataMethod< T > | Type trait for checking if T has a getArrayData method |
| CTNL::HasGetCommunicatorMethod< T > | Type trait for checking if T has a getCommunicator method |
| CTNL::HasGetSizeMethod< T > | Type trait for checking if T has a getSize method |
| CTNL::HasSetSizeMethod< T > | Type trait for checking if T has a setSize method |
| CTNL::HasSubscriptOperator< T > | Type trait for checking if T has operator[] taking one index argument |
| CTNL::Hypre | A simple RAII wrapper for Hypre's initialization and finalization |
| CTNL::IsViewType< T > | Type trait for checking if T is a view type |
| CTNL::Logger | Creates calculations log in the form of a table |
| CTNL::Matrices::DenseMatrixElement< Real, Index > | Accessor for dense matrix elements |
| CTNL::Matrices::DenseMatrixRowView< SegmentView, ValuesView > | RowView is a simple structure for accessing rows of dense matrix |
| CTNL::Matrices::DenseMatrixRowView< Matrices::DenseMatrixView< Real, Device, Index, Organization >::SegmentViewType, Matrices::DenseMatrixView< Real, Device, Index, Organization >::ValuesViewType > | |
| CTNL::Graphs::GraphVertexView< Matrices::DenseMatrixView< Real, Device, Index, Organization >, GraphType_ > | Specialization of GraphVertexView for dense adjacency matrices |
| CTNL::Matrices::DistributedMatrix< Matrix > | |
| CTNL::Matrices::HypreCSRMatrix | Wrapper for Hypre's sequential CSR matrix |
| CTNL::Matrices::HypreParCSRMatrix | Wrapper for Hypre's sequential CSR matrix |
| CTNL::Matrices::LambdaMatrix< MatrixElementsLambda, CompressedRowLengthsLambda, Real, Device, Index > | "Matrix-free matrix" based on lambda functions |
| CTNL::Matrices::LambdaMatrixElement< Real, Index > | Accessor for elements of lambda matrix |
| CTNL::Matrices::LambdaMatrixFactory< Real, Device, Index > | Helper class for creating instances of LambdaMatrix |
| CTNL::Matrices::LambdaMatrixRowView< MatrixElementsLambda, CompressedRowLengthsLambda, Real, Index > | RowView is a simple structure for accessing rows of Lambda matrix |
| CTNL::Matrices::LambdaMatrixRowViewIterator< RowView > | |
| CTNL::Matrices::MatrixBase< Real, Device, Index, MatrixType, Organization > | Base class for the implementation of concrete matrix types |
| CTNL::Matrices::SparseMatrixBase< Real, Device, Index, MatrixType, typename Segments< Device, Index, IndexAllocator >::ViewType, ComputeReal > | |
| CTNL::Matrices::SparseMatrixBase< Real, Device, Index, MatrixType, std::conditional_t< std::is_const_v< Real >, typename SegmentsView< Device, Index >::ConstViewType, SegmentsView< Device, Index > >, ComputeReal > | |
| CTNL::Matrices::MatrixBase< double, Devices::Host, int, GeneralMatrix, Algorithms::Segments::CSR< Devices::Host, int, typename Allocators::Default< Devices::Host >::template Allocator< int > >::ViewType::getOrganization() > | |
| CTNL::Matrices::SparseMatrixBase< double, Devices::Host, int, GeneralMatrix, Algorithms::Segments::CSR< Devices::Host, int, typename Allocators::Default< Devices::Host >::template Allocator< int > >::ViewType, std::conditional_t< std::is_same_v< double, bool >, int, double > > | |
| CTNL::Matrices::SparseMatrix< Real, Device, Index, MatrixType, Segments, ComputeReal, RealAllocator, IndexAllocator > | Implementation of sparse matrix, i.e. matrix storing only non-zero elements |
| CTNL::Matrices::MatrixBase< double, Devices::Host, int, GeneralMatrix, Organization > | |
| CTNL::Matrices::DenseMatrixBase< double, Devices::Host, int, Algorithms::Segments::DefaultElementsOrganization< Devices::Host >::getOrganization() > | |
| CTNL::Matrices::DenseMatrix< Real, Device, Index, Organization, RealAllocator > | Implementation of dense matrix, i.e. matrix storing explicitly all of its elements including zeros |
| CTNL::Matrices::DenseMatrixView< Real, Device, Index, Organization > | Implementation of dense matrix view |
| CTNL::Matrices::MultidiagonalMatrixBase< double, Devices::Host, int, Algorithms::Segments::DefaultElementsOrganization< Devices::Host >::getOrganization() > | |
| CTNL::Matrices::MultidiagonalMatrix< Real, Device, Index, Organization, RealAllocator, IndexAllocator > | Implementation of sparse multidiagonal matrix |
| CTNL::Matrices::MultidiagonalMatrixView< Real, Device, Index, Organization > | Implementation of sparse multidiagonal matrix |
| CTNL::Matrices::TridiagonalMatrixBase< double, Devices::Host, int, Algorithms::Segments::DefaultElementsOrganization< Devices::Host >::getOrganization() > | |
| CTNL::Matrices::TridiagonalMatrix< Real, Device, Index, Organization, RealAllocator > | Implementation of sparse tridiagonal matrix |
| CTNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization > | Implementation of sparse tridiagonal matrix |
| CTNL::Matrices::MatrixBase< GlobalIndexType, TNL::Devices::Host, int, GeneralMatrix, Organization > | |
| CTNL::Matrices::DenseMatrixBase< GlobalIndexType, TNL::Devices::Host, int, Algorithms::Segments::DefaultElementsOrganization< TNL::Devices::Host >::getOrganization() > | |
| CTNL::Matrices::DenseMatrix< GlobalIndexType, TNL::Devices::Host, int > | |
| CTNL::Matrices::MatrixBase< Real, Device, Index, GeneralMatrix, Organization > | |
| CTNL::Matrices::DenseMatrixBase< Real, Device, Index, Organization > | Implementation of dense matrix view |
| CTNL::Matrices::DenseMatrix< _Real, _Device, _Index, _Organization, _RealAllocator > | |
| CTNL::Matrices::DenseMatrix< RealType, Devices::Sequential, IndexType > | |
| CTNL::Matrices::DenseMatrixView< Real, Device, Index, Organization > | |
| CTNL::Matrices::DenseMatrixView< std::add_const_t< Real >, Device, Index, Organization > | |
| CTNL::Matrices::DenseMatrixView< _Real, _Device, _Index > | |
| CTNL::Matrices::MultidiagonalMatrixBase< Real, Device, Index, Organization > | A common base class for MultidiagonalMatrix and MultidiagonalMatrixView |
| CTNL::Matrices::MultidiagonalMatrix< _Real, _Device, _Index, _Organization, _RealAllocator, _IndexAllocator > | |
| CTNL::Matrices::MultidiagonalMatrixView< Real, Device, Index, Organization > | |
| CTNL::Matrices::MultidiagonalMatrixView< std::add_const_t< Real >, Device, Index, Organization > | |
| CTNL::Matrices::MultidiagonalMatrixView< _Real, _Device, _Index, Organization_ > | |
| CTNL::Matrices::TridiagonalMatrixBase< Real, Device, Index, Organization > | A common base class for TridiagonalMatrix and TridiagonalMatrixView |
| CTNL::Matrices::TridiagonalMatrix< _Real, _Device, _Index, _Organization, _RealAllocator > | |
| CTNL::Matrices::TridiagonalMatrixView< Real, Device, Index, Organization > | |
| CTNL::Matrices::TridiagonalMatrixView< std::add_const_t< Real >, Device, Index, Organization > | |
| CTNL::Matrices::TridiagonalMatrixView< _Real, _Device, _Index, Organization_ > | |
| CTNL::Matrices::MatrixBase< Real, Device, Index, MatrixType_, SegmentsView::getOrganization() > | |
| CTNL::Matrices::SparseMatrixBase< Real, Device, Index, MatrixType_, SegmentsView, ComputeReal > | Implementation of sparse matrix view |
| CTNL::Matrices::SparseMatrix< RealType, DeviceType, IndexType, GeneralMatrix, Algorithms::Segments::CSR > | |
| CTNL::Matrices::SparseMatrix< _Real, _Device, _Index, _MatrixType, _Segments, _ComputeReal, _RealAllocator, _IndexAllocator > | |
| CTNL::Matrices::SparseMatrix< RealType, DeviceType, IndexType, Matrices::GeneralMatrix, Algorithms::Segments::CSR > | |
| CTNL::Matrices::SparseMatrixView< Real, Device, Index, MatrixType_, SegmentsView, ComputeRealType > | |
| CTNL::Matrices::SparseMatrixView< Real, Device, Index, MatrixType_, SegmentsView, ComputeReal > | |
| CTNL::Matrices::SparseMatrixView< const Real, Device, Index, MatrixType_, SegmentsView, ComputeReal > | |
| CTNL::Matrices::SparseMatrixView< Real, Device, Index, MatrixType, Segments< Device, Index, IndexAllocator >::template ViewTemplate, ComputeReal > | |
| CTNL::Matrices::SparseMatrixView< std::add_const_t< Real >, Device, Index, MatrixType, Segments< Device, Index, IndexAllocator >::template ViewTemplate, ComputeReal > | |
| CTNL::Matrices::SparseMatrixView< _Real, _Device, _Index, _MatrixType, _SegmentsView, _ComputeReal > | |
| CTNL::Matrices::SparseMatrixView< Real, Device, Index, MatrixType, SegmentsView, ComputeReal > | |
| CTNL::Matrices::SparseMatrixView< std::add_const_t< Real >, Device, Index, MatrixType, SegmentsView, ComputeReal > | |
| CTNL::Matrices::MatrixBase< Real, Devices::Host, int, GeneralMatrix, std::conditional_t< std::is_const_v< Real >, Algorithms::Segments::CSRView< Devices::Host, int >::ConstViewType, Algorithms::Segments::CSRView< Devices::Host, int > >::getOrganization() > | |
| CTNL::Matrices::SparseMatrixBase< Real, Devices::Host, int, GeneralMatrix, std::conditional_t< std::is_const_v< Real >, Algorithms::Segments::CSRView< Devices::Host, int >::ConstViewType, Algorithms::Segments::CSRView< Devices::Host, int > >, std::conditional_t< std::is_same_v< Real, bool >, int, Real > > | |
| CTNL::Matrices::SparseMatrixView< Real, Device, Index, MatrixType, SegmentsView, ComputeReal > | Implementation of sparse matrix view |
| CTNL::Matrices::MatrixBase< RealType, TNL::Devices::Host, IndexType, TNL::Matrices::GeneralMatrix, Segments< TNL::Devices::Host, IndexType, typename Allocators::Default< TNL::Devices::Host >::template Allocator< IndexType > >::ViewType::getOrganization() > | |
| CTNL::Matrices::SparseMatrixBase< RealType, TNL::Devices::Host, IndexType, TNL::Matrices::GeneralMatrix, Segments< TNL::Devices::Host, IndexType, typename Allocators::Default< TNL::Devices::Host >::template Allocator< IndexType > >::ViewType, std::conditional_t< std::is_same_v< RealType, bool >, IndexType, RealType > > | |
| CTNL::Matrices::SparseMatrix< RealType, TNL::Devices::Host, IndexType, TNL::Matrices::GeneralMatrix, TNL::Algorithms::Segments::CSR > | |
| CTNL::Matrices::MatrixBase< Value, Device, Index, TNL::Matrices::GeneralMatrix, Segments< Device, Index, typename Allocators::Default< Device >::template Allocator< Index > >::ViewType::getOrganization() > | |
| CTNL::Matrices::SparseMatrixBase< Value, Device, Index, TNL::Matrices::GeneralMatrix, Segments< Device, Index, typename Allocators::Default< Device >::template Allocator< Index > >::ViewType, std::conditional_t< std::is_same_v< Value, bool >, Index, Value > > | |
| CTNL::Matrices::SparseMatrix< Value, Device, Index, TNL::Matrices::GeneralMatrix, TNL::Algorithms::Segments::CSR > | |
| CTNL::Matrices::MatrixInfo< Matrix > | |
| CTNL::Matrices::MatrixOperations< DeviceType > | |
| CTNL::Matrices::MatrixOperations< Devices::Cuda > | |
| CTNL::Matrices::MatrixReader< Matrix, Device > | Helper class for importing of matrices from different input formats |
| CTNL::Matrices::MatrixRowViewIterator< RowView > | |
| CTNL::Matrices::MatrixType< Symmetric > | Structure for specifying type of sparse matrix |
| CTNL::Matrices::MatrixType< false > | |
| CTNL::Matrices::GeneralMatrix | General non-symmetric matrix type |
| CTNL::Matrices::MatrixType< true > | |
| CTNL::Matrices::SymmetricMatrix | Symmetric matrix type |
| CTNL::Matrices::MatrixWriter< Matrix, Device > | Helper class for exporting of matrices to different output formats |
| CTNL::Matrices::MultidiagonalMatrixElement< Real, Index > | Accessor for multidiagonal matrix elements |
| CTNL::Matrices::MultidiagonalMatrixRowView< ValuesView, Indexer, DiagonalsOffsetsView_ > | RowView is a simple structure for accessing rows of multidiagonal matrix |
| CTNL::Matrices::SparseMatrixElement< Real, Index > | Accessor for sparse matrix elements |
| CTNL::Matrices::SparseMatrixRowView< SegmentView, ValuesView, ColumnsIndexesView > | RowView is a simple structure for accessing rows of sparse matrix |
| CTNL::Matrices::SparseMatrixRowView< Matrices::SparseMatrixView< Real, Device, Index, MatrixType_, SegmentsView, ComputeRealType >::SegmentsViewType::SegmentViewType, Matrices::SparseMatrixView< Real, Device, Index, MatrixType_, SegmentsView, ComputeRealType >::ValuesViewType, Matrices::SparseMatrixView< Real, Device, Index, MatrixType_, SegmentsView, ComputeRealType >::ColumnIndexesViewType > | |
| CTNL::Graphs::GraphVertexView< Matrices::SparseMatrixView< Real, Device, Index, MatrixType_, SegmentsView, ComputeRealType >, GraphType_ > | Specialization of GraphVertexView for sparse adjacency matrices |
| CTNL::Matrices::TridiagonalMatrixRowView< ValuesView, Indexer > | RowView is a simple structure for accessing rows of tridiagonal matrix |
| CTNL::Max | Function object implementing max(x, y) |
| CTNL::MaxWithArg | Function object implementing argmax(x, y, i, j), i.e. returning the maximum value and its index |
| CTNL::Meshes::BoundaryGridEntityChecker< class > | |
| CTNL::Meshes::BuildConfigTags::GridDeviceTag< ConfigTag, Device > | |
| CTNL::Meshes::BuildConfigTags::GridDeviceTag< ConfigTag, Devices::Cuda > | |
| CTNL::Meshes::BuildConfigTags::GridDeviceTag< ConfigTag, Devices::Host > | |
| CTNL::Meshes::BuildConfigTags::GridDimensionTag< ConfigTag, Dimension > | |
| CTNL::Meshes::BuildConfigTags::GridIndexTag< ConfigTag, Index > | |
| CTNL::Meshes::BuildConfigTags::GridIndexTag< ConfigTag, int > | |
| CTNL::Meshes::BuildConfigTags::GridIndexTag< ConfigTag, long int > | |
| CTNL::Meshes::BuildConfigTags::GridRealTag< ConfigTag, Real > | |
| CTNL::Meshes::BuildConfigTags::GridRealTag< ConfigTag, double > | |
| CTNL::Meshes::BuildConfigTags::GridRealTag< ConfigTag, float > | |
| CTNL::Meshes::BuildConfigTags::GridTag< ConfigTag, MeshType > | |
| CTNL::Meshes::BuildConfigTags::GridTag< ConfigTag, Grid< Dimension, Real, Device, Index > > | |
| CTNL::Meshes::BuildConfigTags::MeshCellTopologyTag< ConfigTag, CellTopology > | |
| CTNL::Meshes::BuildConfigTags::MeshConfigTemplateTag< ConfigTag > | |
| CTNL::Meshes::BuildConfigTags::MeshDeviceTag< ConfigTag, Device > | |
| CTNL::Meshes::BuildConfigTags::MeshDeviceTag< ConfigTag, Devices::Cuda > | |
| CTNL::Meshes::BuildConfigTags::MeshDeviceTag< ConfigTag, Devices::Host > | |
| CTNL::Meshes::BuildConfigTags::MeshGlobalIndexTag< ConfigTag, GlobalIndex > | |
| CTNL::Meshes::BuildConfigTags::MeshGlobalIndexTag< ConfigTag, int > | |
| CTNL::Meshes::BuildConfigTags::MeshGlobalIndexTag< ConfigTag, long int > | |
| CTNL::Meshes::BuildConfigTags::MeshLocalIndexTag< ConfigTag, LocalIndex > | |
| CTNL::Meshes::BuildConfigTags::MeshLocalIndexTag< ConfigTag, short int > | |
| CTNL::Meshes::BuildConfigTags::MeshRealTag< ConfigTag, Real > | |
| CTNL::Meshes::BuildConfigTags::MeshRealTag< ConfigTag, double > | |
| CTNL::Meshes::BuildConfigTags::MeshRealTag< ConfigTag, float > | |
| CTNL::Meshes::BuildConfigTags::MeshSpaceDimensionTag< ConfigTag, CellTopology, SpaceDimension > | |
| CTNL::Meshes::BuildConfigTags::MeshTag< ConfigTag, Device, CellTopology, SpaceDimension, Real, GlobalIndex, LocalIndex > | |
| CTNL::Meshes::CuthillMcKeeOrdering< reverse > | |
| CTNL::Meshes::DefaultConfig< Cell, SpaceDimension, Real, GlobalIndex, LocalIndex > | |
| CTNL::Meshes::DimensionTag< Dimension > | |
| CTNL::Meshes::DimensionTag< 0 > | |
| CTNL::Meshes::DistributedMeshes::BufferEntitiesHelper< MeshFunctionType, PeriodicBoundariesMaskPointer, dim, RealType, Device, Index > | |
| CTNL::Meshes::DistributedMeshes::BufferEntitiesHelper< MeshFunctionType, MaskPointer, 1, RealType, Device, Index > | |
| CTNL::Meshes::DistributedMeshes::BufferEntitiesHelper< MeshFunctionType, MaskPointer, 2, RealType, Device, Index > | |
| CTNL::Meshes::DistributedMeshes::BufferEntitiesHelper< MeshFunctionType, MaskPointer, 3, RealType, Device, Index > | |
| CTNL::Meshes::DistributedMeshes::CopyEntitiesHelper< MeshFunctionType, dim > | |
| CTNL::Meshes::DistributedMeshes::CopyEntitiesHelper< MeshFunctionType, 1 > | |
| CTNL::Meshes::DistributedMeshes::CopyEntitiesHelper< MeshFunctionType, 2 > | |
| CTNL::Meshes::DistributedMeshes::CopyEntitiesHelper< MeshFunctionType, 3 > | |
| CTNL::Meshes::DistributedMeshes::Directions | |
| CTNL::Meshes::DistributedMeshes::GlobalIndexStorage< Mesh, Device, Dimension > | |
| CTNL::Meshes::DistributedMeshes::GlobalIndexStorageFamily< Mesh, Device, DimensionTag > | |
| CTNL::Meshes::DistributedMeshes::DistributedMesh< Grid< MeshDimension, GridReal, Device, Index > > | |
| CTNL::Meshes::DistributedMeshes::DistributedMesh< MeshType > | |
| CTNL::Meshes::DistributedMeshes::DistributedMesh< Grid< Dimension, Real, Device, Index > > | |
| CTNL::Meshes::DistributedMeshes::DistributedMesh< Mesh > | |
| CTNL::Meshes::DistributedMeshes::GlobalIndexStorageFamily< Mesh, Device, Meshes::DimensionTag< Mesh::getMeshDimension()+1 > > | |
| CTNL::Meshes::DistributedMeshes::SubdomainOverlapsGetter< Mesh > | |
| CTNL::Meshes::DistributedMeshes::SubdomainOverlapsGetter< Grid< 1, Real, Device, Index > > | |
| CTNL::Meshes::DistributedMeshes::SubdomainOverlapsGetter< Grid< 2, Real, Device, Index > > | |
| CTNL::Meshes::DistributedMeshes::SubdomainOverlapsGetter< Grid< 3, Real, Device, Index > > | |
| CTNL::Meshes::DummyMesh< Real, Device, Index > | |
| CTNL::Meshes::EntityDecomposer< MeshConfig, Topology, EntityDecomposerVersion_, SubentityDecomposerVersion > | |
| CTNL::Meshes::EntityDecomposer< MeshConfig, Topologies::Polygon, EntityDecomposerVersion::ConnectEdgesToCentroid, SubentityDecomposerVersion > | |
| CTNL::Meshes::EntityDecomposer< MeshConfig, Topologies::Polygon, EntityDecomposerVersion::ConnectEdgesToPoint, SubentityDecomposerVersion > | |
| CTNL::Meshes::EntityDecomposer< MeshConfig, Topologies::Polyhedron, EntityDecomposerVersion::ConnectEdgesToCentroid, SubentityDecomposerVersion > | |
| CTNL::Meshes::EntityDecomposer< MeshConfig, Topologies::Polyhedron, EntityDecomposerVersion::ConnectEdgesToPoint, SubentityDecomposerVersion > | |
| CTNL::Meshes::EntityRefiner< MeshConfig, Topology, EntityRefinerVersion_ > | |
| CTNL::Meshes::EntityRefiner< MeshConfig, Topologies::Hexahedron, EntityRefinerVersion::EdgeBisection > | |
| CTNL::Meshes::EntityRefiner< MeshConfig, Topologies::Quadrangle, EntityRefinerVersion::EdgeBisection > | |
| CTNL::Meshes::EntityRefiner< MeshConfig, Topologies::Tetrahedron, EntityRefinerVersion::EdgeBisection > | |
| CTNL::Meshes::EntityRefiner< MeshConfig, Topologies::Triangle, EntityRefinerVersion::EdgeBisection > | |
| CTNL::Meshes::EntityStorageRebinder< Mesh > | |
| CTNL::Meshes::Grid< Dimension, Real, Device, Index > | Orthogonal n-dimensional grid |
| CTNL::Meshes::GridEntity< Grid, EntityDimension > | Structure describing a grid entity i.e., grid cells, faces, edges, vertices and so on |
| CTNL::Meshes::GridEntityCenterGetter< class > | |
| CTNL::Meshes::GridTypeResolver< ConfigTag, Device > | |
| CTNL::Meshes::GridTypeResolver< ConfigTag, Device >::detail< Reader, Functor > | |
| CTNL::Meshes::IndexPermutationApplier< Mesh, Dimension > | |
| CTNL::Meshes::Initializer< MeshConfig > | |
| CTNL::Meshes::MeshBuilder< Mesh > | |
| CTNL::Meshes::MeshEntity< MeshConfig, Device, EntityTopology_ > | |
| CTNL::Meshes::MeshInitializableBase< MeshConfig, Device, MeshType > | |
| CTNL::Meshes::Mesh< MeshConfig, Device > | |
| CTNL::Meshes::MeshInitializableBase< MeshConfig, Devices::Cuda, MeshType > | |
| CTNL::Meshes::MeshInitializableBase< MeshConfig, Devices::Host, Mesh< MeshConfig, Devices::Host > > | |
| CTNL::Meshes::Mesh< MeshConfig, Device > | |
| CTNL::Meshes::MeshOrdering< Mesh, Ordering > | |
| CTNL::Meshes::MeshOrdering< TNL::Meshes::Mesh< MeshConfig, Device >, Ordering > | |
| CTNL::Meshes::MeshTypeResolver< ConfigTag, Device > | |
| CTNL::Meshes::MeshTypeResolver< ConfigTag, Device >::detail< Reader, Functor > | |
| CTNL::Meshes::NDMetaGrid< Dimension, Real, Index > | Minimal class usable as Mesh in the Writers::VTIWriter |
| CTNL::Meshes::NeighbourGridEntityGetter< int, int, int > | |
| CTNL::Meshes::Readers::MeshReader | |
| CTNL::Meshes::Readers::FPMAReader | |
| CTNL::Meshes::Readers::NetgenReader | |
| CTNL::Meshes::Readers::VTKReader | |
| CTNL::Meshes::Readers::XMLVTK | |
| CTNL::Meshes::Readers::PVTIReader | |
| CTNL::Meshes::Readers::PVTUReader | |
| CTNL::Meshes::Readers::VTIReader | |
| CTNL::Meshes::Readers::VTUReader | |
| CTNL::Meshes::Topologies::Edge | |
| CTNL::Meshes::Topologies::Hexahedron | |
| CTNL::Meshes::Topologies::IsDynamicTopology< Topology, D > | Type trait for checking if Topology has at least one missing Subtopology< Topology, D > >count for all D from Topology::dimension - 1 to 0 |
| CTNL::Meshes::Topologies::IsDynamicTopology< Topology, 1 > | Specialization for D = 1 to end recursion |
| CTNL::Meshes::Topologies::NumCombinations< n, k > | |
| CTNL::Meshes::Topologies::Polygon | |
| CTNL::Meshes::Topologies::Polyhedron | |
| CTNL::Meshes::Topologies::Pyramid | |
| CTNL::Meshes::Topologies::Quadrangle | |
| CTNL::Meshes::Topologies::Simplex< dimension_ > | |
| CTNL::Meshes::Topologies::SimplexDetails::CombinationIncrement< n, k, combinationIndex > | |
| CTNL::Meshes::Topologies::SimplexDetails::CombinationIncrementImpl< n, k, combinationIndex, valueIndex_ > | |
| CTNL::Meshes::Topologies::SimplexDetails::CombinationIncrementImpl< n, k, combinationIndex, 0 > | |
| CTNL::Meshes::Topologies::SimplexDetails::CombinationValue< n, k, combinationIndex, valueIndex > | |
| CTNL::Meshes::Topologies::SimplexDetails::CombinationValue< n, k, 0, valueIndex > | |
| CTNL::Meshes::Topologies::SimplexDetails::NumCombinations< n, k > | |
| CTNL::Meshes::Topologies::SimplexDetails::NumCombinations< n, 0 > | |
| CTNL::Meshes::Topologies::SimplexDetails::NumCombinations< n, n > | |
| CTNL::Meshes::Topologies::SubentityVertexCount< EntityTopology, SubentityTopology, SubentityIndex > | |
| CTNL::Meshes::Topologies::SubentityVertexCount< Pyramid, Polygon, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexCount< Pyramid, Polygon, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexCount< Pyramid, Polygon, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexCount< Pyramid, Polygon, 3 > | |
| CTNL::Meshes::Topologies::SubentityVertexCount< Pyramid, Polygon, 4 > | |
| CTNL::Meshes::Topologies::SubentityVertexCount< Wedge, Polygon, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexCount< Wedge, Polygon, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexCount< Wedge, Polygon, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexCount< Wedge, Polygon, 3 > | |
| CTNL::Meshes::Topologies::SubentityVertexCount< Wedge, Polygon, 4 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< EntityTopology, SubentityTopology, SubentityIndex, SubentityVertexIndex > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 0, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 0, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 1, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 1, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 10, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 10, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 11, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 11, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 2, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 2, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 3, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 3, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 4, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 4, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 5, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 5, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 6, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 6, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 7, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 7, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 8, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 8, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 9, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Edge, 9, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 0, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 0, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 0, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 0, 3 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 1, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 1, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 1, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 1, 3 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 2, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 2, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 2, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 2, 3 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 3, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 3, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 3, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 3, 3 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 4, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 4, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 4, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 4, 3 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 5, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 5, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 5, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Hexahedron, Quadrangle, 5, 3 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Edge, 0, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Edge, 0, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Edge, 1, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Edge, 1, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Edge, 2, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Edge, 2, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Edge, 3, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Edge, 3, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Edge, 4, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Edge, 4, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Edge, 5, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Edge, 5, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Edge, 6, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Edge, 6, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Edge, 7, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Edge, 7, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Polygon, 0, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Polygon, 0, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Polygon, 0, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Polygon, 0, 3 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Polygon, 1, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Polygon, 1, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Polygon, 1, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Polygon, 2, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Polygon, 2, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Polygon, 2, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Polygon, 3, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Polygon, 3, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Polygon, 3, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Polygon, 4, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Polygon, 4, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Pyramid, Polygon, 4, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Quadrangle, Edge, 0, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Quadrangle, Edge, 0, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Quadrangle, Edge, 1, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Quadrangle, Edge, 1, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Quadrangle, Edge, 2, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Quadrangle, Edge, 2, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Quadrangle, Edge, 3, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Quadrangle, Edge, 3, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Simplex< dimension >, Subtopology, subtopologyIndex, vertexIndex > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Edge, 0, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Edge, 0, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Edge, 1, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Edge, 1, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Edge, 2, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Edge, 2, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Edge, 3, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Edge, 3, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Edge, 4, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Edge, 4, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Edge, 5, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Edge, 5, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Triangle, 0, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Triangle, 0, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Triangle, 0, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Triangle, 1, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Triangle, 1, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Triangle, 1, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Triangle, 2, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Triangle, 2, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Triangle, 2, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Triangle, 3, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Triangle, 3, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Tetrahedron, Triangle, 3, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Triangle, Edge, 0, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Triangle, Edge, 0, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Triangle, Edge, 1, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Triangle, Edge, 1, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Triangle, Edge, 2, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Triangle, Edge, 2, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Edge, 0, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Edge, 0, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Edge, 1, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Edge, 1, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Edge, 2, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Edge, 2, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Edge, 3, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Edge, 3, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Edge, 4, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Edge, 4, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Edge, 5, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Edge, 5, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Edge, 6, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Edge, 6, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Edge, 7, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Edge, 7, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Edge, 8, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Edge, 8, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Polygon, 0, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Polygon, 0, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Polygon, 0, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Polygon, 1, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Polygon, 1, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Polygon, 1, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Polygon, 2, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Polygon, 2, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Polygon, 2, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Polygon, 2, 3 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Polygon, 3, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Polygon, 3, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Polygon, 3, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Polygon, 3, 3 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Polygon, 4, 0 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Polygon, 4, 1 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Polygon, 4, 2 > | |
| CTNL::Meshes::Topologies::SubentityVertexMap< Wedge, Polygon, 4, 3 > | |
| CTNL::Meshes::Topologies::Subtopology< EntityTopology, SubentityDimension > | |
| CTNL::Meshes::Topologies::Subtopology< Edge, 0 > | |
| CTNL::Meshes::Topologies::Subtopology< Hexahedron, 0 > | |
| CTNL::Meshes::Topologies::Subtopology< Hexahedron, 1 > | |
| CTNL::Meshes::Topologies::Subtopology< Hexahedron, 2 > | |
| CTNL::Meshes::Topologies::Subtopology< Polygon, 0 > | |
| CTNL::Meshes::Topologies::Subtopology< Polygon, 1 > | |
| CTNL::Meshes::Topologies::Subtopology< Polyhedron, 0 > | |
| CTNL::Meshes::Topologies::Subtopology< Polyhedron, 1 > | |
| CTNL::Meshes::Topologies::Subtopology< Polyhedron, 2 > | |
| CTNL::Meshes::Topologies::Subtopology< Pyramid, 0 > | |
| CTNL::Meshes::Topologies::Subtopology< Pyramid, 1 > | |
| CTNL::Meshes::Topologies::Subtopology< Pyramid, 2 > | |
| CTNL::Meshes::Topologies::Subtopology< Quadrangle, 0 > | |
| CTNL::Meshes::Topologies::Subtopology< Quadrangle, 1 > | |
| CTNL::Meshes::Topologies::Subtopology< Simplex< dimension >, 0 > | |
| CTNL::Meshes::Topologies::Subtopology< Simplex< dimension >, subtopologyDim > | |
| CTNL::Meshes::Topologies::Subtopology< Tetrahedron, 0 > | |
| CTNL::Meshes::Topologies::Subtopology< Tetrahedron, 1 > | |
| CTNL::Meshes::Topologies::Subtopology< Tetrahedron, 2 > | |
| CTNL::Meshes::Topologies::Subtopology< Triangle, 0 > | |
| CTNL::Meshes::Topologies::Subtopology< Triangle, 1 > | |
| CTNL::Meshes::Topologies::Subtopology< Wedge, 0 > | |
| CTNL::Meshes::Topologies::Subtopology< Wedge, 1 > | |
| CTNL::Meshes::Topologies::Subtopology< Wedge, 2 > | |
| CTNL::Meshes::Topologies::Tetrahedron | |
| CTNL::Meshes::Topologies::Triangle | |
| CTNL::Meshes::Topologies::Vertex | |
| CTNL::Meshes::Topologies::Wedge | |
| CTNL::Meshes::VTK::EntityShapeGroup< GeneralShape > | |
| CTNL::Meshes::VTK::EntityShapeGroup< EntityShape::Polygon > | |
| CTNL::Meshes::VTK::EntityShapeGroup< EntityShape::Polyhedron > | |
| CTNL::Meshes::VTK::EntityShapeGroupChecker< GeneralShape_ > | |
| CTNL::Meshes::VTK::EntityShapeGroupElement< GeneralShape, index > | |
| CTNL::Meshes::VTK::EntityShapeGroupElement< EntityShape::Polygon, 0 > | |
| CTNL::Meshes::VTK::EntityShapeGroupElement< EntityShape::Polygon, 1 > | |
| CTNL::Meshes::VTK::EntityShapeGroupElement< EntityShape::Polyhedron, 0 > | |
| CTNL::Meshes::VTK::EntityShapeGroupElement< EntityShape::Polyhedron, 1 > | |
| CTNL::Meshes::VTK::EntityShapeGroupElement< EntityShape::Polyhedron, 2 > | |
| CTNL::Meshes::VTK::EntityShapeGroupElement< EntityShape::Polyhedron, 3 > | |
| CTNL::Meshes::VTK::EntityShapeGroupElement< EntityShape::Polyhedron, 4 > | |
| CTNL::Meshes::VTK::EntityShapeGroupElement< EntityShape::Polyhedron, 5 > | |
| CTNL::Meshes::VTK::GridEntityShape< GridEntity > | |
| CTNL::Meshes::VTK::TopologyToEntityShape< Topology > | |
| CTNL::Meshes::VTK::TopologyToEntityShape< Topologies::Edge > | |
| CTNL::Meshes::VTK::TopologyToEntityShape< Topologies::Hexahedron > | |
| CTNL::Meshes::VTK::TopologyToEntityShape< Topologies::Polygon > | |
| CTNL::Meshes::VTK::TopologyToEntityShape< Topologies::Polyhedron > | |
| CTNL::Meshes::VTK::TopologyToEntityShape< Topologies::Pyramid > | |
| CTNL::Meshes::VTK::TopologyToEntityShape< Topologies::Quadrangle > | |
| CTNL::Meshes::VTK::TopologyToEntityShape< Topologies::Tetrahedron > | |
| CTNL::Meshes::VTK::TopologyToEntityShape< Topologies::Triangle > | |
| CTNL::Meshes::VTK::TopologyToEntityShape< Topologies::Vertex > | |
| CTNL::Meshes::VTK::TopologyToEntityShape< Topologies::Wedge > | |
| CTNL::Meshes::Writers::AsymptoteWriter< Mesh > | |
| CTNL::Meshes::Writers::AsymptoteWriter< Grid< 2, Real, Device, Index > > | |
| CTNL::Meshes::Writers::details::MeshEntitiesFPMAWriter< Mesh, EntityDimension, SubDimension > | |
| CTNL::Meshes::Writers::FPMAWriter< Mesh > | |
| CTNL::Meshes::Writers::GnuplotWriter< Mesh > | Writer of data linked with meshes into Gnuplot format |
| CTNL::Meshes::Writers::NetgenWriter< Mesh > | |
| CTNL::Meshes::Writers::PVTIWriter< Grid > | |
| CTNL::Meshes::Writers::PVTUWriter< Mesh > | |
| CTNL::Meshes::Writers::VTIWriter< Mesh > | Writer of data linked with meshes into VTI format |
| CTNL::Meshes::Writers::VTKWriter< Mesh > | Writer of data linked with meshes into VTK format |
| CTNL::Meshes::Writers::VTUWriter< Mesh > | |
| CTNL::Min | Function object implementing min(x, y) |
| CTNL::MinWithArg | Function object implementing argmin(x, y, i, j), i.e. returning the minimum value and its index |
| CTNL::MPI::Comm | An RAII wrapper for custom MPI communicators |
| CTNL::MPI::ScopedInitializer | |
| CTNL::MPI::TypeResolver< T > | |
| CTNL::MPI::TypeResolver< bool > | |
| CTNL::MPI::TypeResolver< char > | |
| CTNL::MPI::TypeResolver< double > | |
| CTNL::MPI::TypeResolver< float > | |
| CTNL::MPI::TypeResolver< int > | |
| CTNL::MPI::TypeResolver< long double > | |
| CTNL::MPI::TypeResolver< long int > | |
| CTNL::MPI::TypeResolver< short int > | |
| CTNL::MPI::TypeResolver< unsigned char > | |
| CTNL::MPI::TypeResolver< unsigned int > | |
| CTNL::MPI::TypeResolver< unsigned long int > | |
| CTNL::MPI::TypeResolver< unsigned short int > | |
| CTNL::PerformanceCounters | Performance counter for measuring CPU cycles |
| CTNL::Pointers::DevicePointer< Object, Device > | The DevicePointer is like SharedPointer, except it takes an existing host object - there is no call to the ObjectType's constructor nor destructor |
| CTNL::Pointers::DevicePointer< Object, Devices::Cuda >::PointerData | |
| CTNL::Pointers::SharedPointer< Object, Device > | Cross-device shared smart pointer |
| CTNL::Pointers::SharedPointer< Object, Devices::Cuda >::PointerData | |
| CTNL::Pointers::SharedPointer< Object, Devices::Host >::PointerData | |
| CTNL::Pointers::SmartPointer | |
| CTNL::Pointers::DevicePointer< Object, Devices::Cuda > | Specialization of the DevicePointer for the CUDA device |
| CTNL::Pointers::DevicePointer< Object, Devices::Host > | Specialization of the DevicePointer for the host system |
| CTNL::Pointers::SharedPointer< Object, Devices::Cuda > | Specialization of the SharedPointer for the CUDA device |
| CTNL::Pointers::SharedPointer< Object, Devices::Host > | Specialization of the SharedPointer for the host system |
| CTNL::Pointers::UniquePointer< Object, Devices::Cuda > | Specialization of the UniquePointer for the CUDA device |
| CTNL::Pointers::UniquePointer< Object, Devices::Host > | Specialization of the UniquePointer for the host system |
| CTNL::Pointers::SmartPointersRegister | |
| CTNL::Pointers::UniquePointer< Object, Device > | Cross-device unique smart pointer |
| CTNL::Pointers::UniquePointer< Object, Devices::Cuda >::PointerData | |
| CTNL::Solvers::IterativeSolver< Real, Index, SolverMonitor > | Base class for iterative solvers |
| CTNL::Solvers::IterativeSolver< double, int, IterativeSolverMonitor< double > > | |
| CTNL::Solvers::ODE::ExplicitSolver< Real, Index, SolverMonitor > | Base class for ODE solvers |
| CTNL::Solvers::IterativeSolver< Matrix::RealType, Matrix::IndexType > | |
| CTNL::Solvers::Linear::LinearSolver< Matrix > | Base class for iterative solvers of systems of linear equations |
| CTNL::Solvers::Linear::BICGStab< Matrix > | Iterative solver of linear systems based on the biconjugate gradient stabilized (BICGStab) method |
| CTNL::Solvers::Linear::BICGStabL< Matrix > | Iterative solver of linear systems based on the BICGStab(l) method |
| CTNL::Solvers::Linear::CG< Matrix > | Iterative solver of linear systems based on the conjugate gradient method |
| CTNL::Solvers::Linear::CuDSSWrapper< Matrix > | |
| CTNL::Solvers::Linear::CuSolverWrapper< Matrix > | |
| CTNL::Solvers::Linear::GEM< Matrix > | Gaussian Elimination Method (GEM) direct solver for dense linear systems |
| CTNL::Solvers::Linear::GMRES< Matrix > | Iterative solver of linear systems based on the Generalized minimal residual (GMRES) method |
| CTNL::Solvers::Linear::GinkgoDirectSolver< Matrix > | |
| CTNL::Solvers::Linear::IDRs< Matrix > | Iterative solver of linear systems based on the IDR(s) method |
| CTNL::Solvers::Linear::Jacobi< Matrix > | Iterative solver of linear systems based on the Jacobi method |
| CTNL::Solvers::Linear::SOR< Matrix > | Iterative solver of linear systems based on the Successive-overrelaxation (SOR) or Gauss-Seidel method |
| CTNL::Solvers::Linear::TFQMR< Matrix > | Iterative solver of linear systems based on the Transpose-free quasi-minimal residual (TFQMR) method |
| CTNL::Solvers::Linear::UmfpackWrapper< Matrix, SolverMonitor > | |
| CTNL::Solvers::IterativeSolver< Vector::RealType, Vector::IndexType, IterativeSolverMonitor< typename Vector::RealType > > | |
| CTNL::Solvers::Optimization::AdaGrad< Vector, SolverMonitor > | |
| CTNL::Solvers::Optimization::GradientDescent< Vector, SolverMonitor > | |
| CTNL::Solvers::Optimization::Momentum< Vector, SolverMonitor > | |
| CTNL::Solvers::Optimization::NesterovMomentum< Vector, SolverMonitor > | |
| CTNL::Solvers::Optimization::RMSProp< Vector, SolverMonitor > | |
| CTNL::Solvers::IterativeSolver< Vector::RealType, Vector::IndexType, SolverMonitor > | |
| CTNL::Solvers::ODE::ExplicitSolver< Vector::RealType, Vector::IndexType, SolverMonitor > | |
| CTNL::Solvers::ODE::ODESolver< Method, Vector, SolverMonitor, false > | |
| CTNL::Solvers::Linear::HypreSolver | Abstract class for Hypre's solvers and preconditioners |
| CTNL::Solvers::Linear::HypreBiCGSTAB | Wrapper for the BiCGSTAB solver in Hypre |
| CTNL::Solvers::Linear::HypreBoomerAMG | Wrapper for the BoomerAMG solver/preconditioner in Hypre |
| CTNL::Solvers::Linear::HypreDiagScale | Wrapper for the Jacobi preconditioner in Hypre |
| CTNL::Solvers::Linear::HypreEuclid | Wrapper for the Euclid preconditioner in Hypre |
| CTNL::Solvers::Linear::HypreFlexGMRES | Wrapper for the Flexible GMRES solver in Hypre |
| CTNL::Solvers::Linear::HypreGMRES | Wrapper for the GMRES solver in Hypre |
| CTNL::Solvers::Linear::HypreILU | Wrapper for Hypre's native parallel ILU preconditioner |
| CTNL::Solvers::Linear::HypreIdentity | Wrapper for the identity operator as a Hypre solver |
| CTNL::Solvers::Linear::HyprePCG | Wrapper for the PCG solver in Hypre |
| CTNL::Solvers::Linear::HypreParaSails | Wrapper for the ParaSails preconditioner in Hypre |
| CTNL::Solvers::Linear::HypreTriSolve | Wrapper for Hypre's preconditioner that is intended for matrices that are triangular in some ordering |
| CTNL::Solvers::Linear::LinearResidueGetter | |
| CTNL::Solvers::Linear::Preconditioners::ILU0_impl< Matrix, Real, Device, Index > | |
| CTNL::Solvers::Linear::Preconditioners::ILU0_impl< Matrix, Matrix::RealType, Matrix::DeviceType, Matrix::IndexType > | |
| CTNL::Solvers::Linear::Preconditioners::ILU0< Matrix > | Implementation of a preconditioner based on Incomplete LU |
| CTNL::Solvers::Linear::Preconditioners::ILUT_impl< Matrix, Real, Device, Index > | |
| CTNL::Solvers::Linear::Preconditioners::ILUT_impl< Matrix, Matrix::RealType, Matrix::DeviceType, Matrix::IndexType > | |
| CTNL::Solvers::Linear::Preconditioners::ILUT< Matrix > | Implementation of a preconditioner based on Incomplete LU with thresholding |
| CTNL::Solvers::Linear::Preconditioners::Preconditioner< Matrix > | Base class for preconditioners of of iterative solvers of linear systems |
| CTNL::Solvers::Linear::Preconditioners::Diagonal< Matrices::DistributedMatrix< Matrix > > | Specialization of the diagonal preconditioner for distributed matrices |
| CTNL::Solvers::Linear::Preconditioners::Diagonal< Matrix > | Diagonal (Jacobi) preconditioner for iterative solvers of linear systems |
| CTNL::Solvers::Linear::Preconditioners::ILU0_impl< Matrix, Real, Devices::Cuda, Index > | |
| CTNL::Solvers::Linear::Preconditioners::ILU0_impl< Matrix, Real, Devices::Host, Index > | Implementation of a preconditioner based in Incomplete LU - specialization for CPU |
| CTNL::Solvers::Linear::Preconditioners::ILU0_impl< Matrix, Real, Devices::Sequential, Index > | |
| CTNL::Solvers::Linear::Preconditioners::ILUT_impl< Matrix, Real, Devices::Cuda, Index > | |
| CTNL::Solvers::Linear::Preconditioners::ILUT_impl< Matrix, Real, Devices::Host, Index > | |
| CTNL::Solvers::Linear::Preconditioners::ILUT_impl< Matrix, Real, Devices::Sequential, Index > | |
| CTNL::Solvers::Linear::Preconditioners::Preconditioner< Matrices::DistributedMatrix< Matrix > > | |
| CTNL::Solvers::Linear::Preconditioners::Diagonal< Matrices::DistributedMatrix< Matrix > > | Specialization of the diagonal preconditioner for distributed matrices |
| CTNL::Solvers::Linear::Traits< Matrix > | |
| CTNL::Solvers::Linear::Traits< Matrices::DistributedMatrix< Matrix > > | |
| CTNL::Solvers::ODE::Methods::BogackiShampin< Value > | Third order Bogacki-Shampin method with adaptive time step |
| CTNL::Solvers::ODE::Methods::CashKarp< Value > | Fifth order Cash-Karp method with adaptive time step |
| CTNL::Solvers::ODE::Methods::DormandPrince< Value > | Fifth order Dormand-Prince method also known as ode45 from Matlab with adaptive step size |
| CTNL::Solvers::ODE::Methods::Euler< Value > | First order Euler method |
| CTNL::Solvers::ODE::Methods::Fehlberg2< Value > | Second order Fehlbergs's method with adaptive time step |
| CTNL::Solvers::ODE::Methods::Fehlberg5< Value > | Fifth order Runge-Kutta-Fehlberg method with adaptive time step |
| CTNL::Solvers::ODE::Methods::Heun2< Value > | Second order Heun's method and Heun-Euler method with adaptive time step |
| CTNL::Solvers::ODE::Methods::Heun3< Value > | Third order Heun's method |
| CTNL::Solvers::ODE::Methods::Kutta< Value > | Third order Kutta's method |
| CTNL::Solvers::ODE::Methods::KuttaMerson< Value > | Fourth order Runge-Kutta-Merson method with adaptive step size |
| CTNL::Solvers::ODE::Methods::Midpoint< Value > | Second order midpoint method |
| CTNL::Solvers::ODE::Methods::OriginalRungeKutta< Value > | Fourth order Runge-Kutta method |
| CTNL::Solvers::ODE::Methods::Ralston2< Value > | Second order Ralstons's method |
| CTNL::Solvers::ODE::Methods::Ralston3< Value > | Third order Ralston's method |
| CTNL::Solvers::ODE::Methods::Ralston4< Value > | Fourth order Ralstons's method |
| CTNL::Solvers::ODE::Methods::Rule38< Value > | Fourth order 3/8 rule method |
| CTNL::Solvers::ODE::Methods::SSPRK3< Value > | Third order Strong Stability Preserving Runge-Kutta method |
| CTNL::Solvers::ODE::Methods::VanDerHouwenWray< Value > | Third order Van der Houwen's-Wray's method |
| CTNL::Solvers::ODE::ODESolver< Method, Vector, SolverMonitor, IsStatic > | Integrator or solver of systems of ordinary differential equations |
| CTNL::Solvers::SolverMonitor | Base class for solver monitors |
| CTNL::Solvers::IterativeSolverMonitor< double > | |
| CTNL::Solvers::IterativeSolverMonitor< typename Vector::RealType > | |
| CTNL::Solvers::IterativeSolverMonitor< gko::default_precision > | |
| CTNL::Solvers::IterativeSolverMonitor< Real > | Object for monitoring convergence of iterative solvers |
| CTNL::Solvers::SolverMonitorThread | A RAII wrapper for launching the SolverMonitor's main loop in a separate thread |
| CTNL::Solvers::StaticIterativeSolver< Real, Index > | Base class for iterative solvers |
| CTNL::Solvers::StaticIterativeSolver< double, int > | |
| CTNL::Solvers::ODE::StaticExplicitSolver< Real, Index > | Base class for ODE solvers and explicit solvers od PDEs |
| CTNL::Solvers::StaticIterativeSolver< GetValueType_t< Vector >, std::size_t > | |
| CTNL::Solvers::ODE::StaticExplicitSolver< GetValueType_t< Vector >, std::size_t > | |
| CTNL::Solvers::ODE::ODESolver< Method, Vector, SolverMonitor, true > | |
| CTNL::Timer | Class for real time, CPU time and CPU cycles measuring |
| CTNL::UnaryPlus | Function object implementing +x |
| Ctypename NDArray::SizesHolderType | |
| CTNL::Containers::LocalBeginsHolder< typename NDArray::SizesHolderType > | |
| Ctypename NDArrayView::SizesHolderType | |
| CTNL::Containers::LocalBeginsHolder< typename NDArrayView::SizesHolderType > | |
| Ctypename Segments::ViewType | |
| CTNL::Algorithms::Segments::GrowingSegmentsView< Segments, SegmentsView_ > | |
| Ctypename SegmentsType::ViewType | |
| CTNL::Algorithms::Segments::GrowingSegmentsView< SegmentsType > | |
1.18.0