|
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...
|
|
|
template<int k> |
std::ostream & | operator<< (std::ostream &s, const bigunsignedint< k > &x) |
|
template<int k> |
bigunsignedint< k > | operator+ (const bigunsignedint< k > &x, std::uintmax_t y) |
|
template<int k> |
bigunsignedint< k > | operator- (const bigunsignedint< k > &x, std::uintmax_t y) |
|
template<int k> |
bigunsignedint< k > | operator* (const bigunsignedint< k > &x, std::uintmax_t y) |
|
template<int k> |
bigunsignedint< k > | operator/ (const bigunsignedint< k > &x, std::uintmax_t y) |
|
template<int k> |
bigunsignedint< k > | operator% (const bigunsignedint< k > &x, std::uintmax_t y) |
|
template<int k> |
bigunsignedint< k > | operator+ (std::uintmax_t x, const bigunsignedint< k > &y) |
|
template<int k> |
bigunsignedint< k > | operator- (std::uintmax_t x, const bigunsignedint< k > &y) |
|
template<int k> |
bigunsignedint< k > | operator* (std::uintmax_t x, const bigunsignedint< k > &y) |
|
template<int k> |
bigunsignedint< k > | operator/ (std::uintmax_t x, const bigunsignedint< k > &y) |
|
template<int k> |
bigunsignedint< k > | operator% (std::uintmax_t x, const bigunsignedint< k > &y) |
|
template<class T > |
std::string | className () |
| Provide the demangled class name of a type T as a string.
|
|
template<class T > |
std::string | className (T &&v) |
| Provide the demangled class name of a given object as a string.
|
|
template<class C , class... T> |
constexpr auto | models () |
| Check if concept is modeled by given types.
|
|
template<typename T1 , typename T2 > |
const T1 | cond (bool b, const T1 &v1, const T2 &v2) |
| conditional evaluate
|
|
static void | defaultViolatedAlignment (const char *className, std::size_t expectedAlignment, const void *address) |
| default alignment violation handler
|
|
ViolatedAlignmentHandler & | violatedAlignmentHandler () |
| access the handler called by violatedAlignment()
|
|
void | violatedAlignment (const char *className, std::size_t expectedAlignment, const void *address) |
| called when an alignment violation is detected
|
|
bool | isAligned (const void *p, std::size_t align) |
| check whether an address conforms to the given alignment
|
|
template<std::size_t align = debugAlignment, class T > |
AlignedNumber< T, align > | aligned (T value) |
| align a value to a certain alignment
|
|
template<class T , std::size_t align> |
AlignedNumber< T, align > | cond (const AlignedNumber< bool, align > &b, const AlignedNumber< T, align > &v1, const AlignedNumber< T, align > &v2) |
|
template<class T , std::size_t align> |
T | max_value (const AlignedNumber< T, align > &val) |
|
template<class T , std::size_t align> |
T | min_value (const AlignedNumber< T, align > &val) |
|
template<std::size_t align> |
bool | any_true (const AlignedNumber< bool, align > &val) |
|
template<std::size_t align> |
bool | all_true (const AlignedNumber< bool, align > &val) |
|
template<typename MAT > |
std::ostream & | operator<< (std::ostream &s, const DenseMatrix< MAT > &a) |
| Sends the matrix to an output stream.
|
|
template<class A , class B > |
auto | dot (const A &a, const B &b) -> typename std::enable_if< IsNumber< A >::value &&!IsVector< A >::value &&!std::is_same< typename FieldTraits< A >::field_type, typename FieldTraits< A >::real_type > ::value, decltype(conj(a) *b)>::type |
| computes the dot product for fundamental data types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b
|
|
template<class A , class B > |
auto | 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 > |
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 > |
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.
|
|