Dune namespace. More...

Namespaces
namespace	Concept
	Namespace for concepts.

namespace	FloatCmp

namespace	Indices
	Namespace with predefined compile time indices for the range [0,19].

namespace	MathOverloads
	namespace for customization of math functions with Dune-Semantics

namespace	Simd
	Namespace for vectorization interface functions used by library developers.

namespace	Std
	Namespace for features backported from new C++ standards.

Classes
struct	AddPtrTypeEvaluator
	`TypeEvaluator` to turn a type `T` into a pointer to `T` More...

struct	AddRefTypeEvaluator
	`TypeEvaluator` to turn a type `T` into a reference to `T` More...

class	AlignedAllocator
	Allocators which guarantee alignment of the memory. More...

struct	AlignedBase
	CRTP base mixin class to check alignment. More...

class	AllSet
	A set containing everything. More...

struct	AlwaysFalse
	template which always yields a false value More...

struct	AlwaysTrue
	template which always yields a true value More...

class	ArithmeticTestSuite
	Test suite for arithmetic types. More...

class	ArrayList
	A dynamically growing random access list. More...

class	ArrayListIterator
	A random access iterator for the Dune::ArrayList class. More...

class	AssociativePropertyMap
	An adapter to turn an unique associative container into a property map. More...

struct	At
	Reverse element access. More...

struct	AtType
	Type for reverse element access. More...

struct	AutonomousValueType
	Type free of internal references that `T` can be converted to. More...

struct	AutonomousValueType< const T >
	Specialization to remove const qualifiers. More...

struct	AutonomousValueType< Simd::VcImpl::Proxy< V > >
	Specialization of AutonomousValue for Vc proxies. More...

struct	AutonomousValueType< std::vector< bool >::reference >
	Specialization for the proxies of `vector<bool>` More...

struct	AutonomousValueType< T & >
	Specialization to remove lvalue references. More...

struct	AutonomousValueType< T && >
	Specialization to remove rvalue references. More...

struct	AutonomousValueType< volatile const T >
	Specialization to remove both const and volatile qualifiers. More...

struct	AutonomousValueType< volatile T >
	Specialization to remove volatile qualifiers. More...

class	BidirectionalIteratorFacade
	Facade class for stl conformant bidirectional iterators. More...

class	bigunsignedint
	Portable very large unsigned integers. More...

class	BitSetVector
	A dynamic array of blocks of booleans. More...

class	BitSetVectorConstReference
	A proxy class that acts as a const reference to a single bitset in a BitSetVector. More...

class	BitSetVectorReference
	A proxy class that acts as a mutable reference to a single bitset in a BitSetVector. More...

class	BufferedCommunicator
	A communicator that uses buffers to gather and scatter the data to be send or received. More...

struct	Cloneable
	An interface class for cloneable objects. More...

class	CollectiveIterator
	A collective iterator for moving over the remote indices for all processes collectively. More...

class	CollectorStream
	Data collector stream. More...

class	Combine
	A set combining two other sets. More...

struct	common_bits
	activate if current and mask have common bits switched on. More...

struct	CommPolicy
	Default policy used for communicating an indexed type. More...

class	Communication
	Collective communication interface and sequential default implementation. More...

class	Communication< MPI_Comm >
	Specialization of Communication for MPI. More...

struct	const_reference
	Get the 'const' version of a reference to a mutable object. More...

struct	const_reference< BitSetVectorReference< block_size, Alloc > >

class	ConstArrayListIterator
	A constant random access iterator for the Dune::ArrayList class. More...

class	ConstAssociativePropertyMap
	An adaptor to turn an unique associative container into a property map. More...

class	ContainerWrapperIterator
	Iterator class for sparse vector-like containers. More...

class	CopyableOptional
	A copyable type wrapper that provides copy/move assignment operations for types that are only copy/move constructible. More...

class	DebugStream
	Generic class to implement debug output streams. More...

class	DebugStreamError
	standard exception for the debugstream More...

class	DebugStreamState
	Intermediate class to implement tie-operation of DebugStream. More...

class	DenseIterator
	Generic iterator class for dense vector and matrix implementations. More...

class	DenseMatrix
	A dense n x m matrix. More...

struct	DenseMatrixAssigner
	you have to specialize this structure for any type that should be assignable to a DenseMatrix More...

class	DenseVector
	Interface for a class of dense vectors over a given field. More...

class	DiagonalMatrix
	A diagonal matrix of static size. More...

class	DynamicMatrix
	Construct a matrix with a dynamic size. More...

class	DynamicVector
	Construct a vector with a dynamic size. More...

struct	Empty
	Just an empty class. More...

class	EmptySet
	An empty set. More...

struct	EnableIfInterOperable
	Enable typedef if two types are interoperable. More...

class	EnumItem
	A set consisting only of one item. More...

class	EnumRange
	A set representing a range including the borders. More...

class	Exception
	Base class for Dune-Exceptions. More...

struct	ExceptionHook
	Base class to add a hook to the Dune::Exception. More...

struct	Factorial

struct	Factorial< 0 >
	end of recursion of factorial via specialization More...

class	FakeMPIHelper
	A fake mpi helper. More...

class	FieldMatrix
	A dense n x m matrix. More...

class	FieldVector
	vector space out of a tensor product of fields. More...

class	FirstPredicateIndex
	Finding the index of a certain type in a std::tuple. More...

struct	FirstTypeIndex
	Find the first occurrence of a type in a std::tuple. More...

struct	FlattenTuple
	Flatten a std::tuple of std::tuple's. More...

class	FloatCmpOps
	Class encapsulating a default epsilon. More...

class	FMatrixError
	Error thrown if operations of a FieldMatrix fail. More...

class	FMatrixPrecision
	Precisions for calculations with FieldMatrix and FieldVector. More...

struct	ForEachType
	Helper template to clone the type definition of a std::tuple with the storage types replaced by a user-defined rule. More...

class	ForwardIteratorFacade
	Base class for stl conformant forward iterators. More...

class	Future
	Type-erasure for future-like objects. A future-like object is a object satisfying the interface of FutureBase. More...

class	GenericIterator
	Generic class for stl-conforming iterators for container classes with operator[]. More...

class	GlobalLookupIndexSet
	Decorates an index set with the possibility to find a global index that is mapped to a specific local. More...

class	GMPField
	Number class for high precision floating point number using the GMP library mpf_class implementation. More...

struct	greater_or_equal
	Greater or equal template test. More...

struct	hash
	Functor for hashing objects of type T. More...

struct	HasNaN
	Whether this type has a value of NaN. More...

class	HelpRequest
	exception thrown if the user wants to see help string More...

struct	IdentityMap
	A property map that applies the identity function to integers. More...

struct	ImplementationDefined
	Dummy struct used for documentation purposes. 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...

class	IndexPair
	A pair consisting of a global and local index. More...

class	IndicesSyncer
	Class for recomputing missing indices of a distributed index set. More...

struct	IntegerSequenceEntry
	Get entry of std::integer_sequence. More...

class	IntegralRange
	dynamic integer range for use in range-based for loops More...

class	Interface
	Communication interface between remote and local indices. More...

class	InterfaceBuilder
	Base class of all classes representing a communication interface. More...

class	InterfaceInformation
	Information describing an interface. 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	InvalidIndexSetState
	Exception indicating that the index set is not in the expected state. More...

class	InvalidStateException
	Default exception if a function was called while the object is not in a valid state for that function. More...

class	IOError
	Default exception class for I/O errors. More...

class	ios_base_all_saver
	Utility class for storing and resetting stream attributes. 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	IsCompileTimeConstant
	Check if T is an integral constant or any type derived from `std::integral_constant`. More...

struct	IsEmptyTypeList
	Check if given type is an empty TypeList. More...

struct	IsFieldVectorSizeCorrect
	TMP to check the size of a DenseVectors statically, if possible. 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	IsIntegralConstant
	Check if T is an std::integral_constant<I, i> More...

struct	IsInteroperable
	Checks whether two types are interoperable. More...

struct	IsIterable
	typetrait to check that a class has begin() and end() members 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	IsTuple
	Check if T is a std::tuple<...> More...

struct	IsTupleOrDerived
	Check if T derived from a std::tuple<...> More...

struct	IsType
	Generator for predicates accepting one particular type. More...

struct	IsTypeList
	Check if given type is a TypeList. More...

struct	IsTypeList< TypeList< T... > >
	Check if given type is a TypeList. More...

class	IteratorFacade
	CRTP-Mixing class for stl conformant iterators of given iterator category. More...

struct	IteratorFacadeAccess
	This class encapsulates access of IteratorFacade. More...

class	IteratorPropertyMap
	Adapter to turn a random access iterator into a property map. More...

class	IteratorRange
	Simple range between a begin and an end iterator. More...

struct	IteratorTransformationTag
	Tag to enable iterator based transformations in TransformedRangeView. More...

struct	JoinTuples
	Join two std::tuple's. More...

class	LocalIndex
	An index present on the local process. More...

class	LoopSIMD

class	lru
	LRU Cache Container. More...

struct	LvaluePropertyMapTag
	Tag for the category of lvalue property maps. More...

class	MallocAllocator
	Allocators implementation which simply calls malloc/free. More...

struct	MathematicalConstants
	Provides commonly used mathematical constants. More...

class	MathError
	Default exception class for mathematical errors. More...

struct	MetaType
	A type that refers to another type. More...

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	MPIGuard
	detects a thrown exception and communicates to all other processes More...

class	MPIGuardError
	This exception is thrown if the MPIGuard detects an error on a remote process. More...

class	MPIHelper
	A real mpi helper. More...

struct	MPITraits
	A traits class describing the mapping of types onto MPI_Datatypes. More...

class	MPITraits< IndexPair< TG, ParallelLocalIndex< TA > > >

class	MPITraits< ParallelLocalIndex< T > >

struct	mutable_reference
	get the 'mutable' version of a reference to a const object 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	NotImplemented
	Default exception for dummy implementations. More...

struct	null_deleter
	implements the Deleter concept of shared_ptr without deleting anything More...

struct	NullPointerInitialiser
	A helper template that initializes a std::tuple consisting of pointers to nullptr. More...

class	OutOfMemoryError
	Default exception if memory allocation fails. More...

class	ParallelError
	Default exception if an error in the parallel communication of the program occurred. More...

class	ParallelIndexSet
	Manager class for the mapping between local indices and globally unique indices. More...

class	ParallelLocalIndex
	An index present on the local process with an additional attribute flag. More...

class	ParameterizedObjectFactory
	A factory class for parameterized objects. More...

class	ParameterTree
	Hierarchical structure of string parameters. More...

class	ParameterTreeParser
	Parsers to set up a ParameterTree from various input sources. More...

class	ParameterTreeParserError
	report parser error while reading ParameterTree More...

struct	PointerPairDeletor
	Deletes all objects pointed to in a std::tuple of pointers. More...

class	Pool
	A memory pool of objects. More...

class	PoolAllocator
	An allocator managing a pool of objects for reuse. More...

struct	PriorityTag
	Helper class for tagging priorities. More...

struct	PriorityTag< 0 >
	Helper class for tagging priorities. More...

struct	PromotionTraits
	Compute type of the result of an arithmetic operation involving two different number types. More...

struct	PropertyMapTypeSelector
	Selector for the property map type. More...

class	ProxyArrowResult
	Helper to mimic a pointer for proxy objects. More...

class	PseudoFuture
	A wrapper-class for a object which is ready immediately. More...

struct	PushBackTuple
	Helper template to append a type to a std::tuple. More...

struct	PushFrontTuple
	Helper template to prepend a type to a std::tuple. More...

class	RandomAccessIteratorFacade
	Base class for stl conformant forward iterators. More...

class	RangeError
	Default exception class for range errors. More...

struct	ReadablePropertyMapTag
	Tag for the category of readable property maps. More...

struct	ReadWritePropertyMapTag
	Tag for the category of readable and writable property maps. More...

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

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	RemoteIndices
	The indices present on remote processes. More...

class	ReservedVector
	A Vector class with statically reserved memory. More...

class	Selection
	A cached selection of indices. More...

class	SelectionIterator
	A const iterator over an uncached selection. More...

struct	SimdScalarTypeTraits< AlignedNumber< T, align > >
	deduce the underlying scalar data type of an AlignedNumber More...

class	Singleton
	An adapter to turn a class into a singleton. More...

struct	SizeOf
	Compute size of variadic type list. More...

struct	SizeOne
	Flag for marking indexed data structures where data at each index is of the same size. More...

class	SLList
	A single linked list. More...

class	SLListConstIterator
	A constant iterator for the SLList. More...

class	SLListIterator
	A mutable iterator for the SLList. More...

class	SLListModifyIterator
	A mutable iterator for the SLList. More...

struct	StandardMathematicalConstants
	Standard implementation of MathematicalConstants. More...

class	StaticIntegralRange
	static integer range for use in range-based for loops More...

class	SystemError
	Default exception class for OS errors. More...

class	TestSuite
	A Simple helper class to organize your test suite. More...

class	Timer
	A simple stop watch. More...

class	TransformedRangeView
	A range transforming the values of another range on-the-fly. More...

class	TransformTupleFunctor

class	TupleVector
	A class augmenting std::tuple by element access via operator[]. More...

struct	TypeListElement< i, TypeList< T... > >
	Get element of TypeList. More...

struct	TypeListSize< TypeList< T... > >
	Get size of TypeList. More...

class	UncachedSelection
	An uncached selection of indices. More...

struct	ValueTransformationTag
	Tag to enable value based transformations in TransformedRangeView. More...

struct	VariableSize
	Flag for marking indexed data structures where the data at each index may be a variable multiple of another type. More...

class	VariableSizeCommunicator
	A buffered communicator where the amount of data sent does not have to be known a priori. More...

struct	WritablePropertyMapTag
	Tag for the category of writable property maps. More...

Typedefs
using	ViolatedAlignmentHandler = std::function< void(const char , std::size_t, const void )>
	type of the handler called by `violatedAlignment()`

typedef unsigned int	DebugLevel
	Type for debug levels. More...

template<std::size_t i>
using	index_constant = std::integral_constant< std::size_t, i >
	An index constant with value i. More...

template<class T >
using	CollectiveCommunication = Communication< T >

template<class T >
using	ResolveRef_t = std::remove_reference_t< decltype(Dune::resolveRef(std::declval< T & >()))>
	Type trait to resolve std::reference_wrapper. More...

template<typename V >
using	SimdIndex = typename SimdIndexTypeTraits< V >::type
	An simd vector of indices corresponding to a simd vector V. More...

template<typename V >
using	SimdMask = typename SimdMaskTypeTraits< V >::type
	A simd vector of truth values corresponding to a simd vector V. More...

template<template< typename... > class Fallback, template< typename... > class TargetType, typename... Args>
using	detected_or_fallback_t = 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.

typedef DebugStream< VERY_VERBOSE_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL >	DVVerbType
	Type of very verbose debug stream. More...

typedef DebugStream< VERBOSE_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL >	DVerbType
	Type of more verbose debug stream. More...

typedef DebugStream< INFO_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL >	DInfoType
	Type of debug stream with info level. More...

typedef DebugStream< WARN_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL >	DWarnType
	Type of debug stream with warn level. More...

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. More...

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. More...

template<template< class... > class Target, class... T>
using	UniqueTypes_t = typename Impl::UniqueTypesHelper< Target, TypeList< T... > >::type
	Remove duplicates from a list of types. More...

template<class NonUniqueTypeList >
using	UniqueTypeList_t = typename Impl::UniqueTypesHelper< TypeList, NonUniqueTypeList >::type
	Remove duplicates from a Dune::TypeList. More...

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. More...

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. More...

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. More...

Enumerations
enum	{ implementationDefined }

enum	ParallelIndexSetState { GROUND , RESIZE }
	The states the index set can be in. More...

enum	LocalIndexState
	The states available for the local indices. More...

Functions
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. More...

template<typename T1 , typename T2 >
const T1	cond (bool b, const T1 &v1, const T2 &v2)
	conditional evaluate More...

static void	defaultViolatedAlignment (const char className, std::size_t expectedAlignment, const void address)
	default alignment violation handler More...

ViolatedAlignmentHandler &	violatedAlignmentHandler ()
	access the handler called by `violatedAlignment()` More...

void	violatedAlignment (const char className, std::size_t expectedAlignment, const void address)
	called when an alignment violation is detected More...

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<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 More...

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. More...

template<std::size_t n, class T >
constexpr std::array< T, n >	filledArray (const T &t)
	Return an array filled with the provided value. More...

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. More...

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. More...

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. More...

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>... More...

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 , T J0, T... JJ>
constexpr auto	filter (std::integer_sequence< T, J0, JJ... > 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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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 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. More...

template<class... F>
auto	orderedOverload (F &&... f)
	Create an ordered overload set. More...

bool	operator== (const No_Comm &, const No_Comm &)
	Comparison operator for MPI compatibility. More...

bool	operator!= (const No_Comm &, const No_Comm &)
	Comparison operator for MPI compatibility. More...

template<class TG , class TL >
std::ostream &	operator<< (std::ostream &os, const IndexPair< TG, TL > &pair)
	Print an index pair. More...

template<class TG , class TL , int N>
std::ostream &	operator<< (std::ostream &os, const ParallelIndexSet< TG, TL, N > &indexSet)
	Print an index set. More...

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. More...

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. More...

template<class T >
std::ostream &	operator<< (std::ostream &os, const ParallelLocalIndex< T > &index)
	Print the local index to a stream. More...

std::string	concatPaths (const std::string &base, const std::string &p)
	concatenate two paths More...

std::string	processPath (const std::string &p)
	sanitize a path for further processing More...

bool	pathIndicatesDirectory (const std::string &p)
	check whether the given path indicates that it is a directory More...

std::string	prettyPath (const std::string &p, bool isDirectory)
	pretty print path More...

std::string	prettyPath (const std::string &p)
	pretty print path More...

std::string	relativePath (const std::string &newbase, const std::string &p)
	compute a relative path between two paths More...

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

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 More...

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 More...

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 More...

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 More...

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 R , class F >
auto	transformedRangeView (R &&range, F &&f)
	Create a TransformedRangeView. More...

template<class R , class F >
auto	iteratorTransformedRangeView (R &&range, F &&f)
	Create a TransformedRangeView using an iterator transformation. More...

template<class Range >
auto	sparseRange (Range &&range)
	Allow structured-binding for-loops for sparse iterators. More...

template<class T >
constexpr T &	resolveRef (T &gf) noexcept
	Helper function to resolve std::reference_wrapper. More...

template<class T >
constexpr T &	resolveRef (std::reference_wrapper< T > gf) noexcept
	Helper function to resolve std::reference_wrapper. More...

template<typename T >
std::shared_ptr< T >	stackobject_to_shared_ptr (T &t)
	Create a shared_ptr for a stack-allocated object. More...

template<class T >
auto	wrap_or_move (T &&t)
	Capture R-value reference to shared_ptr. More...

template<class T >
auto	wrap_or_move (T &t)
	Capture L-value reference to std::shared_ptr. More...

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

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. More...

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. More...

template<typename C >
bool	hasSuffix (const C &c, const char *suffix)
	Check whether a character container has a given suffix. More...

template<class... T>
static std::string	formatString (const std::string &s, const T &... args)
	Format values according to printf format string. More...

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. More...

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. More...

template<class Matrix >
auto	transpose (const std::reference_wrapper< Matrix > &matrix)
	Create a wrapper modelling the transposed matrix. More...

template<class Matrix >
auto	transposedView (const Matrix &matrix)
	Create a view modelling the transposed matrix. More...

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. More...

template<class Tuple , class Functor >
auto	genericTransformTuple (Tuple &&t, Functor &&f) -> decltype(genericTransformTupleBackend(t, f))

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	uniqueTypeList (TypeList< T... > list)
	Remove duplicates from a Dune::TypeList. More...

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. More...

template<class T >
constexpr AutonomousValue< T >	autoCopy (T &&v)
	Autonomous copy of an expression's value for use in `auto` type deduction. More...

Variables
static constexpr auto	debugAlignment = 2*alignof(std::max_align_t)
	an alignment large enough to trigger alignment errors

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. More...

DVerbType	dverb (std::cout)
	Singleton of verbose debug stream. More...

DInfoType	dinfo (std::cout)
	Stream for informative output. More...

DWarnType	dwarn (std::cerr)
	Stream for warnings indicating problems. More...

DGraveType	dgrave (std::cerr)
	Stream for warnings indicating fatal errors. More...

DErrType	derr (std::cerr)
	Stream for error messages. More...

static const DebugLevel	VERY_VERBOSE_DEBUG_LEVEL = 1
	The level of the very verbose debug stream. More...

static const DebugLevel	VERBOSE_DEBUG_LEVEL = 2
	The level of the verbose debug stream. More...

static const DebugLevel	INFO_DEBUG_LEVEL = 3
	The level of the informative debug stream. More...

static const DebugLevel	WARN_DEBUG_LEVEL = 4
	The level of the debug stream for warnings. More...

static const DebugLevel	GRAVE_DEBUG_LEVEL = 5
	The level of the debug stream for fatal errors. More...

Detailed Description

Dune namespace.

Typedef Documentation

◆ CollectiveCommunication

template<class T >

using Dune::CollectiveCommunication = typedef Communication<T>

Deprecated:: CollectiveCommunication is deprecated and will be removed after Dune 2.9.

Use Communication instead.

◆ ResolveRef_t

template<class T >

using Dune::ResolveRef_t = typedef 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<S> the wrapped type S is returned.

◆ SimdIndex

template<typename V >

using Dune::SimdIndex = typedef 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 = typedef typename SimdMaskTypeTraits<V>::type

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

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

◆ UniqueTypeList_t

template<class NonUniqueTypeList >

using Dune::UniqueTypeList_t = typedef 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 = typedef 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 = typedef typename Impl::UnpackTypeList<Target, TL>::type

Unpack Dune::TypeList.

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

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

◆ 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 0. 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.

References Dune::Simd::Overloads::mask().

Referenced by Dune::bigunsignedint< k >::bigunsignedint(), Dune::BitSetVector< block_size, Allocator >::setAll(), and Dune::BitSetVector< block_size, Allocator >::unsetAll().

◆ cond()

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

Referenced by Dune::Simd::Overloads::cond().

◆ defaultViolatedAlignment()

static 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.

References className().

Referenced by violatedAlignmentHandler().

◆ filter() [1/2]

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

constexpr 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

References head(), push_front(), and tail().

◆ filter() [2/2]

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

constexpr 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

References head(), push_front(), and tail().

◆ 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.

Referenced by hash_range().

◆ 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.

References hash_combine().

◆ 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.

References hash_combine().

◆ operator!=()

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

inline

Comparison operator for MPI compatibility.

Always returns false.

◆ operator==() [1/2]

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.

References Dune::Hybrid::equals().

◆ operator==() [2/2]

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

inline

Comparison operator for MPI compatibility.

Always returns true.

◆ power()

template<class Base , class Exponent >

constexpr 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!

◆ stackobject_to_shared_ptr()

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

Referenced by wrap_or_move().

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

.

Referenced by transposedView().

◆ 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:183

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:261

is equivalent to

transpose(std::cref(matrix))

.

References transpose().

◆ uniqueTypeList()

template<class... T>

constexpr 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.

References className(), and violatedAlignmentHandler().

Referenced by Dune::AlignedBase< align, Impl >::operator new(), and Dune::AlignedBase< align, Impl >::operator new[]().

◆ 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.

References defaultViolatedAlignment().

Referenced by violatedAlignment().

◆ 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.

References stackobject_to_shared_ptr().

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ CollectiveCommunication

◆ ResolveRef_t

◆ SimdIndex

◆ SimdMask

◆ UniqueTypeList_t

◆ UniqueTypes_t

◆ UnpackTypeList_t

Enumeration Type Documentation

◆ anonymous enum

Function Documentation

◆ assertCallOnce()

◆ assign()

◆ cond()

◆ defaultViolatedAlignment()

◆ filter() [1/2]

◆ filter() [2/2]

◆ hash_combine()

◆ hash_range() [1/2]

◆ hash_range() [2/2]

◆ operator!=()

◆ operator==() [1/2]

◆ operator==() [2/2]

◆ power()

◆ stackobject_to_shared_ptr()

◆ transpose() [1/3]

◆ transpose() [2/3]

◆ transpose() [3/3]

◆ transposedView()

◆ uniqueTypeList()

◆ violatedAlignment()

◆ violatedAlignmentHandler()

◆ wrap_or_move() [1/2]

◆ wrap_or_move() [2/2]