Loading...
Searching...
No Matches
Dune Namespace Reference
Common » Dense Matrix and Vector Template Library | Common » Parallel Communication

Dune namespace More...

## Namespaces

namespace | Concept
| Namespace for concepts.
namespace | Simd
| Namespace for vectorization interface functions used by library developers.
namespace | DenseMatrixHelp
namespace | DynamicMatrixHelp
namespace | FloatCmp
| Various ways to compare floating-point numbers.
namespace | FMatrixHelp
namespace | MathOverloads
| namespace for customization of math functions with Dune-Semantics
namespace | Hybrid
| Namespace with loops, conditionals and other constructs that can handle both compile-time and run-time conditions.
namespace | Indices
| Namespace with predefined compile time indices for the range [0,19].
namespace | Std
| Namespace for features backported from new C++ standards.
namespace | TypeTree

## Classes

class | AlignedAllocator
| Allocators which guarantee alignment of the memory. More...
class | ArrayListIterator
| A random access iterator for the Dune::ArrayList class. More...
class | ConstArrayListIterator
| A constant random access iterator for the Dune::ArrayList class. More...
class | ArrayList
| A dynamically growing random access list. More...
struct | MPITraits
| A traits class describing the mapping of types onto MPI_Datatypes. More...
class | bigunsignedint
| Portable very large unsigned integers. More...
struct | IsNumber
| Whether this type acts as a scalar in the context of (hierarchically blocked) containers. More...
struct | IsNumber< bigunsignedint< k > >
| Declare big unsigned int is a number. More...
struct | Min
struct | Max
class | BitSetVector
| A dynamic array of blocks of booleans. More...
class | BitSetVectorReference
| A proxy class that acts as a mutable reference to a single bitset in a BitSetVector. More...
class | BitSetVectorConstReference
| A proxy class that acts as a const reference to a single bitset in a BitSetVector. More...
struct | const_reference< BitSetVectorReference< block_size, Alloc > >
struct | const_reference< BitSetVectorConstReference< block_size, Alloc > >
struct | mutable_reference< BitSetVectorReference< block_size, Alloc > >
struct | mutable_reference< BitSetVectorConstReference< block_size, Alloc > >
class | CopyableOptional
| A copyable type wrapper that provides copy/move assignment operations for types that are only copy/move constructible. More...
struct | AlignedBase
| CRTP base mixin class to check alignment. More...
struct | IsNumber< AlignedNumberImpl::AlignedNumber< T, align > >
struct | greater_or_equal
| Greater or equal template test. More...
struct | common_bits
| activate if current and mask have common bits switched on. More...
class | DebugStreamError
| standard exception for the debugstream More...
class | StreamWrap
class | DebugStreamState
| Intermediate class to implement tie-operation of DebugStream. More...
class | DebugStream
| Generic class to implement debug output streams. More...
class | DenseMatrix
| A dense n x m matrix. More...
struct | FieldTraits< DenseMatrix< M > >
class | FieldMatrix
| A dense n x m matrix. More...
class | FieldVector
| vector space out of a tensor product of fields. More...
struct | DenseMatrixAssigner
| you have to specialize this structure for any type that should be assignable to a DenseMatrix More...
class | FMatrixError
| Error thrown if operations of a FieldMatrix fail. More...
class | DenseVector
| Interface for a class of dense vectors over a given field. More...
struct | FieldTraits< DenseVector< V > >
class | DenseIterator
| Generic iterator class for dense vector and matrix implementations. More...
class | DiagonalRowVectorConst
class | DiagonalRowVector
class | DiagonalMatrixWrapper
class | ContainerWrapperIterator
| Iterator class for sparse vector-like containers. More...
class | DiagonalMatrix
| A diagonal matrix of static size. More...
struct | FieldTraits< DiagonalMatrix< K, n > >
struct | const_reference< DiagonalRowVector< K, n > >
struct | const_reference< DiagonalRowVectorConst< K, n > >
struct | mutable_reference< DiagonalRowVector< K, n > >
struct | mutable_reference< DiagonalRowVectorConst< K, n > >
struct | DenseMatrixAssigner< DenseMatrix, DiagonalMatrix< field, N > >
struct | ImplementationDefined
| Dummy struct used for documentation purposes. More...
struct | IsVector
struct | IsVector< T, std::void_t< typename T::field_type > >
class | DynamicMatrix
| Construct a matrix with a dynamic size. More...
struct | DenseMatVecTraits< DynamicMatrix< K > >
struct | FieldTraits< DynamicMatrix< K > >
class | DynamicVector
| Construct a vector with a dynamic size. More...
struct | DenseMatVecTraits< DynamicVector< K, Allocator > >
struct | FieldTraits< DynamicVector< K, Allocator > >
class | EmptySet
| An empty set. More...
class | AllSet
| A set containing everything. More...
class | EnumItem
| A set consisting only of one item. More...
class | EnumRange
| A set representing a range including the borders. More...
class | NegateSet
| The negation of a set. An item is contained in the set if and only if it is not contained in the negated set. More...
class | Combine
| A set combining two other sets. More...
class | Exception
| Base class for Dune-Exceptions. More...
struct | ExceptionHook
| Base class to add a hook to the Dune::Exception. More...
class | ExceptionStream
| Class for extending a Dune::Exception with a stream interface. More...
class | IOError
| Default exception class for I/O errors. More...
class | MathError
| Default exception class for mathematical errors. More...
class | RangeError
| Default exception class for range errors. More...
class | NotImplemented
| Default exception for dummy implementations. More...
class | SystemError
| Default exception class for OS errors. More...
class | OutOfMemoryError
| Default exception if memory allocation fails. More...
class | InvalidStateException
| Default exception if a function was called while the object is not in a valid state for that function. More...
class | ParallelError
| Default exception if an error in the parallel communication of the program occurred. More...
class | FloatCmpOps
| Class encapsulating a default epsilon. More...
struct | FieldTraits< Impl::ColumnVectorView< M > >
struct | DenseMatVecTraits< FieldMatrix< K, ROWS, COLS > >
struct | FieldTraits< FieldMatrix< K, ROWS, COLS > >
struct | FieldTraits
struct | FieldTraits< const T >
struct | FieldTraits< std::complex< T > >
struct | FieldTraits< T[N] >
struct | FieldTraits< std::vector< T > >
struct | DenseMatVecTraits< FieldVector< K, SIZE > >
struct | FieldTraits< FieldVector< K, SIZE > >
struct | IsFieldVectorSizeCorrect
| TMP to check the size of a DenseVectors statically, if possible. More...
struct | IsFieldVectorSizeCorrect< FieldVector< T, SIZE >, SIZE >
struct | IsFieldVectorSizeCorrect< FieldVector< T, SIZE1 >, SIZE >
struct | const_reference
| Get the 'const' version of a reference to a mutable object. More...
struct | const_reference< const R >
struct | const_reference< R & >
struct | const_reference< const R & >
struct | mutable_reference
| get the 'mutable' version of a reference to a const object More...
struct | mutable_reference< const R >
struct | mutable_reference< R & >
struct | mutable_reference< const R & >
class | GenericIterator
| Generic class for stl-conforming iterators for container classes with operator[]. More...
class | GMPField
| Number class for high precision floating point number using the GMP library mpf_class implementation. More...
struct | IsNumber< GMPField< precision > >
struct | PromotionTraits< GMPField< precision1 >, GMPField< precision2 > >
struct | PromotionTraits< GMPField< precision >, GMPField< precision > >
struct | PromotionTraits< GMPField< precision >, T >
struct | PromotionTraits< T, GMPField< precision > >
struct | MathematicalConstants< GMPField< precision > >
struct | hash
| Functor for hashing objects of type T. More...
class | HybridMultiIndex
| A hybrid multi-index class that supports both compile time and run time indices. More...
class | Indent
| Utility class for handling nested indentation in output. More...
class | IndexedIterator
| An iterator mixin that adds an index() method returning an enumeration index for the traversal. More...
struct | Cloneable
| An interface class for cloneable objects. More...
class | ios_base_all_saver
| Utility class for storing and resetting stream attributes. More...
class | ForwardIteratorFacade
| Base class for stl conformant forward iterators. More...
class | BidirectionalIteratorFacade
| Facade class for stl conformant bidirectional iterators. More...
class | RandomAccessIteratorFacade
| Base class for stl conformant forward iterators. More...
class | ProxyArrowResult
| Helper to mimic a pointer for proxy objects. More...
struct | IteratorFacadeAccess
| This class encapsulates access of IteratorFacade. More...
struct | DefaultIteratorTraits
| An iterator_traits class providing sensible defaults. More...
class | IteratorRange
| Simple range between a begin and an end iterator. More...
class | lru
| LRU Cache Container. More...
class | MallocAllocator
| Allocators implementation which simply calls malloc/free. More...
struct | StandardMathematicalConstants
| Standard implementation of MathematicalConstants. More...
struct | MathematicalConstants
| Provides commonly used mathematical constants. More...
struct | DenseMatVecTraits
struct | No_Comm
class | Communication
| Collective communication interface and sequential default implementation. More...
struct | SizeOne
| Flag for marking indexed data structures where data at each index is of the same size. More...
struct | VariableSize
| Flag for marking indexed data structures where the data at each index may be a variable multiple of another type. More...
struct | CommPolicy
| Default policy used for communicating an indexed type. More...
class | BufferedCommunicator
| A communicator that uses buffers to gather and scatter the data to be send or received. More...
class | InvalidFutureException
| This exception is thrown when ready(), wait() or get() is called on an invalid future. A future is valid until get() is called and if it is not default-constructed and it was not moved from. More...
class | PseudoFuture
| A wrapper-class for a object which is ready immediately. More...
class | Future
| Type-erasure for future-like objects. A future-like object is a object satisfying the interface of FutureBase. More...
class | PseudoFuture< void >
class | IndexPair
| A pair consisting of a global and local index. More...
class | InvalidIndexSetState
| Exception indicating that the index set is not in the expected state. More...
class | GlobalLookupIndexSet
| Decorates an index set with the possibility to find a global index that is mapped to a specific local. More...
class | ParallelIndexSet
| Manager class for the mapping between local indices and globally unique indices. More...
struct | LocalIndexComparator
struct | IndexSetSortFunctor
class | IndicesSyncer
| Class for recomputing missing indices of a distributed index set. More...
class | InterfaceBuilder
| Base class of all classes representing a communication interface. More...
class | InterfaceInformation
| Information describing an interface. More...
class | Interface
| Communication interface between remote and local indices. More...
class | LocalIndex
| An index present on the local process. More...
class | Generic_MPI_Op
class | Communication< MPI_Comm >
| Specialization of Communication for MPI. More...
struct | MPIData
struct | MPIData< void >
struct | MPIData< T, std::void_t< std::tuple< decltype(std::declval< T >().data()), decltype(std::declval< T >().size()), typename std::decay_t< T >::value_type > > >
class | MPIFuture
| Provides a future-like object for MPI communication. It contains the object that will be received and might contain also a sending object, which must be hold (keep alive) until the communication has been completed. More...
class | MPIGuardError
| This exception is thrown if the MPIGuard detects an error on a remote process. More...
class | MPIGuard
| detects a thrown exception and communicates to all other processes More...
class | FakeMPIHelper
| A fake mpi helper. More...
class | MPIHelper
| A real mpi helper. More...
class | MPIPack
struct | MPIData< P, std::enable_if_t< std::is_same< std::remove_const_t< P >, MPIPack >::value > >
class | ParallelLocalIndex
| An index present on the local process with an additional attribute flag. More...
struct | LocalIndexComparator< ParallelLocalIndex< T > >
class | MPITraits< ParallelLocalIndex< T > >
class | MPITraits< IndexPair< TG, ParallelLocalIndex< TA > > >
class | RemoteIndices
| The indices present on remote processes. More...
class | RemoteIndex
| Information about an index residing on another processor. More...
class | RemoteIndexListModifier
| Modifier for adding and/or deleting remote indices from the remote index list. More...
class | CollectiveIterator
| A collective iterator for moving over the remote indices for all processes collectively. More...
class | OwnerOverlapCopyCommunication
class | SelectionIterator
| A const iterator over an uncached selection. More...
class | UncachedSelection
| An uncached selection of indices. More...
class | Selection
| A cached selection of indices. More...
class | VariableSizeCommunicator
| A buffered communicator where the amount of data sent does not have to be known a priori. More...
class | ParameterizedObjectFactory
| A factory class for parameterized objects. More...
class | ParameterizedObjectFactory< TypeT(Args...), KeyT >
class | ParameterTree
| Hierarchical structure of string parameters. More...
class | ParameterTreeParserError
| report parser error while reading ParameterTree More...
class | HelpRequest
| exception thrown if the user wants to see help string More...
class | ParameterTreeParser
| Parsers to set up a ParameterTree from various input sources. More...
class | Pool
| A memory pool of objects. More...
class | PoolAllocator
| An allocator managing a pool of objects for reuse. More...
class | PoolAllocator< void, s >
class | FMatrixPrecision
| Precisions for calculations with FieldMatrix and FieldVector. More...
struct | PromotionTraits
| Compute type of the result of an arithmetic operation involving two different number types. More...
struct | PromotionTraits< T1, T1 >
struct | PropertyMapTraits
struct | ReadablePropertyMapTag
| Tag for the category of readable property maps. More...
struct | WritablePropertyMapTag
| Tag for the category of writable property maps. More...
struct | ReadWritePropertyMapTag
| Tag for the category of readable and writable property maps. More...
struct | LvaluePropertyMapTag
| Tag for the category of lvalue property maps. More...
struct | PropertyMapTraits< T * >
struct | PropertyMapTraits< const T * >
struct | RAPropertyMapHelper
class | IteratorPropertyMap
| Adapter to turn a random access iterator into a property map. More...
class | AssociativePropertyMap
| An adapter to turn an unique associative container into a property map. More...
class | ConstAssociativePropertyMap
| An adaptor to turn an unique associative container into a property map. More...
struct | IdentityMap
| A property map that applies the identity function to integers. More...
struct | PropertyMapTypeSelector
| Selector for the property map type. More...
class | IntegralRange
| dynamic integer range for use in range-based for loops More...
class | StaticIntegralRange
| static integer range for use in range-based for loops More...
struct | ValueTransformationTag
| Tag to enable value based transformations in TransformedRangeView. More...
struct | IteratorTransformationTag
| Tag to enable iterator based transformations in TransformedRangeView. More...
class | TransformedRangeView
| A range transforming the values of another range on-the-fly. More...
class | ReservedVector
| A Vector class with statically reserved memory. More...
struct | FieldTraits< Impl::ScalarMatrixView< K > >
struct | DenseMatVecTraits< Impl::ScalarMatrixView< K > >
struct | AutonomousValueType< Impl::ScalarMatrixView< K > >
struct | DenseMatVecTraits< Impl::ScalarVectorView< K > >
struct | FieldTraits< Impl::ScalarVectorView< K > >
struct | AutonomousValueType< Impl::ScalarVectorView< K > >
struct | null_deleter
| implements the Deleter concept of shared_ptr without deleting anything More...
struct | SimdScalarTypeTraits
struct | SimdScalarTypeTraits< AlignedNumber< T, align > >
| deduce the underlying scalar data type of an AlignedNumber More...
struct | SimdIndexTypeTraits
struct | SimdMaskTypeTraits
class | LoopSIMD
struct | IsNumber< LoopSIMD< T, S, A > >
struct | IsNumber< Vc::SimdArray< T, N, V, Wt > >
struct | IsNumber< Vc::Vector< T, Abi > >
struct | AutonomousValueType< Simd::VcImpl::Proxy< V > >
| Specialization of AutonomousValue for Vc proxies. More...
class | Singleton
| An adapter to turn a class into a singleton. More...
class | SLListIterator
| A mutable iterator for the SLList. More...
class | SLListConstIterator
| A constant iterator for the SLList. More...
class | SLListModifyIterator
| A mutable iterator for the SLList. More...
class | SLList
| A single linked list. More...
class | Timer
| A simple stop watch. More...
struct | FieldTraits< Impl::TransposedMatrixWrapper< M > >
struct | TupleAccessTraits
struct | TupleAccessTraits< T * >
struct | TupleAccessTraits< T & >
struct | NullPointerInitialiser
| A helper template that initializes a std::tuple consisting of pointers to nullptr. More...
struct | NullPointerInitialiser< std::tuple< Args... > >
struct | ForEachType
| Helper template to clone the type definition of a std::tuple with the storage types replaced by a user-defined rule. More...
struct | ForEachType< TE, std::tuple< Args... > >
class | TransformTupleFunctor
struct | AddRefTypeEvaluator
| `TypeEvaluator` to turn a type `T` into a reference to `T` More...
struct | AddPtrTypeEvaluator
| `TypeEvaluator` to turn a type `T` into a pointer to `T` More...
struct | AddPtrTypeEvaluator< T & >
struct | AtType
| Type for reverse element access. More...
struct | At
| Reverse element access. More...
struct | PointerPairDeletor
| Deletes all objects pointed to in a std::tuple of pointers. More...
class | FirstPredicateIndex
| Finding the index of a certain type in a std::tuple. More...
struct | IsType
| Generator for predicates accepting one particular type. More...
struct | FirstTypeIndex
| Find the first occurrence of a type in a std::tuple. More...
struct | PushBackTuple
| Helper template to append a type to a std::tuple. More...
struct | PushBackTuple< typename std::tuple< Args... >, T >
struct | PushFrontTuple
| Helper template to prepend a type to a std::tuple. More...
struct | PushFrontTuple< typename std::tuple< Args... >, T >
struct | ReduceTuple
| Apply reduce with meta binary function to template. More...
struct | ReduceTuple< F, Tuple, Seed, 0 >
| Apply reduce with meta binary function to template. More...
struct | JoinTuples
| Join two std::tuple's. More...
struct | FlattenTuple
| Flatten a std::tuple of std::tuple's. More...
class | TupleVector
| A class augmenting std::tuple by element access via operator[]. More...
struct | MetaType
| A type that refers to another type. More...
struct | IsTypeList
| Check if given type is a TypeList. More...
struct | IsTypeList< TypeList< T... > >
| Check if given type is a TypeList. More...
struct | IsEmptyTypeList
| Check if given type is an empty TypeList. More...
struct | TypeListSize
struct | TypeListSize< TypeList< T... > >
| Get size of TypeList. More...
struct | TypeListElement
struct | TypeListElement< i, TypeList< T... > >
| Get element of TypeList. More...
struct | Empty
| Just an empty class. More...
struct | IsInteroperable
| Checks whether two types are interoperable. More...
struct | EnableIfInterOperable
| Enable typedef if two types are interoperable. More...
struct | AlwaysFalse
| template which always yields a false value More...
struct | AlwaysTrue
| template which always yields a true value More...
struct | IsCallable
| Check if a type is callable with ()-operator and given arguments. More...
struct | IsCallable< F(Args...), R >
| Check if a type is callable with ()-operator and given arguments. More...
struct | HasNaN
| Whether this type has a value of NaN. More...
struct | IsIndexable
| Type trait to determine whether an instance of T has an operator[](I), i.e. whether it can be indexed with an index of type I. More...
struct | IsIterable
| typetrait to check that a class has begin() and end() members More...
struct | IsTuple
| Check if T is a std::tuple<...>. More...
struct | IsTupleOrDerived
| Check if T derived from a std::tuple<...>. More...
struct | IsIntegralConstant
| Check if T is an std::integral_constant<I, i>. More...
struct | IsCompileTimeConstant
| Check if T is an integral constant or any type derived from std::integral_constant. More...
struct | IntegerSequenceEntry
| Get entry of std::integer_sequence. More...
struct | AutonomousValueType
| Type free of internal references that T can be converted to. More...
struct | AutonomousValueType< T & >
| Specialization to remove lvalue references. More...
struct | AutonomousValueType< T && >
| Specialization to remove rvalue references. More...
struct | AutonomousValueType< const T >
| Specialization to remove const qualifiers. More...
struct | AutonomousValueType< volatile T >
| Specialization to remove volatile qualifiers. More...
struct | AutonomousValueType< std::vector< bool >::reference >
| Specialization for the proxies of vector<bool>. More...
struct | AutonomousValueType< volatile const T >
| Specialization to remove both const and volatile qualifiers. More...
struct | PriorityTag
| Helper class for tagging priorities. More...
struct | PriorityTag< 0 >
| Helper class for tagging priorities. More...
class | TestSuite
| A Simple helper class to organize your test suite. More...
class | AlignedNumber
| aligned wrappers for arithmetic types More...

## Typedefs

using | ViolatedAlignmentHandler
| type of the handler called by violatedAlignment()
typedef unsigned int | DebugLevel
| Type for debug levels.
template<std::size_t i>
using | index_constant = std::integral_constant<std::size_t, i>
| An index constant with value i.
template<class IteratorImpl, class IteratorTraits>
using | IteratorFacadeForTraits
| Alias for the CRTP-Mixing class IteratorFacade.
template<class T>
using | ResolveRef_t = std::remove_reference_t<decltype(Dune::resolveRef(std::declval<T&>()))>
| Type trait to resolve std::reference_wrapper.
template<typename T>
using | SimdScalar = typename SimdScalarTypeTraits<T>::type
template<typename V>
using | SimdIndex = typename SimdIndexTypeTraits<V>::type
| An simd vector of indices corresponding to a simd vector V.
template<typename V>
using | SimdMask = typename SimdMaskTypeTraits<V>::type
| A simd vector of truth values corresponding to a simd vector V.
template<template< typename... > class Fallback, template< typename... > class TargetType, typename... Args>
using | detected_or_fallback_t
| This type will be either TargetType<Args...> if it exists, or the Fallback<Args...> type.
typedef DebugStream< VERY_VERBOSE_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL > | DVVerbType
| Type of very verbose debug stream.
typedef DebugStream< VERBOSE_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL > | DVerbType
| Type of more verbose debug stream.
typedef DebugStream< INFO_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL > | DInfoType
| Type of debug stream with info level.
typedef DebugStream< WARN_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL > | DWarnType
| Type of debug stream with warn level.
typedef DebugStream< GRAVE_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL > | DGraveType
| Type of debug stream for fatal errors.
typedef DebugStream< 1 > | DErrType
| The type of the stream used for error messages.
template<class... T>
using | TypeList = std::tuple<MetaType<T>...>
| A simple type list.
template<std::size_t i, class T>
using | TypeListEntry_t = typename TypeListElement<i, T>::type
| Shortcut for TypeListElement<i, T>::type;.
template<template< class... > class Target, class TL>
using | UnpackTypeList_t = typename Impl::UnpackTypeList<Target, TL>::type
| Unpack Dune::TypeList.
template<template< class... > class Target, class... T>
using | UniqueTypes_t = typename Impl::UniqueTypesHelper<Target, TypeList<T...>>::type
| Remove duplicates from a list of types.
template<class NonUniqueTypeList>
using | UniqueTypeList_t = typename Impl::UniqueTypesHelper<TypeList, NonUniqueTypeList>::type
| Remove duplicates from a Dune::TypeList.
template<class... Types>
using | void_t = typename Impl::voider<Types...>::type
| Is void for all valid input types. The workhorse for C++11 SFINAE-techniques.
template<class Type>
using | field_t = typename FieldTraits<Type>::field_type
| Convenient access to FieldTraits<Type>::field_type.
template<class Type>
using | real_t = typename FieldTraits<Type>::real_type
| Convenient access to FieldTraits<Type>::real_type.
template<class T>
using | AutonomousValue = typename AutonomousValueType<T>::type
| Type free of internal references that T can be converted to.
template<class This, class... T>
using | disableCopyMove = std::enable_if_t< not Impl::disableCopyMoveHelper<This, T...>::value, int>
| Helper to disable constructor as copy and move constructor.

## Enumerations

enum | { implementationDefined }
enum | ParallelIndexSetState { GROUND , RESIZE }
| The states the index set can be in. More...
enum | LocalIndexState { VALID , DELETED }
| The states available for the local indices. More...

## Functions

template<int k>
std::ostream & | operator<< (std::ostream &s, const bigunsignedint< k > &x)
template<int k>
bigunsignedint< k > | operator+ (const bigunsignedint< k > &x, std::uintmax_t y)
template<int k>
bigunsignedint< k > | operator- (const bigunsignedint< k > &x, std::uintmax_t y)
template<int k>
bigunsignedint< k > | operator* (const bigunsignedint< k > &x, std::uintmax_t y)
template<int k>
bigunsignedint< k > | operator/ (const bigunsignedint< k > &x, std::uintmax_t y)
template<int k>
bigunsignedint< k > | operator% (const bigunsignedint< k > &x, std::uintmax_t y)
template<int k>
bigunsignedint< k > | operator+ (std::uintmax_t x, const bigunsignedint< k > &y)
template<int k>
bigunsignedint< k > | operator- (std::uintmax_t x, const bigunsignedint< k > &y)
template<int k>
bigunsignedint< k > | operator* (std::uintmax_t x, const bigunsignedint< k > &y)
template<int k>
bigunsignedint< k > | operator/ (std::uintmax_t x, const bigunsignedint< k > &y)
template<int k>
bigunsignedint< k > | operator% (std::uintmax_t x, const bigunsignedint< k > &y)
template<class T>
std::string | className ()
| Provide the demangled class name of a type T as a string.
template<class T>
std::string | className (T &&v)
| Provide the demangled class name of a given object as a string.
template<class C, class... T>
constexpr auto | models ()
| Check if concept is modeled by given types.
template<typename T1, typename T2>
const T1 | cond (bool b, const T1 &v1, const T2 &v2)
| conditional evaluate
static void | defaultViolatedAlignment (const char *className, std::size_t expectedAlignment, const void *address)
| default alignment violation handler
ViolatedAlignmentHandler & | violatedAlignmentHandler ()
| access the handler called by violatedAlignment()
void | violatedAlignment (const char *className, std::size_t expectedAlignment, const void *address)
| called when an alignment violation is detected
bool | isAligned (const void *p, std::size_t align)
| check whether an address conforms to the given alignment
template<std::size_t align = debugAlignment, class T>
AlignedNumber< T, align > | aligned (T value)
| align a value to a certain alignment
template<class T, std::size_t align>
AlignedNumber< T, align > | cond (const AlignedNumber< bool, align > &b, const AlignedNumber< T, align > &v1, const AlignedNumber< T, align > &v2)
template<class T, std::size_t align>
T | max_value (const AlignedNumber< T, align > &val)
template<class T, std::size_t align>
T | min_value (const AlignedNumber< T, align > &val)
template<std::size_t align>
bool | any_true (const AlignedNumber< bool, align > &val)
template<std::size_t align>
bool | all_true (const AlignedNumber< bool, align > &val)
template<typename MAT>
std::ostream & | operator<< (std::ostream &s, const DenseMatrix< MAT > &a)
| Sends the matrix to an output stream.
template<class A, class B>
auto | dot (const A &a, const B &b) -> typename std::enable_if< IsNumber< A >::value &&!IsVector< A >::value &&!std::is_same< typename FieldTraits< A >::field_type, typename FieldTraits< A >::real_type > ::value, decltype(conj(a) *b)>::type
| computes the dot product for fundamental data types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b
template<class A, class B>
auto | dot (const A &a, const B &b) -> typename std::enable_if< IsNumber< A >::value &&!IsVector< A >::value &&std::is_same< typename FieldTraits< A >::field_type, typename FieldTraits< A >::real_type >::value, decltype(a *b)>::type
| computes the dot product for fundamental data types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b
template<typename A, typename B>
auto | dot (const A &a, const B &b) -> typename std::enable_if< IsVector< A >::value, decltype(a.dot(b))>::type
| computes the dot product for various dune vector types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b
template<class A, class B>
auto | dotT (const A &a, const B &b) -> decltype(a *b)
| Computes an indefinite vector dot product for fundamental data types according to Petsc's VectTDot function: dotT(a,b) := a*b.
template<typename TA, int i>
std::ostream & | operator<< (std::ostream &os, const EnumItem< TA, i > &)
template<typename TA, int from, int to>
std::ostream & | operator<< (std::ostream &os, const EnumRange< TA, from, to > &)
template<class TI1, class TI2>
Combine< TI1, TI2, typename TI1::Type > | combine (const TI1 &set1, const TI2 &set2)
template<class TI1, class TI2, class T>
std::ostream & | operator<< (std::ostream &os, const Combine< TI1, TI2, T > &)
std::ostream & | operator<< (std::ostream &stream, const Exception &e)
template<std::size_t n, class T>
constexpr std::array< T, n > | filledArray (const T &t)
| Return an array filled with the provided value.
template<typename T>
void | hash_combine (std::size_t &seed, const T &arg)
| Calculates the hash value of arg and combines it in-place with seed.
template<typename It>
std::size_t | hash_range (It first, It last)
| Hashes all elements in the range [first,last) and returns the combined hash.
template<typename It>
void | hash_range (std::size_t &seed, It first, It last)
| Hashes all elements in the range [first,last) and combines the hashes in-place with seed.
template<typename... I> requires (((std::is_integral_v<I> or Dune::IsIntegralConstant<I>::value) && ...))
| HybridMultiIndex (I... i) -> HybridMultiIndex< decltype(Impl::castToHybridSizeT(i))... >
template<typename... I>
| HybridMultiIndex (std::tuple< I... >) -> HybridMultiIndex< I... >
template<typename... T>
constexpr auto | back (const HybridMultiIndex< T... > &tp) -> decltype(tp.back())
| Returns a copy of the last element of the HybridMultiIndex.
template<typename... T>
constexpr auto | front (const HybridMultiIndex< T... > &tp) -> decltype(tp.front())
| Returns a copy of the first element of the HybridMultiIndex.
template<typename... T>
constexpr HybridMultiIndex< T..., std::size_t > | push_back (const HybridMultiIndex< T... > &tp, std::size_t i)
| Appends a run time index to a HybridMultiIndex.
template<std::size_t i, typename... T>
constexpr HybridMultiIndex< T..., index_constant< i > > | push_back (const HybridMultiIndex< T... > &tp, index_constant< i > iConstant={})
| Appends a compile time index to a HybridMultiIndex.
template<typename... T>
constexpr HybridMultiIndex< std::size_t, T... > | push_front (const HybridMultiIndex< T... > &tp, std::size_t i)
| Prepends a run time index to a HybridMultiIndex.
template<std::size_t i, typename... T>
constexpr HybridMultiIndex< index_constant< i >, T... > | push_front (const HybridMultiIndex< T... > &tp, index_constant< i > iConstant={})
| Prepends a compile time index to a HybridMultiIndex.
template<typename I, typename... T> requires (sizeof...(T) > 0)
constexpr auto | accumulate_back (const HybridMultiIndex< T... > &tp, I i)
| Hybrid utility that accumulates to the back of a multi-index.
template<typename I, typename... T> requires (sizeof...(T) > 0)
constexpr auto | accumulate_front (const HybridMultiIndex< T... > &tp, I i)
| Hybrid utility that accumulates to the front of a multi-index.
template<class... Head, class... Other>
constexpr auto | join (const HybridMultiIndex< Head... > &head, const Other &... tail)
| Join two hybrid multi-indices into one.
template<class... T>
constexpr auto | reverse (const HybridMultiIndex< T... > &tp)
| Reverses the order of the elements in the multi-index.
template<class... T> requires (sizeof...(T) > 0)
constexpr auto | pop_front (const HybridMultiIndex< T... > &tp)
| Removes first index on a HybridMultiIndex.
template<class... T> requires (sizeof...(T) > 0)
constexpr auto | pop_back (const HybridMultiIndex< T... > &tp)
| Removes last index on a HybridMultiIndex.
template<class... S, class... T>
constexpr bool | operator== (const HybridMultiIndex< S... > &lhs, const HybridMultiIndex< T... > &rhs)
| Compare two HybridMultiIndexs for value equality.
template<class S, S... lhs, class T, T... rhs>
constexpr auto | operator== (const HybridMultiIndex< std::integral_constant< S, lhs >... > &, const HybridMultiIndex< std::integral_constant< T, rhs >... > &)
| Overload for purely static HybridMultiIndexs.
template<class... S, class... T>
constexpr auto | operator!= (const HybridMultiIndex< S... > &lhs, const HybridMultiIndex< T... > &rhs)
| Compare two HybridMultiIndexs for inequality.
template<class S, S... lhs, class T, T... rhs>
constexpr auto | operator!= (const HybridMultiIndex< std::integral_constant< S, lhs >... > &, const HybridMultiIndex< std::integral_constant< T, rhs >... > &)
| Compare two static HybridMultiIndexs for inequality.
template<typename... T>
std::ostream & | operator<< (std::ostream &os, const HybridMultiIndex< T... > &tp)
| Dumps a HybridMultiIndex to a stream.
std::ostream & | operator<< (std::ostream &s, const Indent &indent)
| write indentation to a stream
template<class F, class I, I... i>
decltype(auto) constexpr | unpackIntegerSequence (F &&f, std::integer_sequence< I, i... > sequence)
| Unpack an std::integer_sequence<I,i...> to std::integral_constant<I,i>...
template<std::size_t pos, class T, T... II, std::enable_if_t<(!(pos >=sizeof...(II))), int > = 0>
constexpr auto | get (std::integer_sequence< T, II... >, std::integral_constant< std::size_t, pos >={})
| Return the entry at position pos of the given sequence.
template<class T, T... II>
constexpr T | get (std::integer_sequence< T, II... >, std::size_t pos)
| Return the entry at position pos of the given sequence.
template<class T, T I0, T... II>
constexpr std::integral_constant< T, I0 > | front (std::integer_sequence< T, I0, II... >)
| Return the first entry of the sequence.
template<class T, T... II, std::enable_if_t<(sizeof...(II) > 0), int > = 0>
constexpr auto | back (std::integer_sequence< T, II... > seq)
| Return the last entry of the sequence.
template<class T, T I0, T... II>
constexpr std::integral_constant< T, I0 > | head (std::integer_sequence< T, I0, II... >)
| For a sequence [head,tail...) return the single head element.
template<class T, T I0, T... II>
constexpr std::integer_sequence< T, II... > | tail (std::integer_sequence< T, I0, II... >)
| For a sequence [head,tail...) return the tail sequence.
template<auto I0, class T, T... II>
constexpr std::integer_sequence< T, T(I0), II... > | push_front (std::integer_sequence< T, II... >, std::integral_constant< T, I0 >={})
| Append an index I0 to the front of the sequence.
template<auto IN, class T, T... II>
constexpr std::integer_sequence< T, II..., T(IN)> | push_back (std::integer_sequence< T, II... >, std::integral_constant< T, IN >={})
| Append an index IN to the back of the sequence.
template<class T, T... II>
constexpr std::integral_constant< std::size_t, sizeof...(II)> | size (std::integer_sequence< T, II... >)
| Return the size of the sequence.
template<class T, T... II>
constexpr std::bool_constant<(sizeof...(II)==0)> | empty (std::integer_sequence< T, II... >)
| Checks whether the sequence is empty.
template<class T, T... II, class Compare>
constexpr auto | sorted (std::integer_sequence< T, II... >, Compare comp)
| Sort a given sequence by the comparator comp.
template<class T, T... II>
constexpr auto | sorted (std::integer_sequence< T, II... > seq)
| Sort a given sequence by less-than comparison.
template<class T, T... II, T value>
constexpr std::bool_constant<((II==value)||...)> | contains (std::integer_sequence< T, II... >, std::integral_constant< T, value >)
| Checks whether or not a given sequence contains a value.
template<class T, T... II, T... JJ>
constexpr auto | difference (std::integer_sequence< T, II... > iSeq, std::integer_sequence< T, JJ... > jSeq)
| Return the elements from the sequence [II...) which are not found in the sequence [JJ...).
template<std::size_t N, class T, T... JJ, std::enable_if_t<(N >=sizeof...(JJ)), int > = 0>
constexpr auto | difference (std::integer_sequence< T, JJ... > jSeq)
| Return the elements from the sequence [0,1,...N) which are not found in the sequence [JJ...).
template<class S, S... II, class T, T... JJ, std::enable_if_t<(sizeof...(II)==sizeof...(JJ)), int > = 0, class ST = std::common_type_t<S,T>>
constexpr std::is_same< std::integer_sequence< bool, true,(ST(II)==ST(JJ))... >, std::integer_sequence< bool,(ST(II)==ST(JJ))..., true > > | equal (std::integer_sequence< S, II... >, std::integer_sequence< T, JJ... >)
| Checks whether two sequences are identical.
template<class S, S... II, class T, T... JJ, std::enable_if_t<(sizeof...(II) !=sizeof...(JJ)), int > = 0>
constexpr std::bool_constant< false > | equal (std::integer_sequence< S, II... >, std::integer_sequence< T, JJ... >)
| Sequences are unequal if not of the same length.
template<template< auto > class Filter, class T>
constexpr auto | filter (std::integer_sequence< T > jSeq)
template<template< auto > class Filter, class T, T J0, T... JJ>
constexpr auto | filter (std::integer_sequence< T, J0, JJ... > jSeq)
template<class Filter, class T>
constexpr auto | filter (Filter, std::integer_sequence< T > jSeq)
template<class Filter, class T, T J0, T... JJ>
constexpr auto | filter (Filter f, std::integer_sequence< T, J0, JJ... > jSeq)
template<class T1, class V1, class R1, class D, class T2, class V2, class R2>
constexpr EnableIfInterOperable< T1, T2, bool >::type | operator== (const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
| Checks for equality.
template<class T1, class V1, class R1, class D, class T2, class V2, class R2>
constexpr EnableIfInterOperable< T1, T2, bool >::type | operator!= (const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
| Checks for inequality.
template<class T1, class V1, class R1, class D, class T2, class V2, class R2>
constexpr std::enable_if< std::is_convertible< T2, T1 >::value, bool >::type | operator== (const BidirectionalIteratorFacade< T1, V1, R1, D > &lhs, const BidirectionalIteratorFacade< T2, V2, R2, D > &rhs)
| Checks for equality.
template<class T1, class V1, class R1, class D, class T2, class V2, class R2>
constexpr std::enable_if< std::is_convertible< T1, T2 >::value &&!std::is_convertible< T2, T1 >::value, bool >::type | operator== (const BidirectionalIteratorFacade< T1, V1, R1, D > &lhs, const BidirectionalIteratorFacade< T2, V2, R2, D > &rhs)
| Checks for equality.
template<class T1, class V1, class R1, class D, class T2, class V2, class R2>
constexpr EnableIfInterOperable< T1, T2, bool >::type | operator!= (const BidirectionalIteratorFacade< T1, V1, R1, D > &lhs, const BidirectionalIteratorFacade< T2, V2, R2, D > &rhs)
| Checks for inequality.
template<class T1, class V1, class R1, class D, class T2, class V2, class R2>
constexpr EnableIfInterOperable< T1, T2, bool >::type | operator== (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
| Checks for equality.
template<class T1, class V1, class R1, class D, class T2, class V2, class R2>
constexpr EnableIfInterOperable< T1, T2, bool >::type | operator!= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
| Checks for inequality.
template<class T1, class V1, class R1, class D, class T2, class V2, class R2>
constexpr EnableIfInterOperable< T1, T2, bool >::type | operator< (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
| Comparison operator.
template<class T1, class V1, class R1, class D, class T2, class V2, class R2>
constexpr EnableIfInterOperable< T1, T2, bool >::type | operator<= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
| Comparison operator.
template<class T1, class V1, class R1, class D, class T2, class V2, class R2>
constexpr EnableIfInterOperable< T1, T2, bool >::type | operator> (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
| Comparison operator.
template<class T1, class V1, class R1, class D, class T2, class V2, class R2>
constexpr EnableIfInterOperable< T1, T2, bool >::type | operator>= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
| Comparison operator.
template<class T1, class V1, class R1, class D, class T2, class V2, class R2>
constexpr EnableIfInterOperable< T1, T2, D >::type | operator- (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
| Calculates the difference between two pointers.
constexpr decltype(auto) | operator* () const
| Dereferencing operator.
constexpr pointer | operator-> () const
| Arrow access to members of referenced value.
constexpr decltype(auto) | operator++ ()
| Preincrement operator.
constexpr DerivedIterator | operator++ (int)
| Postincrement operator.
template<bool dummy = true, std::enable_if_t< isBidirectional and dummy, int > = 0>
constexpr decltype(auto) | operator-- ()
| Predecrement operator.
template<bool dummy = true, std::enable_if_t< isBidirectional and dummy, int > = 0>
constexpr DerivedIterator | operator-- (int)
| Postdecrement operator.
template<bool dummy = true, std::enable_if_t< isRandomAccess and dummy, int > = 0>
constexpr reference | operator[] (difference_type n) const
| Dereference element with given offset form this iterator.
template<bool dummy = true, std::enable_if_t< isRandomAccess and dummy, int > = 0>
constexpr decltype(auto) | operator+= (difference_type n)
| Increment iterator by given value.
template<bool dummy = true, std::enable_if_t< isRandomAccess and dummy, int > = 0>
constexpr DerivedIterator | operator+ (difference_type n) const
| Create iterator incremented by given value.
template<bool dummy = true, std::enable_if_t< isRandomAccess and dummy, int > = 0>
constexpr DerivedIterator | operator+ (difference_type n, const IteratorFacade &it)
| Create iterator incremented by given value.
template<bool dummy = true, std::enable_if_t< isRandomAccess and dummy, int > = 0>
constexpr DerivedIterator & | operator-= (difference_type n)
| Decrement iterator by given value.
template<bool dummy = true, std::enable_if_t< isRandomAccess and dummy, int > = 0>
constexpr DerivedIterator | operator- (difference_type n) const
| Create iterator decremented by given value.
template<class T1, class T2, class C, class V1, class V2, class R1, class R2, class P1, class P2, class D1, class D2>
constexpr auto | operator== (const IteratorFacade< T1, C, V1, R1, P1, D1 > &it1, const IteratorFacade< T2, C, V2, R2, P2, D2 > &it2)
| Equality comparison for IteratorFacade.
template<class T1, class T2, class C, class V1, class V2, class R1, class R2, class P1, class P2, class D1, class D2, std::enable_if_t< Dune::models< Impl::Concepts::IterEqualsOp, T1, T2 >(), int > = 0>
constexpr bool | operator!= (const IteratorFacade< T1, C, V1, R1, P1, D1 > &it1, const IteratorFacade< T2, C, V2, R2, P2, D2 > &it2)
| Inequality comparison for IteratorFacade.
template<class T1, class T2, class C, class V1, class V2, class R1, class R2, class P1, class P2, class D>
constexpr auto | operator- (const IteratorFacade< T1, C, V1, R1, P1, D > &it1, const IteratorFacade< T2, C, V2, R2, P2, D > &it2)
| Difference for two IteratorFacade objects.
template<class T1, class T2, class C, class V1, class V2, class R1, class R2, class P1, class P2, class D1, class D2, std::enable_if_t< Dune::models< Impl::Concepts::IterDistanceOp< D1 >, T1, T2 >(), int > = 0>
constexpr bool | operator< (const IteratorFacade< T1, C, V1, R1, P1, D1 > &it1, const IteratorFacade< T2, C, V2, R2, P2, D2 > &it2)
| Comparison for IteratorFacade.
template<class T1, class T2, class C, class V1, class V2, class R1, class R2, class P1, class P2, class D1, class D2, std::enable_if_t< Dune::models< Impl::Concepts::IterDistanceOp< D1 >, T1, T2 >(), int > = 0>
constexpr bool | operator<= (const IteratorFacade< T1, C, V1, R1, P1, D1 > &it1, const IteratorFacade< T2, C, V2, R2, P2, D2 > &it2)
| Comparison for IteratorFacade.
template<class T1, class T2, class C, class V1, class V2, class R1, class R2, class P1, class P2, class D1, class D2, std::enable_if_t< Dune::models< Impl::Concepts::IterDistanceOp< D1 >, T1, T2 >(), int > = 0>
constexpr bool | operator> (const IteratorFacade< T1, C, V1, R1, P1, D1 > &it1, const IteratorFacade< T2, C, V2, R2, P2, D2 > &it2)
| Comparison for IteratorFacade.
template<class T1, class T2, class C, class V1, class V2, class R1, class R2, class P1, class P2, class D1, class D2, std::enable_if_t< Dune::models< Impl::Concepts::IterDistanceOp< D1 >, T1, T2 >(), int > = 0>
constexpr bool | operator>= (const IteratorFacade< T1, C, V1, R1, P1, D1 > &it1, const IteratorFacade< T2, C, V2, R2, P2, D2 > &it2)
| Comparison for IteratorFacade.
template<class T>
constexpr bool | operator== (const MallocAllocator< T > &, const MallocAllocator< T > &)
| check whether allocators are equivalent
template<class T>
constexpr bool | operator!= (const MallocAllocator< T > &, const MallocAllocator< T > &)
| check whether allocators are not equivalent
template<class Base, class Exponent>
constexpr Base | power (Base m, Exponent p)
| Power method for integer exponents.
template<class T>
static constexpr T | factorial (const T &n) noexcept
| calculate the factorial of n as a constexpr
template<class T, T n>
static constexpr auto | factorial (std::integral_constant< T, n >) noexcept
| calculate the factorial of n as a constexpr
template<class T>
static constexpr T | binomial (const T &n, const T &k) noexcept
| calculate the binomial coefficient n over k as a constexpr
template<class T, T n, T k>
static constexpr auto | binomial (std::integral_constant< T, n >, std::integral_constant< T, k >) noexcept
| calculate the binomial coefficient n over k as a constexpr
template<class T, T n>
static constexpr auto | binomial (std::integral_constant< T, n >, std::integral_constant< T, n >) noexcept
template<class K>
constexpr K | conjugateComplex (const K &x)
| compute conjugate complex of x
template<class T>
constexpr int | sign (const T &val)
| Return the sign of the value.
template<class... F>
auto | overload (F &&... f)
| Create an overload set.
template<class... F>
auto | orderedOverload (F &&... f)
| Create an ordered overload set.
bool | operator== (const No_Comm &, const No_Comm &)
| Comparison operator for MPI compatibility.
bool | operator!= (const No_Comm &, const No_Comm &)
| Comparison operator for MPI compatibility.
template<class TG, class TL>
std::ostream & | operator<< (std::ostream &os, const IndexPair< TG, TL > &pair)
| Print an index pair.
template<class TG, class TL>
bool | operator== (const IndexPair< TG, TL > &a, const IndexPair< TG, TL > &b)
template<class TG, class TL>
bool | operator!= (const IndexPair< TG, TL > &a, const IndexPair< TG, TL > &b)
template<class TG, class TL>
bool | operator< (const IndexPair< TG, TL > &a, const IndexPair< TG, TL > &b)
template<class TG, class TL>
bool | operator> (const IndexPair< TG, TL > &a, const IndexPair< TG, TL > &b)
template<class TG, class TL>
bool | operator<= (const IndexPair< TG, TL > &a, const IndexPair< TG, TL > &b)
template<class TG, class TL>
bool | operator>= (const IndexPair< TG, TL > &a, const IndexPair< TG, TL > &b)
template<class TG, class TL>
bool | operator== (const IndexPair< TG, TL > &a, const TG &b)
template<class TG, class TL>
bool | operator!= (const IndexPair< TG, TL > &a, const TG &b)
template<class TG, class TL>
bool | operator< (const IndexPair< TG, TL > &a, const TG &b)
template<class TG, class TL>
bool | operator> (const IndexPair< TG, TL > &a, const TG &b)
template<class TG, class TL>
bool | operator<= (const IndexPair< TG, TL > &a, const TG &b)
template<class TG, class TL>
bool | operator>= (const IndexPair< TG, TL > &a, const TG &b)
template<class TG, class TL, int N>
std::ostream & | operator<< (std::ostream &os, const ParallelIndexSet< TG, TL, N > &indexSet)
| Print an index set.
template<typename TG, typename TA>
bool | operator< (const IndexPair< TG, ParallelLocalIndex< TA > > &i1, const std::pair< TG, TA > &i2)
template<typename TG, typename TA>
bool | operator< (const std::pair< TG, TA > &i1, const IndexPair< TG, ParallelLocalIndex< TA > > &i2)
template<typename TG, typename TA>
bool | operator== (const IndexPair< TG, ParallelLocalIndex< TA > > &i1, const std::pair< TG, TA > &i2)
template<typename TG, typename TA>
bool | operator!= (const IndexPair< TG, ParallelLocalIndex< TA > > &i1, const std::pair< TG, TA > &i2)
template<typename TG, typename TA>
bool | operator== (const std::pair< TG, TA > &i2, const IndexPair< TG, ParallelLocalIndex< TA > > &i1)
template<typename TG, typename TA>
bool | operator!= (const std::pair< TG, TA > &i2, const IndexPair< TG, ParallelLocalIndex< TA > > &i1)
template<typename T, typename A, typename A1>
void | storeGlobalIndicesOfRemoteIndices (std::map< int, SLList< std::pair< typename T::GlobalIndex, typename T::LocalIndex::Attribute >, A > > &globalMap, const RemoteIndices< T, A1 > &remoteIndices)
| Stores the corresponding global indices of the remote index information.
template<typename T, typename A, typename A1>
void | repairLocalIndexPointers (std::map< int, SLList< std::pair< typename T::GlobalIndex, typename T::LocalIndex::Attribute >, A > > &globalMap, RemoteIndices< T, A1 > &remoteIndices, const T &indexSet)
| Repair the pointers to the local indices in the remote indices.
std::ostream & | operator<< (std::ostream &os, const Interface &interface)
| ComposeMPIOp (std::plus, MPI_SUM)
| ComposeMPIOp (std::multiplies, MPI_PROD)
| ComposeMPIOp (Min, MPI_MIN)
| ComposeMPIOp (Max, MPI_MAX)
template<class T>
auto | getMPIData (T &t)
template<class T>
std::ostream & | operator<< (std::ostream &os, const ParallelLocalIndex< T > &index)
| Print the local index to a stream.
template<typename T>
bool | operator== (const ParallelLocalIndex< T > &p1, const ParallelLocalIndex< T > &p2)
template<typename T>
bool | operator!= (const ParallelLocalIndex< T > &p1, const ParallelLocalIndex< T > &p2)
template<typename T1, typename T2>
std::ostream & | operator<< (std::ostream &os, const RemoteIndex< T1, T2 > &index)
template<class T, class A>
std::ostream & | operator<< (std::ostream &os, const RemoteIndices< T, A > &indices)
template<typename TG, typename TA>
std::ostream & | operator<< (std::ostream &os, const RemoteIndex< TG, TA > &index)
std::string | concatPaths (const std::string &base, const std::string &p)
| concatenate two paths
std::string | processPath (const std::string &p)
| sanitize a path for further processing
bool | pathIndicatesDirectory (const std::string &p)
| check whether the given path indicates that it is a directory
std::string | prettyPath (const std::string &p, bool isDirectory)
| pretty print path
std::string | prettyPath (const std::string &p)
| pretty print path
std::string | relativePath (const std::string &newbase, const std::string &p)
| compute a relative path between two paths
template<typename T1, std::size_t t1, typename T2, std::size_t t2>
bool | operator== (const PoolAllocator< T1, t1 > &, const PoolAllocator< T2, t2 > &)
template<typename T1, std::size_t t1, typename T2, std::size_t t2>
bool | operator!= (const PoolAllocator< T1, t1 > &, const PoolAllocator< T2, t2 > &)
template<typename T, std::size_t t1, std::size_t t2>
bool | operator== (const PoolAllocator< T, t1 > &p1, const PoolAllocator< T, t2 > &p2)
template<typename T, std::size_t t1, std::size_t t2>
bool | operator!= (const PoolAllocator< T, t1 > &p1, const PoolAllocator< T, t2 > &p2)
template<typename T, std::size_t t1, std::size_t t2>
bool | operator== (const PoolAllocator< void, t1 > &, const PoolAllocator< T, t2 > &)
template<typename T, std::size_t t1, std::size_t t2>
bool | operator!= (const PoolAllocator< void, t1 > &, const PoolAllocator< T, t2 > &)
template<std::size_t t1, std::size_t t2>
bool | operator== (const PoolAllocator< void, t1 > &p1, const PoolAllocator< void, t2 > &p2)
template<std::size_t t1, std::size_t t2>
bool | operator!= (const PoolAllocator< void, t1 > &p1, const PoolAllocator< void, t2 > &p2)
template<class Reference, class PropertyMap, class Key>
Reference | get (const RAPropertyMapHelper< Reference, PropertyMap > &pmap, const Key &key)
template<class Reference, class PropertyMap, class Key, class Value>
void | put (const RAPropertyMapHelper< Reference, PropertyMap > &pmap, const Key &key, const Value &value)
template<typename T>
pointer_or_proxy_holder | handle_proxy_member_access (T &&t)
| Transparent support for providing member access to both lvalues and rvalues (temporary proxies).
template<typename T, typename std::enable_if< IsIterable< T >::value, int >::type = 0>
T::value_type | max_value (const T &v)
| compute the maximum value over a range
template<typename T, typename std::enable_if<!IsIterable< T >::value, int >::type = 0>
const T & | max_value (const T &v)
template<typename T, typename std::enable_if< IsIterable< T >::value, int >::type = 0>
T::value_type | min_value (const T &v)
| compute the minimum value over a range
template<typename T, typename std::enable_if<!IsIterable< T >::value, int >::type = 0>
const T & | min_value (const T &v)
template<typename T, typename std::enable_if< IsIterable< T >::value, int >::type = 0>
bool | any_true (const T &v)
| similar to std::bitset<N>::any() return true, if any entries is true
template<std::size_t N>
bool | any_true (const std::bitset< N > &b)
template<typename T, typename std::enable_if< IsIterable< T >::value, int >::type = 0>
bool | all_true (const T &v)
| similar to std::bitset<N>::all() return true, if any entries is true
template<std::size_t N>
bool | all_true (const std::bitset< N > &b)
template<class T, class U, std::enable_if_t< std::is_same< std::decay_t< T >, std::decay_t< U > >::value, int > = 0, std::enable_if_t< std::is_integral< std::decay_t< T > >::value, int > = 0>
static constexpr IntegralRange< std::decay_t< T > > | range (T &&from, U &&to) noexcept
| free standing function for setting up a range based for loop over an integer range for (auto i: range(0,10)) // 0,1,2,3,4,5,6,7,8,9 or for (auto i: range(-10,10)) // -10,-9,..,8,9 or for (auto i: range(10)) // 0,1,2,3,4,5,6,7,8,9
template<class T, std::enable_if_t< std::is_integral< std::decay_t< T > >::value, int > = 0>
static constexpr IntegralRange< std::decay_t< T > > | range (T &&to) noexcept
template<class T, std::enable_if_t< std::is_enum< std::decay_t< T > >::value, int > = 0>
static constexpr IntegralRange< std::underlying_type_t< std::decay_t< T > > > | range (T &&to) noexcept
template<class T, T from, T to>
static constexpr StaticIntegralRange< T, to, from > | range (std::integral_constant< T, from >, std::integral_constant< T, to >) noexcept
template<class T, T to>
static constexpr StaticIntegralRange< T, to > | range (std::integral_constant< T, to >) noexcept
template<class R, class F>
auto | transformedRangeView (R &&range, F &&f)
| Create a TransformedRangeView.
template<class R, class F>
auto | iteratorTransformedRangeView (R &&range, F &&f)
| Create a TransformedRangeView using an iterator transformation.
template<class Range>
auto | sparseRange (Range &&range)
| Allow structured-binding for-loops for sparse iterators.
template<class T>
constexpr T & | resolveRef (T &gf) noexcept
| Helper function to resolve std::reference_wrapper.
template<class T>
const auto & | resolveRef (T &&gf)=delete
template<class T>
constexpr T & | resolveRef (std::reference_wrapper< T > gf) noexcept
| Helper function to resolve std::reference_wrapper.
template<typename T>
std::shared_ptr< T > | stackobject_to_shared_ptr (T &t)
| Create a shared_ptr for a stack-allocated object.
template<class T>
auto | wrap_or_move (T &&t)
| Capture R-value reference to shared_ptr.
template<class T>
auto | wrap_or_move (T &t)
| Capture L-value reference to std::shared_ptr.
template<class T>
std::size_t | lanes (const T &)
| get the number of lanes of a simd vector (scalar version)
template<class T>
T | lane (std::size_t l, const T &v)
| access a lane of a simd vector (scalar version)
template<class T>
T & | lane (std::size_t l, T &v)
| access a lane of a simd vector (scalar version)
template<class T>
void | assign (T &dst, const T &src, bool mask)
| masked Simd assignment (scalar version)
template<class T>
void | swap (T &v1, T &v2, bool mask)
| DUNE_SIMD_LOOP_BINARY_OP (+)
| DUNE_SIMD_LOOP_BINARY_OP (-)
DUNE_SIMD_LOOP_BINARY_OP * | DUNE_SIMD_LOOP_BINARY_OP (/);DUNE_SIMD_LOOP_BINARY_OP(%
DUNE_SIMD_LOOP_BINARY_OP & | DUNE_SIMD_LOOP_BINARY_OP (|);DUNE_SIMD_LOOP_BINARY_OP(^
| DUNE_SIMD_LOOP_BITSHIFT_OP (<<)
| DUNE_SIMD_LOOP_BITSHIFT_OP (> >)
| DUNE_SIMD_LOOP_COMPARISON_OP (<)
| DUNE_SIMD_LOOP_COMPARISON_OP (<=)
| DUNE_SIMD_LOOP_COMPARISON_OP (>=)
| DUNE_SIMD_LOOP_COMPARISON_OP (!=)
DUNE_SIMD_LOOP_BOOLEAN_OP && | DUNE_SIMD_LOOP_BOOLEAN_OP (||);template< class T, std::size_t S, std::size_t A > std::ostream &operator<<(std::ostream &os, const LoopSIMD< T, S, A > &v
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (cos)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (sin)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (tan)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (acos)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (asin)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (atan)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (cosh)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (sinh)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (tanh)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (acosh)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (asinh)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (atanh)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (exp)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (log)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (log10)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (exp2)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (expm1)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN (ilogb, int)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (log1p)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (log2)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (logb)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (sqrt)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (cbrt)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (erf)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (erfc)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (tgamma)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (lgamma)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (ceil)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (floor)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (trunc)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (round)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN (lround, long)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN (llround, long long)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (rint)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN (lrint, long)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN (llrint, long long)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (nearbyint)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (fabs)
| DUNE_SIMD_LOOP_CMATH_UNARY_OP (abs)
| DUNE_SIMD_LOOP_STD_UNARY_OP (real)
| DUNE_SIMD_LOOP_STD_UNARY_OP (imag)
| DUNE_SIMD_LOOP_STD_BINARY_OP (max)
| DUNE_SIMD_LOOP_STD_BINARY_OP (min)
template<typename T, typename A>
std::ostream & | operator<< (std::ostream &os, const SLList< T, A > &sllist)
void | doAssertCallOnce (const char *file, int line, const char *function)
void | assertCallOnce (const char *file=nullptr, int line=-1, const char *function=nullptr)
| Make sure call_once() works and provide a helpful error message otherwise.
template<typename... Ts>
std::ostream & | operator<< (std::ostream &stream, const std::tuple< Ts... > &t)
| Print a std::tuple.
template<typename... Ts>
std::istream & | operator>> (std::istream &stream, std::tuple< Ts... > &t)
| Read a std::tuple.
template<typename T, std::size_t N>
std::ostream & | operator<< (std::ostream &stream, const std::array< T, N > &a)
| Print a std::array.
template<typename C>
bool | hasPrefix (const C &c, const char *prefix)
| Check whether a character container has a given prefix.
template<typename C>
bool | hasSuffix (const C &c, const char *suffix)
| Check whether a character container has a given suffix.
template<class... T>
static std::string | formatString (const std::string &s, const T &... args)
| Format values according to printf format string.
template<class Matrix, std::enable_if_t< Impl::HasMemberFunctionTransposed< Matrix >::value, int > = 0>
auto | transpose (const Matrix &matrix)
| Return the transposed of the given matrix.
template<class Matrix, std::enable_if_t< not Impl::HasMemberFunctionTransposed< std::decay_t< Matrix > >::value, int > = 0>
auto | transpose (Matrix &&matrix)
| Create a wrapper modelling the transposed matrix.
template<class Matrix>
auto | transpose (const std::reference_wrapper< Matrix > &matrix)
| Create a wrapper modelling the transposed matrix.
template<class Matrix>
auto | transposedView (const Matrix &matrix)
| Create a view modelling the transposed matrix.
template<class F, class ArgTuple, class I, I... i>
decltype(auto) | applyPartial (F &&f, ArgTuple &&args, std::integer_sequence< I, i... >)
| Apply function with arguments from a given tuple.
template<class Tuple, class Functor>
auto | genericTransformTuple (Tuple &&t, Functor &&f) -> decltype(genericTransformTupleBackend(t, f))
template<template< class > class TE, class... Args>
TransformTupleFunctor< TE, Args... > | makeTransformTupleFunctor (Args &&... args)
template<template< class > class TypeEvaluator, class Tuple, class... Args>
auto | transformTuple (Tuple &&orig, Args &&... args) -> decltype(genericTransformTuple(orig, makeTransformTupleFunctor< TypeEvaluator >(args...)))
template<class... T>
constexpr auto | makeTupleVector (T &&... t)
template<class... T>
constexpr auto | uniqueTypeList (TypeList< T... >)
| Remove duplicates from a Dune::TypeList.
template<class T, T... t, std::size_t index>
constexpr auto | integerSequenceEntry (std::integer_sequence< T, t... >, std::integral_constant< std::size_t, index > i)
| Get entry of std::integer_sequence.
template<class T>
constexpr AutonomousValue< T > | autoCopy (T &&v)
| Autonomous copy of an expression's value for use in auto type deduction.
template<typename V>
std::ostream & | operator<< (std::ostream &s, const DenseVector< V > &v)
| Write a DenseVector to an output stream.
template<class K, class Allocator>
std::istream & | operator>> (std::istream &in, DynamicVector< K, Allocator > &v)
| Read a DynamicVector from an input stream.
template<class K, int SIZE>
std::istream & | operator>> (std::istream &in, FieldVector< K, SIZE > &v)
| Read a FieldVector from an input stream.
template<typename T>
std::shared_ptr< T > | stackobject_to_shared_ptr (T &t)
| Create a shared_ptr for a stack-allocated object.

## Variables

static constexpr auto | debugAlignment = 2*alignof(std::max_align_t)
| an alignment large enough to trigger alignment errors
template<typename Type, typename BinaryFunction, typename Enable>
std::unique_ptr< MPI_Op > | Generic_MPI_Op< Type, BinaryFunction, Enable >::op
template<class T>
MPI_Datatype | MPITraits< T >::datatype = MPI_DATATYPE_NULL
template<typename T>
MPI_Datatype | MPITraits< ParallelLocalIndex< T > >::type = MPI_DATATYPE_NULL
template<typename TG, typename TA>
MPI_Datatype | MPITraits< IndexPair< TG, ParallelLocalIndex< TA > > >::type =MPI_DATATYPE_NULL
template<class ctype>
ctype | FMatrixPrecision< ctype >::_absolute = 1E-80
template<class T>
constexpr bool | IsReferenceWrapper_v = Impl::IsReferenceWrapper<T>::value
| Helper to detect if given type is a std::reference_wrapper.
DVVerbType | dvverb (std::cout)
| stream for very verbose output.
DVerbType | dverb (std::cout)
| Singleton of verbose debug stream.
DInfoType | dinfo (std::cout)
| Stream for informative output.
DWarnType | dwarn (std::cerr)
| Stream for warnings indicating problems.
DGraveType | dgrave (std::cerr)
| Stream for warnings indicating fatal errors.
DErrType | derr (std::cerr)
| Stream for error messages.
static const DebugLevel | MINIMAL_DEBUG_LEVEL = DUNE_MINIMAL_DEBUG_LEVEL
static const DebugLevel | VERY_VERBOSE_DEBUG_LEVEL = 1
| The level of the very verbose debug stream.
static const DebugLevel | VERBOSE_DEBUG_LEVEL = 2
| The level of the verbose debug stream.
static const DebugLevel | INFO_DEBUG_LEVEL = 3
| The level of the informative debug stream.
static const DebugLevel | WARN_DEBUG_LEVEL = 4
| The level of the debug stream for warnings.
static const DebugLevel | GRAVE_DEBUG_LEVEL = 5
| The level of the debug stream for fatal errors.

## Detailed Description

Dune namespace

## Typedef Documentation

## detected_or_fallback_t

template<template< typename... > class Fallback, template< typename... > class TargetType, typename... Args>

using Dune::detected_or_fallback_t

Initial value:
Std::detected_or_t<decltype(
detail::warningIfNotDefined<Std::detected_t<Fallback, Args...> >(std::declval<const Std::detected_t<TargetType, Args...>*>())),
TargetType, Args...>
Dune::Std::detected_t
typename detected_or< nonesuch, Op, Args... >::type detected_t
Returns Op<Args...> if that is valid; otherwise returns nonesuch.
Definition type_traits.hh:170
Dune::Std::detected_or_t
typename detected_or< Default, Op, Args... >::type detected_or_t
Returns Op<Args...> if that is valid; otherwise returns the fallback type Default.
Definition type_traits.hh:185

This type will be either TargetType<Args...> if it exists, or the Fallback<Args...> type.

## SimdIndex

template<typename V>

using Dune::SimdIndex = typename SimdIndexTypeTraits<V>::type

An simd vector of indices corresponding to a simd vector V.

lanes(T()) == lanes(SimdIndex<T>()) holds.

Note
  The size of the elements of a SimdIndex isn't very well-defined. Be careful.

## SimdMask

template<typename V>

using Dune::SimdMask = typename SimdMaskTypeTraits<V>::type

A simd vector of truth values corresponding to a simd vector V.

lanes(T()) == lanes(SimdMask<T>()) holds.

## SimdScalar

template<typename T>

using Dune::SimdScalar = typename SimdScalarTypeTraits<T>::type

## TypeListEntry_t

template<std::size_t i, class T>

using Dune::TypeListEntry_t = typename TypeListElement<i, T>::type

Shortcut for TypeListElement<i, T>::type;.

## UniqueTypeList_t

template<class NonUniqueTypeList>

using Dune::UniqueTypeList_t = typename Impl::UniqueTypesHelper<TypeList, NonUniqueTypeList>::type

Remove duplicates from a Dune::TypeList.

For a given Dune::TypeList<T...> this is an alias for Dune::TypeList<S...>, where S... is generated by removing duplicate types from T... .

## UniqueTypes_t

template<template< class... > class Target, class... T>

using Dune::UniqueTypes_t = typename Impl::UniqueTypesHelper<Target, TypeList<T...>>::type

Remove duplicates from a list of types.

For a given list of types T... instantiate Target<S...>, where S... is generated by removing duplicate types from T... . This is useful for std::variant which does not like to be instantiated with duplicate types.

## UnpackTypeList_t

template<template< class... > class Target, class TL>

using Dune::UnpackTypeList_t = typename Impl::UnpackTypeList<Target, TL>::type

Unpack Dune::TypeList.

For a given Dune::TypeList<T...> this is an alias for Target<T...>.

## ViolatedAlignmentHandler

using Dune::ViolatedAlignmentHandler

Initial value:
std::function<void(const char*, std::size_t, const void*)>

type of the handler called by violatedAlignment()

## Enumeration Type Documentation

## anonymous enum

anonymous enum

Enumerator

implementationDefined

Dummy integral value used for documentation purposes.

#include <dune/common/documentation.hh>
documentation.hh
Documentation related stuff.

See also
  ImplementationDefined

## Function Documentation

## accumulate_back()

template<typename I, typename... T>
requires (sizeof...(T) > 0)

auto Dune::accumulate_back | ( | const HybridMultiIndex< T... > & | tp,
|  | I | i )

nodiscard constexpr

Hybrid utility that accumulates to the back of a multi-index.

The back of the multi-index will be accumulated and promoted in order to hold the new index:

accumulate_back(HybridMultiIndex(_0,_2),_2) -> HybridMultiIndex(_0,_4)
accumulate_back(HybridMultiIndex(_0,_2), 2) -> HybridMultiIndex(_0, 4)
accumulate_back(HybridMultiIndex(_0, 2),_2) -> HybridMultiIndex(_0, 4)
accumulate_back(HybridMultiIndex(_0, 2), 2) -> HybridMultiIndex(_0, 4)
Dune::HybridMultiIndex
HybridMultiIndex(I... i) -> HybridMultiIndex< decltype(Impl::castToHybridSizeT(i))... >
Dune::accumulate_back
constexpr auto accumulate_back(const HybridMultiIndex< T... > &tp, I i)
Hybrid utility that accumulates to the back of a multi-index.
Definition hybridmultiindex.hh:328
Dune::HybridMultiIndex
A hybrid multi-index class that supports both compile time and run time indices.
Definition hybridmultiindex.hh:81

## accumulate_front()

template<typename I, typename... T>
requires (sizeof...(T) > 0)

auto Dune::accumulate_front | ( | const HybridMultiIndex< T... > & | tp,
|  | I | i )

nodiscard constexpr

Hybrid utility that accumulates to the front of a multi-index.

The front of the multi-index will be accumulated and promoted in order to hold the new index:

accumulate_front(HybridMultiIndex(_0,_2),_2) -> HybridMultiIndex(_2,_2)
accumulate_front(HybridMultiIndex(_0,_2), 2) -> HybridMultiIndex( 2,_2)
accumulate_front(HybridMultiIndex( 0,_2),_2) -> HybridMultiIndex( 2,_2)
accumulate_front(HybridMultiIndex( 0,_2), 2) -> HybridMultiIndex( 2,_2)
Dune::accumulate_front
constexpr auto accumulate_front(const HybridMultiIndex< T... > &tp, I i)
Hybrid utility that accumulates to the front of a multi-index.
Definition hybridmultiindex.hh:348

## aligned()

template<std::size_t align = debugAlignment, class T>

AlignedNumber< T, align > Dune::aligned | ( | T | value | ) |

align a value to a certain alignment

## all_true()

template<std::size_t align>

bool Dune::all_true | ( | const AlignedNumber< bool, align > & | val | ) |

## any_true()

template<std::size_t align>

bool Dune::any_true | ( | const AlignedNumber< bool, align > & | val | ) |

## assertCallOnce()

void Dune::assertCallOnce | ( | const char * | file = nullptr,
|  | int | line = -1,
|  | const char * | function = nullptr )

inline

Make sure call_once() works and provide a helpful error message otherwise.

For call_once() to work, certain versions of libstdc++ need to be linked with -pthread or similar flags. If that is not the case, call_once() will throw an exception. This function checks that call_once() can indeed be used, i.e. that it does not throw an exception when it should not, and that the code does indeed get executed. If call_once() cannot be used, assertCallOnce() aborts the program with a helpful error message.

The check is only actually executed the first time assertCallOnce() is called.

The arguments `file` and `line` specify the filename and line number that should appear in the error message. They are ignored if `file` is

1. The argument `function` specifies the name of the function to appear in the error message. It is ignored if `function` is 0.

## assign()

template<class T>

void Dune::assign | ( | T & | dst,
|  | const T & | src,
|  | bool | mask )

masked Simd assignment (scalar version)

Assign `src` to `dest` for those lanes where `mask` is true.

## back() [1/2]

template<typename... T>

auto Dune::back | ( | const HybridMultiIndex< T... > & | tp | ) | ->decltype(tp.back())

nodiscard constexpr

Returns a copy of the last element of the HybridMultiIndex.

As HybridMultiIndex instances should not be mutated after their creation, this function returns a copy of the value. As values are either std::integral_constant or std::size_t, that's just as cheap as returning a reference.

## back() [2/2]

template<class T, T... II, std::enable_if_t<(sizeof...(II) > 0), int > = 0>

auto Dune::back | ( | std::integer_sequence< T, II... > | seq | ) |

constexpr

Return the last entry of the sequence.

## binomial() [1/3]

template<class T>

constexpr T Dune::binomial | ( | const T & | n,
|  | const T & | k )

inline static constexpr noexcept

calculate the binomial coefficient n over k as a constexpr

## binomial() [2/3]

template<class T, T n, T k>

constexpr auto Dune::binomial | ( | std::integral_constant< T, n > | ,
|  | std::integral_constant< T, k > | )

inline static constexpr noexcept

calculate the binomial coefficient n over k as a constexpr

## binomial() [3/3]

template<class T, T n>

constexpr auto Dune::binomial | ( | std::integral_constant< T, n > | ,
|  | std::integral_constant< T, n > | )

inline static constexpr noexcept

## className() [1/2]

template<class T>

std::string Dune::className | ( |  | ) |

Provide the demangled class name of a type T as a string.

## className() [2/2]

template<class T>

std::string Dune::className | ( | T && | v | ) |

Provide the demangled class name of a given object as a string.

## ComposeMPIOp() [1/4]

Dune::ComposeMPIOp | ( | Max | ,
|  | MPI_MAX | )

## ComposeMPIOp() [2/4]

Dune::ComposeMPIOp | ( | Min | ,
|  | MPI_MIN | )

## ComposeMPIOp() [3/4]

Dune::ComposeMPIOp | ( | std::multiplies | ,
|  | MPI_PROD | )

## ComposeMPIOp() [4/4]

Dune::ComposeMPIOp | ( | std::plus | ,
|  | MPI_SUM | )

## cond() [1/2]

template<typename T1, typename T2>

const T1 Dune::cond | ( | bool | b,
|  | const T1 & | v1,
|  | const T2 & | v2 )

conditional evaluate

sometimes call immediate if, evaluates to

if (b)
return v1;
else
return v2;

In contrast to if-then-else the cond function can also be evaluated for vector valued SIMD data types, see simd.hh.

Parameters

  b | boolean value
  v1 | value of b==true
  v2 | value of b==false

## cond() [2/2]

template<class T, std::size_t align>

AlignedNumber< T, align > Dune::cond | ( | const AlignedNumber< bool, align > & | b,
|  | const AlignedNumber< T, align > & | v1,
|  | const AlignedNumber< T, align > & | v2 )

## conjugateComplex()

template<class K>

K Dune::conjugateComplex | ( | const K & | x | ) |

constexpr

compute conjugate complex of x

## contains()

template<class T, T... II, T value>

std::bool_constant<((II==value)||...)> Dune::contains | ( | std::integer_sequence< T, II... > | ,
|  | std::integral_constant< T, value > | )

constexpr

Checks whether or not a given sequence contains a value.

## defaultViolatedAlignment()

void Dune::defaultViolatedAlignment | ( | const char * | className,
|  | std::size_t | expectedAlignment,
|  | const void * | address )

static

default alignment violation handler

Prints it's arguments on stderr and aborts.

## difference() [1/2]

template<class T, T... II, T... JJ>

auto Dune::difference | ( | std::integer_sequence< T, II... > | iSeq,
|  | std::integer_sequence< T, JJ... > | jSeq )

constexpr

Return the elements from the sequence [II...) which are not found in the sequence [JJ...).

## difference() [2/2]

template<std::size_t N, class T, T... JJ, std::enable_if_t<(N >=sizeof...(JJ)), int > = 0>

auto Dune::difference | ( | std::integer_sequence< T, JJ... > | jSeq | ) |

constexpr

Return the elements from the sequence [0,1,...N) which are not found in the sequence [JJ...).

## doAssertCallOnce()

void Dune::doAssertCallOnce | ( | const char * | file,
|  | int | line,
|  | const char * | function )

## DUNE_SIMD_LOOP_BINARY_OP() [1/4]

Dune::DUNE_SIMD_LOOP_BINARY_OP | ( | + |  | ) |

## DUNE_SIMD_LOOP_BINARY_OP() [2/4]

Dune::DUNE_SIMD_LOOP_BINARY_OP | ( | - |  | ) |

## DUNE_SIMD_LOOP_BINARY_OP() [3/4]

DUNE_SIMD_LOOP_BINARY_OP * Dune::DUNE_SIMD_LOOP_BINARY_OP | ( | / |  | ) |

## DUNE_SIMD_LOOP_BINARY_OP() [4/4]

DUNE_SIMD_LOOP_BINARY_OP & Dune::DUNE_SIMD_LOOP_BINARY_OP | ( | | |  | ) |

## DUNE_SIMD_LOOP_BITSHIFT_OP() [1/2]

Dune::DUNE_SIMD_LOOP_BITSHIFT_OP | ( | << |  | ) |

## DUNE_SIMD_LOOP_BITSHIFT_OP() [2/2]

Dune::DUNE_SIMD_LOOP_BITSHIFT_OP | ( |  | ) |

## DUNE_SIMD_LOOP_BOOLEAN_OP()

DUNE_SIMD_LOOP_BOOLEAN_OP && Dune::DUNE_SIMD_LOOP_BOOLEAN_OP | ( | || |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [1/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | abs |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [2/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | acos |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [3/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | acosh |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [4/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | asin |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [5/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | asinh |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [6/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | atan |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [7/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | atanh |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [8/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | cbrt |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [9/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | ceil |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [10/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | cos |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [11/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | cosh |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [12/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | erf |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [13/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | erfc |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [14/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | exp |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [15/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | exp2 |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [16/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | expm1 |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [17/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | fabs |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [18/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | floor |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [19/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | lgamma |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [20/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | log |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [21/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | log10 |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [22/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | log1p |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [23/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | log2 |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [24/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | logb |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [25/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | nearbyint |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [26/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | rint |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [27/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | round |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [28/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | sin |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [29/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | sinh |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [30/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | sqrt |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [31/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | tan |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [32/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | tanh |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [33/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | tgamma |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP() [34/34]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP | ( | trunc |  | ) |

## DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN() [1/5]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN | ( | ilogb | ,
|  | int | )

## DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN() [2/5]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN | ( | llrint | ,
|  | long long | )

## DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN() [3/5]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN | ( | llround | ,
|  | long long | )

## DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN() [4/5]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN | ( | lrint | ,
|  | long | )

## DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN() [5/5]

Dune::DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN | ( | lround | ,
|  | long | )

## DUNE_SIMD_LOOP_COMPARISON_OP() [1/4]

Dune::DUNE_SIMD_LOOP_COMPARISON_OP | ( | ! |  | ) |

## DUNE_SIMD_LOOP_COMPARISON_OP() [2/4]

Dune::DUNE_SIMD_LOOP_COMPARISON_OP | ( |  | ) |

## DUNE_SIMD_LOOP_COMPARISON_OP() [3/4]

Dune::DUNE_SIMD_LOOP_COMPARISON_OP | ( | <= |  | ) |

## DUNE_SIMD_LOOP_COMPARISON_OP() [4/4]

Dune::DUNE_SIMD_LOOP_COMPARISON_OP | ( | >= |  | ) |

## DUNE_SIMD_LOOP_STD_BINARY_OP() [1/2]

Dune::DUNE_SIMD_LOOP_STD_BINARY_OP | ( | max |  | ) |

## DUNE_SIMD_LOOP_STD_BINARY_OP() [2/2]

Dune::DUNE_SIMD_LOOP_STD_BINARY_OP | ( | min |  | ) |

## DUNE_SIMD_LOOP_STD_UNARY_OP() [1/2]

Dune::DUNE_SIMD_LOOP_STD_UNARY_OP | ( | imag |  | ) |

## DUNE_SIMD_LOOP_STD_UNARY_OP() [2/2]

Dune::DUNE_SIMD_LOOP_STD_UNARY_OP | ( | real |  | ) |

## empty()

template<class T, T... II>

std::bool_constant<(sizeof...(II)==0)> Dune::empty | ( | std::integer_sequence< T, II... > |  | ) |

constexpr

Checks whether the sequence is empty.

## equal() [1/2]

template<class S, S... II, class T, T... JJ, std::enable_if_t<(sizeof...(II) !=sizeof...(JJ)), int > = 0>

std::bool_constant< false > Dune::equal | ( | std::integer_sequence< S, II... > | ,
|  | std::integer_sequence< T, JJ... > | )

constexpr

Sequences are unequal if not of the same length.

## equal() [2/2]

template<class S, S... II, class T, T... JJ, std::enable_if_t<(sizeof...(II)==sizeof...(JJ)), int > = 0, class ST = std::common_type_t<S,T>>

std::is_same< std::integer_sequence< bool, true,(ST(II)==ST(JJ))... >, std::integer_sequence< bool,(ST(II)==ST(JJ))..., true > > Dune::equal | ( | std::integer_sequence< S, II... > | ,
|  | std::integer_sequence< T, JJ... > | )

constexpr

Checks whether two sequences are identical.

## factorial() [1/2]

template<class T>

constexpr T Dune::factorial | ( | const T & | n | ) |

inline static constexpr noexcept

calculate the factorial of n as a constexpr

## factorial() [2/2]

template<class T, T n>

constexpr auto Dune::factorial | ( | std::integral_constant< T, n > |  | ) |

inline static constexpr noexcept

calculate the factorial of n as a constexpr

## filter() [1/4]

template<class Filter, class T, T J0, T... JJ>

auto Dune::filter | ( | Filter | f,
|  | std::integer_sequence< T, J0, JJ... > | jSeq )

constexpr

Return the elements from the sequence [JJ...) which are accepted by the Filter, i.e., for which f(integral_constant<JJ>) == true

## filter() [2/4]

template<class Filter, class T>

auto Dune::filter | ( | Filter | ,
|  | std::integer_sequence< T > | jSeq )

constexpr

## filter() [3/4]

template<template< auto > class Filter, class T>

auto Dune::filter | ( | std::integer_sequence< T > | jSeq | ) |

constexpr

## filter() [4/4]

template<template< auto > class Filter, class T, T J0, T... JJ>

auto Dune::filter | ( | std::integer_sequence< T, J0, JJ... > | jSeq | ) |

constexpr

Return the elements from the sequence [JJ...) which are accepted by the Filter, i.e., for which Filter<JJ>::value == true

## front() [1/2]

template<typename... T>

auto Dune::front | ( | const HybridMultiIndex< T... > & | tp | ) | ->decltype(tp.front())

nodiscard constexpr

Returns a copy of the first element of the HybridMultiIndex.

As HybridMultiIndex instances should not be mutated after their creation, this function returns a copy of the value. As values are either std::integral_constant or std::size_t, that's just as cheap as returning a reference.

## front() [2/2]

template<class T, T I0, T... II>

std::integral_constant< T, I0 > Dune::front | ( | std::integer_sequence< T, I0, II... > |  | ) |

constexpr

Return the first entry of the sequence.

## get() [1/3]

template<class Reference, class PropertyMap, class Key>

Reference Dune::get | ( | const RAPropertyMapHelper< Reference, PropertyMap > & | pmap,
|  | const Key & | key )

inline

## get() [2/3]

template<std::size_t pos, class T, T... II, std::enable_if_t<(!(pos >=sizeof...(II))), int > = 0>

auto Dune::get | ( | std::integer_sequence< T, II... > | ,
|  | std::integral_constant< std::size_t, pos > | = {} )

constexpr

Return the entry at position pos of the given sequence.

## get() [3/3]

template<class T, T... II>

T Dune::get | ( | std::integer_sequence< T, II... > | ,
|  | std::size_t | pos )

constexpr

Return the entry at position pos of the given sequence.

## getMPIData()

template<class T>

auto Dune::getMPIData | ( | T & | t | ) |

## hash_combine()

template<typename T>

void Dune::hash_combine | ( | std::size_t & | seed,
|  | const T & | arg )

inline

Calculates the hash value of arg and combines it in-place with seed.

Parameters

  seed | The hash value that will be combined with the hash of arg.
  arg | The object for which to calculate a hash value and combine it with seed.

## hash_range() [1/2]

template<typename It>

std::size_t Dune::hash_range | ( | It | first,
|  | It | last )

inline

Hashes all elements in the range [first,last) and returns the combined hash.

Parameters

  first | Iterator pointing to the first object to hash.
  last | Iterator pointing one past the last object to hash.

Returns
  The result of hashing all objects in the range and combining them using hash_combine() in sequential fashion, starting with seed 0.

## hash_range() [2/2]

template<typename It>

void Dune::hash_range | ( | std::size_t & | seed,
|  | It | first,
|  | It | last )

inline

Hashes all elements in the range [first,last) and combines the hashes in-place with seed.

Parameters

  seed | Start value that will be combined with the hash values of all objects in the range using hash_combine() in sequential fashion.
  first | Iterator pointing to the first object to hash.
  last | Iterator pointing one past the last object to hash.

## head()

template<class T, T I0, T... II>

std::integral_constant< T, I0 > Dune::head | ( | std::integer_sequence< T, I0, II... > |  | ) |

constexpr

For a sequence [head,tail...) return the single head element.

## HybridMultiIndex() [1/2]

template<typename... I>
requires (((std::is_integral_v<I> or Dune::IsIntegralConstant<I>::value) && ...))

Dune::HybridMultiIndex | ( | I... | i | ) | ->HybridMultiIndex< decltype(Impl::castToHybridSizeT(i))... >

## HybridMultiIndex() [2/2]

template<typename... I>

Dune::HybridMultiIndex | ( | std::tuple< I... > |  | ) | ->HybridMultiIndex< I... >

## isAligned()

bool Dune::isAligned | ( | const void * | p,
|  | std::size_t | align )

inline

check whether an address conforms to the given alignment

## join()

template<class... Head, class... Other>

auto Dune::join | ( | const HybridMultiIndex< Head... > & | head,
|  | const Other &... | tail )

nodiscard constexpr

Join two hybrid multi-indices into one.

## lane() [1/2]

template<class T>

T Dune::lane | ( | std::size_t | l,
|  | const T & | v )

access a lane of a simd vector (scalar version)

## lane() [2/2]

template<class T>

T & Dune::lane | ( | std::size_t | l,
|  | T & | v )

access a lane of a simd vector (scalar version)

## lanes()

template<class T>

std::size_t Dune::lanes | ( | const T & |  | ) |

get the number of lanes of a simd vector (scalar version)

## makeTupleVector()

template<class... T>

auto Dune::makeTupleVector | ( | T &&... | t | ) |

constexpr

## max_value() [1/2]

template<class T, std::size_t align>

T Dune::max_value | ( | const AlignedNumber< T, align > & | val | ) |

## max_value() [2/2]

template<typename T, typename std::enable_if<!IsIterable< T >::value, int >::type = 0>

const T & Dune::max_value | ( | const T & | v | ) |

## min_value() [1/2]

template<class T, std::size_t align>

T Dune::min_value | ( | const AlignedNumber< T, align > & | val | ) |

## min_value() [2/2]

template<typename T, typename std::enable_if<!IsIterable< T >::value, int >::type = 0>

const T & Dune::min_value | ( | const T & | v | ) |

## operator!=() [1/4]

template<class... S, class... T>

auto Dune::operator!= | ( | const HybridMultiIndex< S... > & | lhs,
|  | const HybridMultiIndex< T... > & | rhs )

nodiscard constexpr

Compare two HybridMultiIndexs for inequality.

## operator!=() [2/4]

template<class S, S... lhs, class T, T... rhs>

auto Dune::operator!= | ( | const HybridMultiIndex< std::integral_constant< S, lhs >... > & | ,
|  | const HybridMultiIndex< std::integral_constant< T, rhs >... > & | )

nodiscard constexpr

Compare two static HybridMultiIndexs for inequality.

## operator!=() [3/4]

template<class T>

bool Dune::operator!= | ( | const MallocAllocator< T > & | ,
|  | const MallocAllocator< T > & | )

constexpr

check whether allocators are not equivalent

## operator!=() [4/4]

bool Dune::operator!= | ( | const No_Comm & | ,
|  | const No_Comm & | )

inline

Comparison operator for MPI compatibility.

Always returns false.

## operator<<() [1/2]

template<typename... T>

std::ostream & Dune::operator<< | ( | std::ostream & | os,
|  | const HybridMultiIndex< T... > & | tp )

Dumps a HybridMultiIndex to a stream.

## operator<<() [2/2]

std::ostream & Dune::operator<< | ( | std::ostream & | os,
|  | const Interface & | interface )

inline

## operator==() [1/5]

template<class T1, class V1, class R1, class D, class T2, class V2, class R2>

std::enable_if< std::is_convertible< T1, T2 >::value &&!std::is_convertible< T2, T1 >::value, bool >::type Dune::operator== | ( | const BidirectionalIteratorFacade< T1, V1, R1, D > & | lhs,
|  | const BidirectionalIteratorFacade< T2, V2, R2, D > & | rhs )

constexpr

Checks for equality.

This operation is only defined if either T1 is convertible to T2, and T2 is not convetible to T1. Otherwise the operator is removed from the overload set since the enable_if for the return type yield an invalid type expression.

## operator==() [2/5]

template<class... S, class... T>

bool Dune::operator== | ( | const HybridMultiIndex< S... > & | lhs,
|  | const HybridMultiIndex< T... > & | rhs )

nodiscard constexpr

Compare two HybridMultiIndexs for value equality.

The function returns true if both hybrid multi-indices are of the same length and all entries have the same value.

Note, it might be that the values are represented with different types. To check for same value and same type, use a combination of std::is_same and this comparison operator.

## operator==() [3/5]

template<class S, S... lhs, class T, T... rhs>

auto Dune::operator== | ( | const HybridMultiIndex< std::integral_constant< S, lhs >... > & | ,
|  | const HybridMultiIndex< std::integral_constant< T, rhs >... > & | )

nodiscard constexpr

Overload for purely static HybridMultiIndexs.

The function returns std::true_type if the values of the passed multi-indices are equal. Otherwise returns std::false_type. Note, this overload is chosen for purely static multi-indices only.

## operator==() [4/5]

template<class T>

bool Dune::operator== | ( | const MallocAllocator< T > & | ,
|  | const MallocAllocator< T > & | )

constexpr

check whether allocators are equivalent

## operator==() [5/5]

bool Dune::operator== | ( | const No_Comm & | ,
|  | const No_Comm & | )

inline

Comparison operator for MPI compatibility.

Always returns true.

## pop_back()

template<class... T>
requires (sizeof...(T) > 0)

auto Dune::pop_back | ( | const HybridMultiIndex< T... > & | tp | ) |

nodiscard constexpr

Removes last index on a HybridMultiIndex.

This function returns a new HybridMultiIndex without the last index.

## pop_front()

template<class... T>
requires (sizeof...(T) > 0)

auto Dune::pop_front | ( | const HybridMultiIndex< T... > & | tp | ) |

nodiscard constexpr

Removes first index on a HybridMultiIndex.

This function returns a new HybridMultiIndex without the first index.

## power()

template<class Base, class Exponent>

Base Dune::power | ( | Base | m,
|  | Exponent | p )

constexpr

Power method for integer exponents.

Note
  Make sure that Base is a non-integer type when using negative exponents!

## push_back() [1/3]

template<std::size_t i, typename... T>

HybridMultiIndex< T..., index_constant< i > > Dune::push_back | ( | const HybridMultiIndex< T... > & | tp,
|  | index_constant< i > | iConstant = {} )

nodiscard constexpr

Appends a compile time index to a HybridMultiIndex.

This function returns a new HybridMultiIndex with the compile time index i appended.

The value for the new entry can be passed either as a template parameter or as an index_constant:

auto tp = HybridMultiIndex(1,2,3,4);
using namespace Dune::Indices;
// the following two lines are equivalent
auto tp_a = push_back<1>(tp);
auto tp_b = push_back(tp,_1);
Dune::Indices::_1
constexpr index_constant< 1 > _1
Compile time index with value 1.
Definition indices.hh:55
Dune::push_back
constexpr HybridMultiIndex< T..., std::size_t > push_back(const HybridMultiIndex< T... > &tp, std::size_t i)
Appends a run time index to a HybridMultiIndex.
Definition hybridmultiindex.hh:249
Dune::Indices
Namespace with predefined compile time indices for the range [0,19].
Definition indices.hh:50

## push_back() [2/3]

template<typename... T>

HybridMultiIndex< T..., std::size_t > Dune::push_back | ( | const HybridMultiIndex< T... > & | tp,
|  | std::size_t | i )

nodiscard constexpr

Appends a run time index to a HybridMultiIndex.

This function returns a new HybridMultiIndex with the run time index i appended.

## push_back() [3/3]

template<auto IN, class T, T... II>

std::integer_sequence< T, II..., T(IN)> Dune::push_back | ( | std::integer_sequence< T, II... > | ,
|  | std::integral_constant< T, IN > | = {} )

constexpr

Append an index IN to the back of the sequence.

## push_front() [1/3]

template<std::size_t i, typename... T>

HybridMultiIndex< index_constant< i >, T... > Dune::push_front | ( | const HybridMultiIndex< T... > & | tp,
|  | index_constant< i > | iConstant = {} )

nodiscard constexpr

Prepends a compile time index to a HybridMultiIndex.

This function returns a new HybridMultiIndex with the compile time index i prepended.

The value for the new entry can be passed either as a template parameter or as an index_constant:

auto tp = HybridMultiIndex(1,2,3,4);
using namespace Dune::Indices;
// the following two lines are equivalent
auto tp_a = push_front<1>(tp);
auto tp_b = push_front(tp,_1);
Dune::push_front
constexpr HybridMultiIndex< std::size_t, T... > push_front(const HybridMultiIndex< T... > &tp, std::size_t i)
Prepends a run time index to a HybridMultiIndex.
Definition hybridmultiindex.hh:284

## push_front() [2/3]

template<typename... T>

HybridMultiIndex< std::size_t, T... > Dune::push_front | ( | const HybridMultiIndex< T... > & | tp,
|  | std::size_t | i )

nodiscard constexpr

Prepends a run time index to a HybridMultiIndex.

This function returns a new HybridMultiIndex with the run time index i prepended.

## push_front() [3/3]

template<auto I0, class T, T... II>

std::integer_sequence< T, T(I0), II... > Dune::push_front | ( | std::integer_sequence< T, II... > | ,
|  | std::integral_constant< T, I0 > | = {} )

constexpr

Append an index I0 to the front of the sequence.

## put()

template<class Reference, class PropertyMap, class Key, class Value>

void Dune::put | ( | const RAPropertyMapHelper< Reference, PropertyMap > & | pmap,
|  | const Key & | key,
|  | const Value & | value )

inline

## range()

template<class T, std::enable_if_t< std::is_enum< std::decay_t< T > >::value, int > = 0>

constexpr IntegralRange< std::underlying_type_t< std::decay_t< T > > > Dune::range | ( | T && | to | ) |

static constexpr noexcept

## resolveRef()

template<class T>

const auto & Dune::resolveRef | ( | T && | gf | ) |

delete

## reverse()

template<class... T>

auto Dune::reverse | ( | const HybridMultiIndex< T... > & | tp | ) |

nodiscard constexpr

Reverses the order of the elements in the multi-index.

## sign()

template<class T>

int Dune::sign | ( | const T & | val | ) |

constexpr

Return the sign of the value.

## size()

template<class T, T... II>

std::integral_constant< std::size_t, sizeof...(II)> Dune::size | ( | std::integer_sequence< T, II... > |  | ) |

constexpr

Return the size of the sequence.

## sorted() [1/2]

template<class T, T... II>

auto Dune::sorted | ( | std::integer_sequence< T, II... > | seq | ) |

constexpr

Sort a given sequence by less-than comparison.

## sorted() [2/2]

template<class T, T... II, class Compare>

auto Dune::sorted | ( | std::integer_sequence< T, II... > | ,
|  | Compare | comp )

constexpr

Sort a given sequence by the comparator comp.

## stackobject_to_shared_ptr() [1/2]

template<typename T>

std::shared_ptr< T > stackobject_to_shared_ptr | ( | T & | t | ) |

inline

Create a shared_ptr for a stack-allocated object.

#include <dune/common/shared_ptr.hh>
shared_ptr.hh
This file implements several utilities related to std::shared_ptr.

Usage:

int i = 10;
std::shared_ptr<int> pi = stackobject_to_shared_ptr(i);
Dune::stackobject_to_shared_ptr
std::shared_ptr< T > stackobject_to_shared_ptr(T &t)
Create a shared_ptr for a stack-allocated object.
Definition shared_ptr.hh:72

The `std::shared_ptr` points to the object on the stack, but its deleter is set to an instance of `null_deleter` so that nothing happens when the `shared_ptr` is destroyed.

See also
  null_deleter

## swap()

template<class T>

void Dune::swap | ( | T & | v1,
|  | T & | v2,
|  | bool | mask )

## tail()

template<class T, T I0, T... II>

std::integer_sequence< T, II... > Dune::tail | ( | std::integer_sequence< T, I0, II... > |  | ) |

constexpr

For a sequence [head,tail...) return the tail sequence.

## transpose() [1/3]

template<class Matrix, std::enable_if_t< Impl::HasMemberFunctionTransposed< Matrix >::value, int > = 0>

auto Dune::transpose | ( | const Matrix & | matrix | ) |

Return the transposed of the given matrix.

Parameters

  matrix | The matrix to be transposed.

This overload is selected if the given matrix supports

matrix.transposed()

. It will return the result of

matrix.transposed()

.

## transpose() [2/3]

template<class Matrix>

auto Dune::transpose | ( | const std::reference_wrapper< Matrix > & | matrix | ) |

Create a wrapper modelling the transposed matrix.

Parameters

  matrix | The matrix to be transposed.

This overload is selected if the given value is a

std::reference_wrapper

of a matrix. It will return a wrapper storing a reference of the given matrix.

Currently the wrapper only implements

auto c = a*transpose(b);
Dune::transpose
auto transpose(const Matrix &matrix)
Return the transposed of the given matrix.
Definition transpose.hh:234

if a is a FieldMatrix of appropriate size. This is optimal even for sparse b because it only relies on calling b.mv(a[i], c[i]) for the rows of a. Furthermore the wrapper can be converted to a suitable dense FieldMatrix using the

adDense()

method if the wrapped matrix allows to iterate over its entries and matrix-vector multiplication using

transpose(b).mv(x,y)

if the wrapped matrix provides the

b.mtv(x,y)

.

This specialization allows to pass a

std::reference_wrapper

of a matrix to explicitly request, that the latter is stored by reference in the wrapper.

## transpose() [3/3]

template<class Matrix, std::enable_if_t< not Impl::HasMemberFunctionTransposed< std::decay_t< Matrix > >::value, int > = 0>

auto Dune::transpose | ( | Matrix && | matrix | ) |

Create a wrapper modelling the transposed matrix.

Parameters

  matrix | The matrix to be transposed.

This overload is selected if the given matrix does not support

matrix.transposed()

. It will return a wrapper storing a copy of the given matrix.

Currently the wrapper only implements

auto c = a*transpose(b);

if a is a FieldMatrix of appropriate size. This is optimal even for sparse b because it only relies on calling

b.mv(a[i], c[i])

for the rows of a. Furthermore the wrapper can be converted to a suitable dense FieldMatrix using the

asDense()

method if the wrapped matrix allows to iterate over its entries and matrix-vector multiplication using

transpose(b).mv(x,y)

if the wrapped matrix provides the

b.mtv(x,y)

.

## transposedView()

template<class Matrix>

auto Dune::transposedView | ( | const Matrix & | matrix | ) |

Create a view modelling the transposed matrix.

Parameters

  matrix | The matrix to be transposed.

The returned view stores a reference of the given matrix. Calling

transposedView(matrix)
Dune::transposedView
auto transposedView(const Matrix &matrix)
Create a view modelling the transposed matrix.
Definition transpose.hh:312

is equivalent to

transpose(std::cref(matrix))

.

## uniqueTypeList()

template<class... T>

auto Dune::uniqueTypeList | ( | TypeList< T... > |  | ) |

constexpr

Remove duplicates from a Dune::TypeList.

For a given Dune::TypeList<T...> this return a Dune::TypeList<S...>, where S... is generated by removing duplicate types from T... .

## violatedAlignment()

void Dune::violatedAlignment | ( | const char * | className,
|  | std::size_t | expectedAlignment,
|  | const void * | address )

called when an alignment violation is detected

`className` Name of the class whose alignment was violated `expectedAlignment` The (over-)alignment that the class expected `address` The address the class actually found itself at.

The main purpose of the function is to serve as a convenient breakpoint for debugging – which is why we put it in an external compilation unit so it isn't inlined.

## violatedAlignmentHandler()

ViolatedAlignmentHandler & Dune::violatedAlignmentHandler | ( |  | ) |

access the handler called by violatedAlignment()

This may be used to obtain the handler for the purpose of calling, or for saving it somewhere to restore it later. It may also be used to set the handler simply by assigning a new handler. Setting the handler races with other accesses.

## wrap_or_move() [1/2]

template<class T>

auto Dune::wrap_or_move | ( | T && | t | ) |

Capture R-value reference to shared_ptr.

This will store a copy of the passed object in a shared_ptr.

The two overloads of wrap_or_move are intended to capture references and temporaries in a unique way without creating copies and only moving if necessary.

Be careful: Only use this function if you are aware of it's implications. You can e.g. easily end up storing a reference to a temporary if you use this inside of another function without perfect forwarding.

## wrap_or_move() [2/2]

template<class T>

auto Dune::wrap_or_move | ( | T & | t | ) |

Capture L-value reference to std::shared_ptr.

This will store a pointer for the passed reference in a non-owning std::shared_ptr.

The two overloads of wrap_or_move are intended to capture references and temporaries in a unique way without creating copies and only moving if necessary.

Be careful: Only use this function if you are aware of it's implications. You can e.g. easily end up storing a reference to a temporary if you use this inside of another function without perfect forwarding.

## Variable Documentation

## debugAlignment

auto Dune::debugAlignment = 2*alignof(std::max_align_t)

static constexpr

an alignment large enough to trigger alignment errors

## Generic_MPI_Op< Type, BinaryFunction, Enable >::op

template<typename Type, typename BinaryFunction, typename Enable>

std::unique_ptr<MPI_Op> Dune::Generic_MPI_Op< Type, BinaryFunction, Enable >::op

## MPITraits< T >::datatype

template<class T>

MPI_Datatype Dune::MPITraits< T >::datatype = MPI_DATATYPE_NULL