Class Hierarchy

Go to the graphical class hierarchy

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

[detail level 1234]

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::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::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::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::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::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::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, HasGetArrayDataMethod< T >::value &&HasGetSizeMethod< T >::value &&HasSubscriptOperator< T >::value > [external]
CTNL::IsArrayType< T >	Type trait for checking if T is an array type, e.g. Containers::Array or Containers::Vector
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 mathemtatical 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::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 >
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::BiEllpackBase< Device, Index, Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization(), 32 >
CTNL::Algorithms::Segments::BiEllpack< Device, Index, IndexAllocator, Organization, WarpSize >
CTNL::Algorithms::Segments::BiEllpackView< Device, Index, Organization, WarpSize >
CTNL::Algorithms::Segments::BiEllpackSegmentView< Index, Organization, WarpSize >
CTNL::Algorithms::Segments::ChunkedEllpackBase< Device, Index, Organization >
CTNL::Algorithms::Segments::ChunkedEllpackView< Device, Index, Organization >
CTNL::Algorithms::Segments::ChunkedEllpackView< Device, std::add_const_t< Index >, Organization >
CTNL::Algorithms::Segments::ChunkedEllpackBase< Device, Index, Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization() >
CTNL::Algorithms::Segments::ChunkedEllpack< Device, Index, IndexAllocator, Organization >
CTNL::Algorithms::Segments::ChunkedEllpackView< Device, Index, Organization >
CTNL::Algorithms::Segments::ChunkedEllpackBase< Device_, Index_, Organization >
CTNL::Algorithms::Segments::ChunkedEllpackView< Device_, Index_, Organization >
CTNL::Algorithms::Segments::ChunkedEllpackSegmentView< Index, Organization >
CTNL::Algorithms::Segments::ChunkedEllpackSegmentView< Index, ColumnMajorOrder >
CTNL::Algorithms::Segments::ChunkedEllpackSegmentView< Index, RowMajorOrder >
CTNL::Algorithms::Segments::CSRBase< Device, Index >	CSRBase serves as a base class for CSR and CSRView
CTNL::Algorithms::Segments::CSRView< Device, std::add_const_t< Index > >
CTNL::Algorithms::Segments::CSRView< 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 format
CTNL::Algorithms::Segments::CSRView< Device, Index >	CSRView is provides a non-owning encapsulation of data stored in the CSR segments format
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 >
CTNL::Algorithms::Segments::EllpackView< Device, Index, Organization, Alignment >
CTNL::Algorithms::Segments::EllpackView< Device_, Index_, Organization, Alignment >
CTNL::Algorithms::Segments::EllpackBase< Device, Index, Segments::DefaultElementsOrganization< Device >::getOrganization(), 32 >
CTNL::Algorithms::Segments::Ellpack< Device, Index, IndexAllocator, Organization, Alignment >
CTNL::Algorithms::Segments::EllpackView< Device, Index, Organization, Alignment >
CTNL::Algorithms::Segments::SegmentElement< Index >	Simple structure representing one element of a segment
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 >
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::SlicedEllpackBase< Device, Index, Algorithms::Segments::DefaultElementsOrganization< Device >::getOrganization(), 32 >
CTNL::Algorithms::Segments::SlicedEllpack< Device, Index, IndexAllocator, Organization, SliceSize >
CTNL::Algorithms::Segments::SlicedEllpackView< Device, Index, Organization, SliceSize >
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::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::EllpackKernel< Index, Device >
CTNL::Algorithms::SegmentsReductionKernels::isSegmentReductionKernel< SegmentReductionKernel >
CTNL::Algorithms::SegmentsReductionKernels::isSegmentReductionKernel< BiEllpackKernel< Index, Device > >
CTNL::Algorithms::SegmentsReductionKernels::isSegmentReductionKernel< ChunkedEllpackKernel< Index, Device > >
CTNL::Algorithms::SegmentsReductionKernels::isSegmentReductionKernel< CSRAdaptiveKernel< Index, Device > >
CTNL::Algorithms::SegmentsReductionKernels::isSegmentReductionKernel< CSRAdaptiveKernelView< Index, Device > >
CTNL::Algorithms::SegmentsReductionKernels::isSegmentReductionKernel< CSRHybridKernel< Index, Device, ThreadsInBlock > >
CTNL::Algorithms::SegmentsReductionKernels::isSegmentReductionKernel< CSRLightKernel< Index, Device > >
CTNL::Algorithms::SegmentsReductionKernels::isSegmentReductionKernel< CSRScalarKernel< Index, Device > >
CTNL::Algorithms::SegmentsReductionKernels::isSegmentReductionKernel< CSRVectorKernel< Index, Device > >
CTNL::Algorithms::SegmentsReductionKernels::isSegmentReductionKernel< EllpackKernel< Index, Device > >
CTNL::Algorithms::SegmentsReductionKernels::isSegmentReductionKernel< SlicedEllpackKernel< Index, Device > >
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::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::Quicksort
CTNL::Algorithms::Sorting::Quicksorter< Value, Device >
CTNL::Algorithms::Sorting::Quicksorter< Value, Devices::Cuda >
CTNL::Algorithms::Sorting::STLSort
CTNL::Algorithms::Sorting::TASK
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::Double< T >
CTNL::Arithmetics::MultiPrecision
CTNL::Arithmetics::Quad< T >
CTNL::Atomic< T, Device >
CTNL::Atomic< T, Devices::Sequential >
CTNL::Atomic< T, Devices::Cuda >
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::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::Benchmarks::Benchmark< Logger >
CTNL::Benchmarks::BenchmarkResult
CTNL::Benchmarks::Logging
CTNL::Benchmarks::JsonLogging
CTNL::Benchmarks::LoggingRowElements
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< 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, 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< Real, TNL::Devices::Host, IndexType, Allocator >
CTNL::Containers::Vector< Real, TNL::Devices::Host, IndexType, typename Allocators::Default< TNL::Devices::Host >::template Allocator< Real > >
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< 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< Real, TNL::Devices::Host, IndexType >
CTNL::Containers::VectorView< Real, TNL::Devices::Host, IndexType >
CTNL::Containers::VectorView< typename TNL::copy_const< IndexType >::template from< Real >::type, 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< 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::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 >
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 >
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
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::FileName	Helper class for the construction of file names based on name, index and extension
CTNL::Functions::CutMeshFunction< MeshFunctionType, OutMesh, OutDof, outDimension, codimension >
CTNL::Functions::Domain< Dimension, DomainType_ >
CTNL::Functions::MeshFunction< MeshType, OperatorType::getPreimageEntitiesDimension() >
CTNL::Functions::MeshFunction< MeshType, Operator::getImageEntitiesDimension() >
CTNL::Functions::MeshFunction< MeshType, MeshEntityDimension, RealType >
CTNL::Functions::MeshFunctionView< MeshType, MeshEntityDimension, RealType >
CTNL::Functions::VectorField< VectorFieldSize, MeshFunction< MeshType, 1, RealType > >
CTNL::Functions::VectorField< VectorFieldSize, MeshFunction< MeshType, 0, RealType > >
CTNL::Functions::VectorField< VectorFieldSize, MeshFunction< MeshType, 2, RealType > >
CTNL::Functions::VectorField< VectorFieldSize, MeshFunction< MeshType, 3, RealType > >
CTNL::Functions::Domain< Function::getDomainDimension(), Function::getDomainType() >
CTNL::Functions::OperatorFunction< Operator, Function, void, false, true >
CTNL::Functions::VectorField< Size, Function >
CTNL::Functions::Domain< Mesh::getMeshDimension(), MeshDomain >
CTNL::Functions::MeshFunction< Mesh, MeshEntityDimension, Real >
CTNL::Functions::MeshFunction< Mesh, Mesh::getMeshDimension(), typename Mesh::RealType >
CTNL::Functions::BoundaryMeshFunction< Mesh, MeshEntityDimension, Real >
CTNL::Functions::MeshFunction< Mesh, MeshEntityDimension, Real >
CTNL::Functions::MeshFunctionView< Mesh, MeshEntityDimension, Real >
CTNL::Functions::Domain< MeshFunction< Mesh, MeshEntityDimension, Real >::getDomainDimension(), MeshFunction< Mesh, MeshEntityDimension, Real >::getDomainType() >
CTNL::Functions::VectorField< Size, MeshFunction< Mesh, MeshEntityDimension, Real > >
CTNL::Functions::VectorField< Size, MeshFunction< Mesh, MeshEntityDimension, Real > >
CTNL::Functions::Domain< MeshFunctionView< Mesh, MeshEntityDimension, Real >::getDomainDimension(), MeshFunctionView< Mesh, MeshEntityDimension, Real >::getDomainType() >
CTNL::Functions::VectorField< Size, MeshFunctionView< Mesh, MeshEntityDimension, Real > >
CTNL::Functions::VectorField< Size, MeshFunctionView< Mesh, MeshEntityDimension, Real > >
CTNL::Functions::Domain< Operator::getDimension(), MeshDomain >
CTNL::Functions::OperatorFunction< Operator, Function, BoundaryConditions, false, IsAnalytic >
CTNL::Functions::OperatorFunction< Operator, MeshFunctionT, BoundaryConditions, true, IsAnalytic >
CTNL::Functions::Domain< Operator::getDomainDimension(), Operator::getDomainType() >
CTNL::Functions::OperatorFunction< Operator, MeshFunctionT, void, true, IsAnalytic >
CTNL::Functions::OperatorFunction< Operator, PreimageFunction, void, false, IsAnalytic >
CTNL::Functions::Domain< Operator::getDomainDimension(), SpaceDomain >
CTNL::Functions::ExactOperatorFunction< Operator, Function >
CTNL::Functions::FunctionAdapter< Mesh, Function, domainType >
CTNL::Functions::FunctionAdapter< Mesh, Function, NonspaceDomain >
CTNL::Functions::FunctionAdapter< Mesh, Function, SpaceDomain >
CTNL::Functions::MeshFunctionEvaluator< OutMeshFunction, InFunction >
CTNL::Functions::MeshFunctionEvaluatorAdditionEntitiesProcessor< MeshType, UserData >
CTNL::Functions::MeshFunctionEvaluatorAssignmentEntitiesProcessor< MeshType, UserData >
CTNL::Functions::MeshFunctionEvaluatorTraverserUserData< OutMeshFunction, InFunction, Real >
CTNL::Functions::MeshFunctionGnuplotWriterBase
CTNL::Functions::MeshFunctionGnuplotWriter< MeshFunction, Meshes::Grid< 2, Real, Device, Index >, EntityDimension >
CTNL::Functions::MeshFunctionGnuplotWriter< MeshFunction, Meshes::Grid< 3, Real, Device, Index >, EntityDimension >
CTNL::Functions::MeshFunctionGnuplotWriter< MeshFunction, Mesh, EntitiesDimension >
CTNL::Functions::MeshFunctionGnuplotWriter< MeshFunction, Meshes::Grid< 2, Real, Device, Index >, EntityDimension >
CTNL::Functions::MeshFunctionGnuplotWriter< MeshFunction, Meshes::Grid< 3, Real, Device, Index >, EntityDimension >
CTNL::Functions::MeshFunctionGnuplotWriterBase::center< Entity, dim >
CTNL::Functions::MeshFunctionGnuplotWriterBase::center< Entity, 0 >
CTNL::Functions::MeshFunctionGnuplotWriterBase::center< TNL::Meshes::MeshEntity< MeshConfig, Device, Topology >, 0 >
CTNL::Functions::MeshFunctionGnuplotWriterBase::center< TNL::Meshes::MeshEntity< MeshConfig, Device, Topology >, dim >
CTNL::Functions::MeshFunctionNormGetter< Mesh >
CTNL::Functions::MeshFunctionNormGetter< Meshes::Grid< Dimension, MeshReal, Devices::Cuda, MeshIndex > >
CTNL::Functions::MeshFunctionNormGetter< Meshes::Grid< Dimension, MeshReal, Devices::Host, MeshIndex > >
CTNL::Functions::OperatorFunction< Operator, Function, BoundaryConditions, EvaluateOnFly, IsAnalytic >
CTNL::Functions::VectorFieldEvaluator< OutVectorField, InVectorField >
CTNL::Functions::VectorFieldEvaluatorAdditionEntitiesProcessor< MeshType, UserData >
CTNL::Functions::VectorFieldEvaluatorAssignmentEntitiesProcessor< MeshType, UserData >
CTNL::Functions::VectorFieldEvaluatorTraverserUserData< OutVectorField, InVectorField, Real >
CTNL::Functions::VectorFieldGnuplotWriter< VectorField >
CTNL::Functions::VectorFieldGnuplotWriter< VectorField< VectorFieldSize, MeshFunction< Meshes::Grid< 1, MeshReal, Device, MeshIndex >, 0, Real > > >
CTNL::Functions::VectorFieldGnuplotWriter< VectorField< VectorFieldSize, MeshFunction< Meshes::Grid< 1, MeshReal, Device, MeshIndex >, 1, Real > > >
CTNL::Functions::VectorFieldGnuplotWriter< VectorField< VectorFieldSize, MeshFunction< Meshes::Grid< 2, MeshReal, Device, MeshIndex >, 0, Real > > >
CTNL::Functions::VectorFieldGnuplotWriter< VectorField< VectorFieldSize, MeshFunction< Meshes::Grid< 2, MeshReal, Device, MeshIndex >, 1, Real > > >
CTNL::Functions::VectorFieldGnuplotWriter< VectorField< VectorFieldSize, MeshFunction< Meshes::Grid< 2, MeshReal, Device, MeshIndex >, 2, Real > > >
CTNL::Functions::VectorFieldGnuplotWriter< VectorField< VectorFieldSize, MeshFunction< Meshes::Grid< 3, MeshReal, Device, MeshIndex >, 0, Real > > >
CTNL::Functions::VectorFieldGnuplotWriter< VectorField< VectorFieldSize, MeshFunction< Meshes::Grid< 3, MeshReal, Device, MeshIndex >, 2, Real > > >
CTNL::Functions::VectorFieldGnuplotWriter< VectorField< VectorFieldSize, MeshFunction< Meshes::Grid< 3, MeshReal, Device, MeshIndex >, 3, Real > > >
CTNL::GetValueType< T >	Get the underlying value type of T
CTNL::Graphs::Aux< Real, Index >
CTNL::Graphs::Edge< Real, Index >
CTNL::Graphs::Forest< Real, Index >
CTNL::Graphs::Graph< Matrix, GraphType >
CTNL::Graphs::GraphReader< Graph >
CTNL::Graphs::GraphWriter< Graph >
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 count member
CTNL::HasGetArrayDataMethod< T >	Type trait for checking if T has getArrayData method
CTNL::HasGetCommunicatorMethod< T >	Type trait for checking if T has getCommunicator method
CTNL::HasGetSizeMethod< T >	Type trait for checking if T has getSize method
CTNL::HasSetSizeMethod< T >	Type trait for checking if T has 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::Images::DicomHeader
CTNL::Images::DicomImageInfo
CTNL::Images::DicomPatientInfo
CTNL::Images::DicomSeriesInfo
CTNL::Images::DirectionCosines
CTNL::Images::Image< Index >
CTNL::Images::Image< int >
CTNL::Images::DicomSeries
CTNL::Images::JPEGImage< Index >
CTNL::Images::PGMImage< Index >
CTNL::Images::PNGImage< Index >
CTNL::Images::ImageOrientationToPatient
CTNL::Images::ImagePositionToPatient
CTNL::Images::ImagesInfo
CTNL::Images::PixelSpacing
CTNL::Images::RegionOfInterest< Index >
CTNL::Images::WindowCenterWidth
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::details::MultidiagonalMatrixIndexer< Index, RowMajorOrder >
CTNL::Matrices::details::TridiagonalMatrixIndexer< Index, Organization >
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::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, typename ChooseSparseMatrixComputeReal< double, int >::type >
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< typename std::add_const< Real >::type, 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, std::conditional_t< std::is_const_v< Real >, typename SegmentsView< Device, Index >::ConstViewType, SegmentsView< Device, Index > >, ComputeReal >
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, SegmentsViewTemplate, ComputeReal >
CTNL::Matrices::SparseMatrixView< std::add_const_t< Real >, Device, Index, MatrixType, SegmentsViewTemplate, ComputeReal >
CTNL::Matrices::SparseMatrixView< _Real, _Device, _Index, _MatrixType, _SegmentsView, _ComputeReal >
CTNL::Matrices::SparseMatrixView< Real, Device, Index, MatrixType, SegmentsViewTemplate >
CTNL::Matrices::SparseMatrixView< std::add_const_t< Real >, Device, Index, MatrixType, SegmentsViewTemplate >
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 > >, typename ChooseSparseMatrixComputeReal< Real, int >::type >
CTNL::Matrices::SparseMatrixView< Real, Device, Index, MatrixType, SegmentsView, ComputeReal >	Implementation of sparse matrix view
CTNL::Matrices::MatrixBase< Real, 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< Real, TNL::Devices::Host, IndexType, TNL::Matrices::GeneralMatrix, Segments< TNL::Devices::Host, IndexType, typename Allocators::Default< TNL::Devices::Host >::template Allocator< IndexType > >::ViewType, typename ChooseSparseMatrixComputeReal< Real, IndexType >::type >
CTNL::Matrices::SparseMatrix< TNL::Real, TNL::Devices::Host, IndexType, 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::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::Real< T >
CTNL::Solvers::ConfigTagDevice< ConfigTag, Device >
CTNL::Solvers::ConfigTagExplicitSolver< ConfigTag, ExplicitSolver >
CTNL::Solvers::ConfigTagIndex< ConfigTag, Index >
CTNL::Solvers::ConfigTagIndex< FastBuildConfigTag, long int >
CTNL::Solvers::ConfigTagIndex< FastBuildConfigTag, short int >
CTNL::Solvers::ConfigTagMeshResolve< ConfigTag >
CTNL::Solvers::ConfigTagReal< ConfigTag, Real >
CTNL::Solvers::ConfigTagReal< FastBuildConfigTag, float >
CTNL::Solvers::ConfigTagReal< FastBuildConfigTag, long double >
CTNL::Solvers::ConfigTagTimeDiscretisation< ConfigTag, TimeDiscretisation >
CTNL::Solvers::ConfigTagTimeDiscretisation< FastBuildConfigTag, ExplicitTimeDiscretisationTag >
CTNL::Solvers::ConfigTagTimeDiscretisation< FastBuildConfigTag, ImplicitTimeDiscretisationTag >
CTNL::Solvers::ConfigTagTimeDiscretisation< FastBuildConfigTag, SemiImplicitTimeDiscretisationTag >
CTNL::Solvers::DefaultBuildConfigTag
CTNL::Solvers::ExplicitEulerSolverTag
CTNL::Solvers::ExplicitMersonSolverTag
CTNL::Solvers::ExplicitTimeDiscretisationTag
CTNL::Solvers::FastBuildConfigTag
CTNL::Solvers::ImplicitTimeDiscretisationTag
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::CuSolverWrapper< Matrix >
CTNL::Solvers::Linear::GEM< Matrix, Real, SolverMonitor >	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::SemiImplicitTimeDiscretisationTag
CTNL::Solvers::Solver< ProblemSetter, ProblemConfig, ConfigTag >
CTNL::Solvers::SolverConfig< ConfigTag, ProblemConfig >
CTNL::Solvers::SolverInitiator< ProblemSetter, ConfigTag >
CTNL::Solvers::SolverInitiatorDeviceResolver< ProblemSetter, Real, Device, ConfigTag, enabled >
CTNL::Solvers::SolverInitiatorDeviceResolver< ProblemSetter, Real, Device, ConfigTag, false >
CTNL::Solvers::SolverInitiatorDeviceResolver< ProblemSetter, Real, Device, ConfigTag, true >
CTNL::Solvers::SolverInitiatorIndexResolver< ProblemSetter, Real, Device, Index, ConfigTag, enabled >
CTNL::Solvers::SolverInitiatorIndexResolver< ProblemSetter, Real, Device, Index, ConfigTag, false >
CTNL::Solvers::SolverInitiatorIndexResolver< ProblemSetter, Real, Device, Index, ConfigTag, true >
CTNL::Solvers::SolverInitiatorMeshResolver< ProblemSetter, Real, Device, Index, ConfigTag, enabled >
CTNL::Solvers::SolverInitiatorMeshResolver< ProblemSetter, Real, Device, Index, ConfigTag, false >
CTNL::Solvers::SolverInitiatorMeshResolver< ProblemSetter, Real, Device, Index, ConfigTag, true >
CTNL::Solvers::SolverInitiatorRealResolver< ProblemSetter, Real, ConfigTag, enabled >
CTNL::Solvers::SolverInitiatorRealResolver< ProblemSetter, Real, ConfigTag, false >
CTNL::Solvers::SolverInitiatorRealResolver< ProblemSetter, Real, ConfigTag, true >
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::SolverStarter< ConfigTag >
CTNL::Solvers::SolverStarterExplicitSolverSetter< Problem, ExplicitSolver, ConfigTag, enabled >
CTNL::Solvers::SolverStarterExplicitSolverSetter< Problem, ExplicitSolverTag, ConfigTag, false >
CTNL::Solvers::SolverStarterExplicitSolverSetter< Problem, ExplicitSolverTag, ConfigTag, true >
CTNL::Solvers::SolverStarterTimeDiscretisationSetter< Problem, TimeDiscretisation, ConfigTag, enabled >
CTNL::Solvers::SolverStarterTimeDiscretisationSetter< Problem, ExplicitTimeDiscretisationTag, ConfigTag, true >
CTNL::Solvers::SolverStarterTimeDiscretisationSetter< Problem, ImplicitTimeDiscretisationTag, ConfigTag, true >
CTNL::Solvers::SolverStarterTimeDiscretisationSetter< Problem, SemiImplicitTimeDiscretisationTag, ConfigTag, true >
CTNL::Solvers::SolverStarterTimeDiscretisationSetter< Problem, TimeDiscretisationTag, ConfigTag, false >
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::Solvers::TimeDependencyResolver< Problem, ConfigTag, TimeDependent >
CTNL::Solvers::TimeDependencyResolver< Problem, ConfigTag, false >
CTNL::Solvers::TimeDependencyResolver< Problem, ConfigTag, true >
CTNL::Solvers::UserDefinedTimeDiscretisationSetter< Problem, ConfigTag, TimeStepper >
CTNL::Solvers::UserDefinedTimeDiscretisationSetter< Problem, ConfigTag, void >
CTNL::Timer	Class for real time, CPU time and CPU cycles measuring
CTNL::tnlFlopsCounter
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 >