Dune Namespace Reference

Dune namespace. More...

Namespaces
namespace	Concept
	Namespace for concepts.
namespace	AlignedNumberImpl
namespace	Simd
	Namespace for vectorization interface functions used by library developers.
namespace	DenseMatrixHelp
namespace	fvmeta
namespace	DynamicMatrixHelp
namespace	FloatCmp
namespace	FMatrixHelp
namespace	MathOverloads
	namespace for customization of math functions with Dune-Semantics
namespace	Hybrid
namespace	Indices
	Namespace with predefined compile time indices for the range [0,19].
namespace	MathImpl
namespace	impl
namespace	SimdImpl
namespace	Std
	Namespace for features backported from new C++ standards.

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	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	hash
	Functor for hashing objects of type T. 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...
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	Factorial
struct	Factorial< 0 >
	end of recursion of factorial via specialization 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	SizeOf
	Compute size of variadic type list. 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 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.
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... > seq, 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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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)
	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>
K	conjugateComplex (const K &x)
	compute conjugate complex of x
template<class T>
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 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 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 IntegralRange< std::underlying_type_t< std::decay_t< T > > >	range (T &&to) noexcept
template<class T, T to>
static 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 Stream, typename... Ts>
Stream &	operator<< (Stream &stream, const std::tuple< Ts... > &t)
	Print a std::tuple.
template<typename Stream, typename... Ts>
Stream &	operator>> (Stream &stream, std::tuple< Ts... > &t)
	Read a std::tuple.
template<typename Stream, typename T, std::size_t N>
Stream &	operator<< (Stream &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... > list)
	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, T from, T to>
static StaticIntegralRange< T, to, from >	range (std::integral_constant< T, from >, std::integral_constant< T, to >) noexcept
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...>

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

ResolveRef_t

template<class T>

using Dune::ResolveRef_t = std::remove_reference_t<decltype(Dune::resolveRef(std::declval<T&>()))>

Type trait to resolve std::reference_wrapper.

This is an alias for result of resolveRef. Plain types T or const T are forwarded while for T=std::reference_wrapper the wrapped type S is returned.

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> See also ImplementationDefined

Function Documentation

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()

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 )

inlinestaticconstexprnoexcept

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 >  )

inlinestaticconstexprnoexcept

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 >  )

inlinestaticconstexprnoexcept

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 )

inline

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 )

inlinestaticconstexprnoexcept

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 > )

inlinestaticconstexprnoexcept

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()

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.

isAligned()

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

inline

check whether an address conforms to the given alignment

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/2]

template<class T>

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

constexpr

check whether allocators are not equivalent

operator!=() [2/2]

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

inline

Comparison operator for MPI compatibility.

Always returns false.

operator<<()

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

inline

operator==() [1/3]

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 )

inline

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/3]

template<class T>

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

constexpr

check whether allocators are equivalent

operator==() [3/3]

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

inline

Comparison operator for MPI compatibility.

Always returns true.

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()

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()

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>

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

inlinestaticnoexcept

resolveRef()

template<class T>

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

delete

sign()

template<class T>

int Dune::sign

(

const T &

val

)

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... > seq, 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>

Usage:

int i = 10;
std::shared_ptr<int> pi = stackobject_to_shared_ptr(i);

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);

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) 

is equivalent to

transpose(std::cref(matrix)) 

.

uniqueTypeList()

template<class... T>

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

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)

staticconstexpr

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