dune-common 2.9.0
Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables

Dune namespace. More...

Namespaces

namespace  AlignedNumberImpl
 
namespace  Concept
 Namespace for concepts.
 
namespace  DenseMatrixHelp
 
namespace  DynamicMatrixHelp
 
namespace  FloatCmp
 
namespace  FMatrixHelp
 
namespace  fvmeta
 
namespace  Hybrid
 
namespace  impl
 
namespace  Indices
 Namespace with predefined compile time indices for the range [0,19].
 
namespace  MathImpl
 
namespace  MathOverloads
 namespace for customization of math functions with Dune-Semantics
 
namespace  Simd
 Namespace for vectorization interface functions used by library developers.
 
namespace  SimdImpl
 
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  AddPtrTypeEvaluator< T & >
 
struct  AddRefTypeEvaluator
 TypeEvaluator to turn a type T into a reference to T More...
 
class  AlignedAllocator
 Allocators which guarantee alignment of the memory. More...
 
class  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  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< Impl::ScalarMatrixView< K > >
 
struct  AutonomousValueType< Impl::ScalarVectorView< K > >
 
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  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< BitSetVectorConstReference< block_size, Alloc > >
 
struct  const_reference< BitSetVectorReference< block_size, Alloc > >
 
struct  const_reference< const R & >
 
struct  const_reference< const R >
 
struct  const_reference< DiagonalRowVector< K, n > >
 
struct  const_reference< DiagonalRowVectorConst< K, n > >
 
struct  const_reference< R & >
 
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  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...
 
struct  DenseMatrixAssigner< DenseMatrix, DiagonalMatrix< field, N > >
 
struct  DenseMatVecTraits
 
struct  DenseMatVecTraits< DynamicMatrix< K > >
 
struct  DenseMatVecTraits< DynamicVector< K, Allocator > >
 
struct  DenseMatVecTraits< FieldMatrix< K, ROWS, COLS > >
 
struct  DenseMatVecTraits< FieldVector< K, SIZE > >
 
struct  DenseMatVecTraits< Impl::ScalarMatrixView< K > >
 
struct  DenseMatVecTraits< Impl::ScalarVectorView< K > >
 
class  DenseVector
 Interface for a class of dense vectors over a given field. More...
 
class  DiagonalMatrix
 A diagonal matrix of static size. More...
 
class  DiagonalMatrixWrapper
 
class  DiagonalRowVector
 
class  DiagonalRowVectorConst
 
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...
 
struct  FieldTraits
 
struct  FieldTraits< const T >
 
struct  FieldTraits< DenseMatrix< M > >
 
struct  FieldTraits< DenseVector< V > >
 
struct  FieldTraits< DiagonalMatrix< K, n > >
 
struct  FieldTraits< DynamicMatrix< K > >
 
struct  FieldTraits< DynamicVector< K, Allocator > >
 
struct  FieldTraits< FieldMatrix< K, ROWS, COLS > >
 
struct  FieldTraits< FieldVector< K, SIZE > >
 
struct  FieldTraits< Impl::ColumnVectorView< M > >
 
struct  FieldTraits< Impl::ScalarMatrixView< K > >
 
struct  FieldTraits< Impl::ScalarVectorView< K > >
 
struct  FieldTraits< Impl::TransposedMatrixWrapper< M > >
 
struct  FieldTraits< std::complex< T > >
 
struct  FieldTraits< std::vector< T > >
 
struct  FieldTraits< T[N] >
 
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...
 
struct  ForEachType< TE, std::tuple< Args... > >
 
class  ForwardIteratorFacade
 Base class for stl conformant forward iterators. More...
 
class  Function
 Base class template for function classes. More...
 
class  Future
 Type-erasure for future-like objects. A future-like object is a object satisfying the interface of FutureBase. More...
 
class  Generic_MPI_Op
 
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  IndexPair
 A pair consisting of a global and local index. More...
 
struct  IndexSetSortFunctor
 
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  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  IsFieldVectorSizeCorrect< FieldVector< T, SIZE >, SIZE >
 
struct  IsFieldVectorSizeCorrect< FieldVector< T, SIZE1 >, SIZE >
 
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< AlignedNumberImpl::AlignedNumber< T, align > >
 
struct  IsNumber< bigunsignedint< k > >
 Declare big unsigned int is a number. More...
 
struct  IsNumber< GMPField< precision > >
 
struct  IsNumber< LoopSIMD< T, S, A > >
 
struct  IsNumber< Vc::SimdArray< T, N, V, Wt > >
 
struct  IsNumber< Vc::Vector< T, Abi > >
 
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...
 
struct  IsVector
 
struct  IsVector< T, std::void_t< typename T::field_type > >
 
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...
 
struct  LocalIndexComparator
 
struct  LocalIndexComparator< ParallelLocalIndex< T > >
 
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  Max
 
struct  MetaType
 A type that refers to another type. More...
 
struct  Min
 
struct  MPIData
 
struct  MPIData< P, std::enable_if_t< std::is_same< std::remove_const_t< P >, MPIPack >::value > >
 
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 > > >
 
struct  MPIData< void >
 
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...
 
class  MPIPack
 
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...
 
struct  mutable_reference< BitSetVectorConstReference< block_size, Alloc > >
 
struct  mutable_reference< BitSetVectorReference< block_size, Alloc > >
 
struct  mutable_reference< const R & >
 
struct  mutable_reference< const R >
 
struct  mutable_reference< DiagonalRowVector< K, n > >
 
struct  mutable_reference< DiagonalRowVectorConst< K, n > >
 
struct  mutable_reference< R & >
 
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...
 
struct  No_Comm
 
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...
 
struct  NullPointerInitialiser< std::tuple< Args... > >
 
class  OutOfMemoryError
 Default exception if memory allocation fails. More...
 
class  OwnerOverlapCopyCommunication
 
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  ParameterizedObjectFactory< TypeT(Args...), KeyT >
 
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...
 
class  PoolAllocator< void, s >
 
struct  Power
 Compute power for a run-time base and a compile-time integer exponent. 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  PromotionTraits< GMPField< precision >, GMPField< precision > >
 
struct  PromotionTraits< GMPField< precision >, T >
 
struct  PromotionTraits< GMPField< precision1 >, GMPField< precision2 > >
 
struct  PromotionTraits< T, GMPField< precision > >
 
struct  PromotionTraits< T1, T1 >
 
struct  PropertyMapTraits
 
struct  PropertyMapTraits< const T * >
 
struct  PropertyMapTraits< T * >
 
struct  PropertyMapTypeSelector
 Selector for the property map type. More...
 
class  PseudoFuture
 A wrapper-class for a object which is ready immediately. More...
 
class  PseudoFuture< void >
 
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 >
 
class  RandomAccessIteratorFacade
 Base class for stl conformant forward iterators. More...
 
class  RangeError
 Default exception class for range errors. More...
 
struct  RAPropertyMapHelper
 
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  SimdIndexTypeTraits
 
struct  SimdMaskTypeTraits
 
struct  SimdScalarTypeTraits
 
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...
 
struct  StaticPower
 Calculates b^p at compile time. More...
 
class  StreamWrap
 
class  SystemError
 Default exception class for OS errors. More...
 
class  Timer
 A simple stop watch. More...
 
class  TransformedRangeView
 A range transforming the values of another range on-the-fly. More...
 
class  TransformTupleFunctor
 
struct  TupleAccessTraits
 
struct  TupleAccessTraits< T & >
 
struct  TupleAccessTraits< T * >
 
class  TupleVector
 A class augmenting std::tuple by element access via operator[]. More...
 
struct  TypeListElement
 
struct  TypeListElement< i, TypeList< T... > >
 Get element of TypeList. More...
 
struct  TypeListSize
 
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...
 
class  VirtualFunction
 Virtual base class template for function classes. 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.
 
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 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.
 
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 = 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_LEVELDVVerbType
 Type of very verbose debug stream.
 
typedef DebugStream< VERBOSE_DEBUG_LEVEL, MINIMAL_DEBUG_LEVELDVerbType
 Type of more verbose debug stream.
 
typedef DebugStream< INFO_DEBUG_LEVEL, MINIMAL_DEBUG_LEVELDInfoType
 Type of debug stream with info level.
 
typedef DebugStream< WARN_DEBUG_LEVEL, MINIMAL_DEBUG_LEVELDWarnType
 Type of debug stream with warn level.
 
typedef DebugStream< GRAVE_DEBUG_LEVEL, MINIMAL_DEBUG_LEVELDGraveType
 Type of debug stream for fatal errors.
 
typedef DebugStream< 1 > DErrType
 The type of the stream used for error messages.
 
template<class T >
using ToUniquePtr = std::unique_ptr< T >
 Alias for std::unique_ptr introduced as transition wrapper.
 
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
 
ViolatedAlignmentHandlerviolatedAlignmentHandler ()
 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>
max_value (const AlignedNumber< T, align > &val)
 
template<class T , std::size_t align>
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 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 Domain , typename Range , typename F >
Impl::LambdaVirtualFunction< Domain, Range, std::decay_t< F > > makeVirtualFunction (F &&f)
 make VirtualFunction out of a function object
 
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<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.
 
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 >
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 > &, const IndexPair< TG, TL > &)
 
template<class TG , class TL >
bool operator!= (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
 
template<class TG , class TL >
bool operator< (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
 
template<class TG , class TL >
bool operator> (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
 
template<class TG , class TL >
bool operator<= (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
 
template<class TG , class TL >
bool operator>= (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
 
template<class TG , class TL >
bool operator== (const IndexPair< TG, TL > &, const TG &)
 
template<class TG , class TL >
bool operator!= (const IndexPair< TG, TL > &, const TG &)
 
template<class TG , class TL >
bool operator< (const IndexPair< TG, TL > &, const TG &)
 
template<class TG , class TL >
bool operator> (const IndexPair< TG, TL > &, const TG &)
 
template<class TG , class TL >
bool operator<= (const IndexPair< TG, TL > &, const TG &)
 
template<class TG , class TL >
bool operator>= (const IndexPair< TG, TL > &, const TG &)
 
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, const F &f)
 Create a TransformedRangeView.
 
template<class R , class F >
auto iteratorTransformedRangeView (R &&range, const 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 >
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 T , class... Args>
std::unique_ptr< T > makeToUnique (Args &&... args)
 Alias for std::make_unique introduced as transition wrapper.
 
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.
 

Variables

static constexpr auto debugAlignment = 2*alignof(std::max_align_t)
 an alignment large enough to trigger alignment errors
 
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

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

◆ detected_or_fallback_t

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

◆ SimdScalar

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

◆ ToUniquePtr

template<class T >
using Dune::ToUniquePtr = typedef std::unique_ptr<T>

Alias for std::unique_ptr introduced as transition wrapper.

Deprecated:

◆ TypeListEntry_t

template<std::size_t i, class T >
using Dune::TypeListEntry_t = typedef typename TypeListElement<i, T>::type

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

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

◆ ViolatedAlignmentHandler

using Dune::ViolatedAlignmentHandler = typedef 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 

Function Documentation

◆ aligned()

template<std::size_t align = debugAlignment, class T >
AlignedNumber< T, align > Dune::aligned ( 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 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.

◆ binomial() [1/3]

template<class T >
static 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>
static 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>
static 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
bboolean value
v1value of b==true
v2value 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

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

◆ doAssertCallOnce()

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

◆ dotT()

template<class A , class B >
auto Dune::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.

See also
http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Vec/VecTDot.html#VecTDot
Parameters
a
b
Returns
a*b

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

◆ factorial() [1/2]

template<class T >
static constexpr T Dune::factorial ( const T &  n)
inlinestaticconstexprnoexcept

calculate the factorial of n as a constexpr

◆ factorial() [2/2]

template<class T , T n>
static constexpr auto Dune::factorial ( std::integral_constant< T, n >  )
inlinestaticconstexprnoexcept

calculate the factorial of n as a constexpr

◆ get()

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

◆ 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
seedThe hash value that will be combined with the hash of arg.
argThe 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
firstIterator pointing to the first object to hash.
lastIterator 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
seedStart value that will be combined with the hash values of all objects in the range using hash_combine() in sequential fashion.
firstIterator pointing to the first object to hash.
lastIterator pointing one past the last object to hash.

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

◆ makeToUnique()

template<class T , class... Args>
std::unique_ptr< T > Dune::makeToUnique ( Args &&...  args)

Alias for std::make_unique introduced as transition wrapper.

Deprecated:

◆ makeTupleVector()

template<class... T>
constexpr 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 >
constexpr 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<<() [1/2]

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

◆ operator<<() [2/2]

template<typename TG , typename TA >
std::ostream & Dune::operator<< ( std::ostream &  os,
const RemoteIndex< TG, TA > &  index 
)
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 >
constexpr 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 >
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!

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

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

This file implements several utilities related to std::shared_ptr.

Usage:

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

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

See also
null_deleter

◆ swap()

template<class T >
void Dune::swap ( T &  v1,
T &  v2,
bool  mask 
)

◆ 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
matrixThe 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
matrixThe 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);
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
matrixThe 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
matrixThe matrix to be transposed.

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

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

is equivalent to

transpose(std::cref(matrix))

.

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

◆ 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

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

an alignment large enough to trigger alignment errors