dune-common
2.4.1
|
Namespaces | |
DenseMatrixHelp | |
DynamicMatrixHelp | |
FloatCmp | |
FMatrixHelp | |
fvmeta | |
Std | |
Classes | |
struct | __is_lvalue_reference_helper |
struct | __is_lvalue_reference_helper< T & > |
struct | __is_pointer_helper |
struct | __is_pointer_helper< T * > |
struct | __remove_pointer_helper |
struct | __remove_pointer_helper< _Tp * > |
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... | |
struct | AlignmentOf |
Calculates the alignment requirement of a type. 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... | |
struct | AlwaysVoid |
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... | |
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 | CollectiveCommunication |
Collective communication interface and sequential default implementation. More... | |
class | CollectiveCommunication< MPI_Comm > |
Specialization of CollectiveCommunication for MPI. 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... | |
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 & > |
struct | ConstantVolatileTraits |
Determines wether a type is const or volatile and provides the unqualified types. More... | |
struct | ConstantVolatileTraits< const T > |
struct | ConstantVolatileTraits< const volatile T > |
struct | ConstantVolatileTraits< volatile T > |
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 | Conversion |
Checks wether a type is convertible to another. More... | |
class | Conversion< From, void > |
class | Conversion< int, double > |
class | Conversion< T, T > |
class | Conversion< void, To > |
class | DebugAllocator |
Allocators implementation which performs different kind of memory checks. More... | |
class | DebugAllocator< void > |
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 | DenseMatVecTraits |
struct | DenseMatVecTraits< DynamicMatrix< K > > |
struct | DenseMatVecTraits< DynamicVector< K, Allocator > > |
struct | DenseMatVecTraits< FieldMatrix< K, ROWS, COLS > > |
struct | DenseMatVecTraits< FieldVector< K, SIZE > > |
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 |
Calculates the factorial of m at compile time. More... | |
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< DynamicMatrix< K > > |
struct | FieldTraits< DynamicVector< K, Allocator > > |
struct | FieldTraits< FieldMatrix< K, ROWS, COLS > > |
struct | FieldTraits< FieldVector< K, SIZE > > |
struct | FieldTraits< std::complex< T > > |
class | FieldVector |
vector space out of a tensor product of fields. More... | |
class | FirstPredicateIndex |
Finding the index of a certain type in a tuple. More... | |
struct | FirstTypeIndex |
Find the first occurance of a type in a tuple. More... | |
struct | FlattenTuple |
Flatten a tuple of tuples. More... | |
class | FloatCmpOps |
Class encapsulating a default epsilon. More... | |
class | fmatrix_assigner |
fmatrix assignment operator More... | |
class | FMatrixError |
Error thrown if operations of a FieldMatrix fail. More... | |
class | FMatrixPrecision |
Precisions for calculations with FieldMatrix and FieldVector. More... | |
class | ForEachType |
Helper template to clone the type definition of a tuple with the storage types replaced by a user-defined rule. More... | |
class | ForEachValue |
Helper template which implements iteration over all storage elements in a tuple. More... | |
class | ForEachValuePair |
Extension of ForEachValue to two tuples... More... | |
class | ForLoop |
A static loop using TMP. More... | |
class | ForwardIteratorFacade |
Base class for stl conformant forward iterators. More... | |
class | Function |
Base class template for function classes. More... | |
class | fvector_assigner |
fvector assignment operator More... | |
struct | Gcd |
Calculator of the greatest common divisor. 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... | |
struct | greater_or_equal |
Greater or equal template test. More... | |
struct | hash |
Functor for hashing objects of type T. 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... | |
class | IdentityMatrix |
Read-only identity matrix. 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 |
singleton | IndicesSyncer |
Class for recomputing missing indices of a distributed index set. 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 | 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 | is_indexable |
struct | is_lvalue_reference |
Determine whether a type is a lvalue reference type. More... | |
struct | is_pointer |
is_pointer More... | |
class | IsBaseOf |
Checks wether a type is derived from another. More... | |
struct | IsConst |
Tests wether a type is constant. 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 | IsInteroperable |
Checks wether two types are interoperable. More... | |
struct | IsType |
Generator for predicates accepting one particular type. More... | |
struct | IsVector |
struct | IsVector< T, typename AlwaysVoid< typename T::field_type >::type > |
struct | IsVolatile |
Tests wether a type is volatile. More... | |
class | IteratorPropertyMap |
Adapter to turn a random access iterator into a property map. More... | |
class | IteratorRange |
Simple range between a begin and an end iterator. More... | |
struct | JoinTuples |
Join two tuples. More... | |
struct | Lcm |
Calculate the least common multiple of two numbers. More... | |
class | LocalIndex |
An index present on the local process. More... | |
struct | LocalIndexComparator |
struct | LocalIndexComparator< ParallelLocalIndex< T > > |
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 | Min |
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.This helper should be used for parallel programs. More... | |
struct | MPITraits |
A traits class describing the mapping of types onto MPI_Datatypes. More... | |
class | MPITraits< IndexPair< TG, ParallelLocalIndex< TA > > > |
class | MPITraits< ParallelLocalIndex< T > > |
struct | mutable_reference |
get the 'mutable' version of a reference to a const object More... | |
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... | |
class | NullPointerInitialiser |
A helper template that initializes a tuple consisting of pointers to NULL. More... | |
class | OutOfMemoryError |
Default exception if memory allocation fails. More... | |
singleton | OwnerOverlapCopyCommunication |
class | ParallelError |
Default exception if an error in the parallel communication of the programm occured. 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 | 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... | |
class | PointerPairDeletor |
Deletes all objects pointed to in a 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 mantissa and a compile-time integer exponent. More... | |
struct | PropertyMapTraits |
struct | PropertyMapTraits< const T * > |
struct | PropertyMapTraits< T * > |
struct | PropertyMapTypeSelector |
Selector for the property map type. More... | |
struct | PushBackTuple |
Helper template to append a type to a tuple. More... | |
struct | PushFrontTuple |
Helper template to prepend a type to a tuple. More... | |
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... | |
struct | remove_pointer |
Return the type a pointer type points to. More... | |
struct | RemoveConstHelper |
struct | RemoveConstHelper< T, true > |
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... | |
class | Singleton |
An adapter to turn a class into a singleton. 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... | |
struct | StaticPower |
Calculates m^p at compile time. More... | |
struct | StaticPower< m, 0 > |
end of recursion via specialization More... | |
class | StreamWrap |
class | SystemError |
Default exception class for OS errors. More... | |
class | Timer |
A simple stop watch. More... | |
class | TimerError |
Exception thrown by the Timer class More... | |
class | TransformTupleFunctor |
helper class to implement transformTuple() More... | |
struct | tuple_writer |
struct | tuple_writer< 0 > |
struct | tuple_writer< 1 > |
struct | TupleAccessTraits |
struct | TupleAccessTraits< T & > |
struct | TupleAccessTraits< T * > |
class | TypeTraits |
General type traits class to check whether type is reference or pointer type. More... | |
class | UncachedSelection |
An uncached selection of indices. 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 | |
typedef unsigned int | DebugLevel |
Type for debug levels. More... | |
typedef dune_nullptr_t | nullptr_t |
typedef DebugStream < VERY_VERBOSE_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL > | DVVerbType |
Type of very verbose debug stream. More... | |
typedef DebugStream < VERBOSE_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL > | DVerbType |
Type of more verbose debug stream. More... | |
typedef DebugStream < INFO_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL > | DInfoType |
Type of debug stream with info level. More... | |
typedef DebugStream < WARN_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL > | DWarnType |
Type of debug stream with warn level. More... | |
typedef DebugStream < GRAVE_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL > | DGraveType |
Type of debug stream for fatal errors. More... | |
typedef DebugStream< 1 > | DErrType |
The type of the stream used for error messages. More... | |
Enumerations | |
enum | { implementationDefined } |
enum | ParallelIndexSetState { GROUND, RESIZE } |
The states the index set can be in. More... | |
enum | LocalIndexState { VALID, DELETED } |
The states avaiable for the local indices. More... | |
Functions | |
template<class T , size_t N> | |
std::ostream & | operator<< (std::ostream &s, const array< T, N > &e) |
Output operator for array. More... | |
template<class T > | |
array< T, 10 > | make_array (const T &t0, const T &t1, const T &t2, const T &t3, const T &t4, const T &t5, const T &t6, const T &t7, const T &t8, const T &t9) |
create an initialize an array More... | |
template<typename T , std::size_t n> | |
array< T, n > | fill_array (const T &t) |
Create an array and fill it with copies of the provided value. 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 (T &t) |
Provide the demangled class name of a given object as a string. More... | |
template<class T > | |
std::string | className () |
Provide the demangled class name of a type T as a string. More... | |
template<class DenseMatrix , class K , int N, int M> | |
void | istl_assign_to_fmatrix (DenseMatrix &denseMatrix, const K(&values)[M][N]) |
template<typename MAT > | |
std::ostream & | operator<< (std::ostream &s, const DenseMatrix< MAT > &a) |
Sends the matrix to an output stream. More... | |
template<class M , class K , int n> | |
void | istl_assign_to_fmatrix (DenseMatrix< M > &fm, const DiagonalMatrix< K, n > &s) |
template<class A , class B > | |
enable_if<!IsVector< A > ::value &&!is_same< typename FieldTraits< A >::field_type, typename FieldTraits< A > ::real_type >::value, typename PromotionTraits< A, B > ::PromotedType >::type | dot (const A &a, const B &b) |
computes the dot product for fundamental data types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b More... | |
template<class A , class B > | |
enable_if<!IsVector< A > ::value &&is_same< typename FieldTraits< A >::field_type, typename FieldTraits< A > ::real_type >::value, typename PromotionTraits< A, B > ::PromotedType >::type | dot (const A &a, const B &b) |
computes the dot product for fundamental data types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b More... | |
template<typename A , typename B > | |
enable_if< IsVector< A > ::value, typename PromotionTraits< typename A::field_type, typename B::field_type >::PromotedType > ::type | dot (const A &a, const B &b) |
computes the dot product for various dune vector types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b More... | |
template<class A , class B > | |
enable_if<!IsVector< A > ::value &&!is_same< typename FieldTraits< A >::field_type, typename FieldTraits< A > ::real_type >::value, typename PromotionTraits< A, B > ::PromotedType >::type | dotT (const A &a, const B &b) |
Computes an indefinite vector dot product for fundamental data types according to Petsc's VectTDot function: dotT(a,b) := a*b. More... | |
template<class A , class B > | |
enable_if< IsVector< A > ::value, typename PromotionTraits< typename A::field_type, typename B::field_type >::PromotedType > ::type | dotT (const A &a, const B &b) |
Computes an indefinite vector dot product for various dune vector types according to Petsc's VectTDot function: dotT(a,b) := a*b. More... | |
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<class T , class K , int s> | |
fvector_assigner< T, s > | operator<<= (FieldVector< T, s > &v, const K &t) |
fvector assignment operator More... | |
template<class T , int s> | |
fvector_assigner< T, s > | operator<<= (FieldVector< T, s > &v, Zero z) |
fvector assignment operator More... | |
template<class T , class K , int n, int m> | |
fmatrix_assigner< T, n, m > | operator<<= (FieldMatrix< T, n, m > &v, const K &t) |
FieldMatrix assignment operator. More... | |
template<class T , int n, int m> | |
fmatrix_assigner< T, n, m > | operator<<= (FieldMatrix< T, n, m > &v, Zero z) |
FieldMatrix assignment operator. More... | |
template<typename T > | |
void | hash_combine (std::size_t &seed, const T &arg) |
Calculates the hash value of arg and combines it in-place with seed. More... | |
template<typename It > | |
std::size_t | hash_range (It first, It last) |
Hashes all elements in the range [first,last) and returns the combined hash. More... | |
template<typename It > | |
void | hash_range (std::size_t &seed, It first, It last) |
Hashes all elements in the range [first,last) and combines the hashes in-place with seed. More... | |
std::ostream & | operator<< (std::ostream &s, const Indent &indent) |
write indentation to a stream More... | |
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
EnableIfInterOperable< T1, T2, bool >::type | operator== (const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs) |
Checks for equality. More... | |
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
EnableIfInterOperable< T1, T2, bool >::type | operator!= (const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs) |
Checks for inequality. More... | |
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
enable_if< Conversion< T2, T1 > ::exists, bool >::type | operator== (const BidirectionalIteratorFacade< T1, V1, R1, D > &lhs, const BidirectionalIteratorFacade< T2, V2, R2, D > &rhs) |
Checks for equality. More... | |
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
enable_if< Conversion< T1, T2 > ::exists &&!Conversion< T2, T1 > ::exists, bool >::type | operator== (const BidirectionalIteratorFacade< T1, V1, R1, D > &lhs, const BidirectionalIteratorFacade< T2, V2, R2, D > &rhs) |
Checks for equality. More... | |
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
EnableIfInterOperable< T1, T2, bool >::type | operator!= (const BidirectionalIteratorFacade< T1, V1, R1, D > &lhs, const BidirectionalIteratorFacade< T2, V2, R2, D > &rhs) |
Checks for inequality. More... | |
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
EnableIfInterOperable< T1, T2, bool >::type | operator== (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs) |
Checks for equality. More... | |
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
EnableIfInterOperable< T1, T2, bool >::type | operator!= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs) |
Checks for inequality. More... | |
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
EnableIfInterOperable< T1, T2, bool >::type | operator< (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs) |
Comparison operator. More... | |
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
EnableIfInterOperable< T1, T2, bool >::type | operator<= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs) |
Comparison operator. More... | |
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
EnableIfInterOperable< T1, T2, bool >::type | operator> (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs) |
Comparison operator. More... | |
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
EnableIfInterOperable< T1, T2, bool >::type | operator>= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs) |
Comparison operator. More... | |
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 > | |
EnableIfInterOperable< T1, T2, D >::type | operator- (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs) |
Calculates the difference between two pointers. More... | |
template<class K > | |
K | conjugateComplex (const K &x) |
compute conjugate complex of x More... | |
template<class T > | |
int | sign (const T &val) |
Return the sign of the value. More... | |
template<class TG , class TL > | |
std::ostream & | operator<< (std::ostream &os, const IndexPair< TG, TL > &pair) |
Print an index pair. More... | |
template<class TG , class TL > | |
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. More... | |
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. More... | |
template<typename T , typename A , typename A1 > | |
void | repairLocalIndexPointers (std::map< int, SLList< std::pair< typename T::GlobalIndex, typename T::LocalIndex::Attribute >, A > > &globalMap, RemoteIndices< T, A1 > &remoteIndices, const T &indexSet) |
Repair the pointers to the local indices in the remote indices. More... | |
ComposeMPIOp (char, std::plus, MPI_SUM) | |
ComposeMPIOp (unsigned char, std::plus, MPI_SUM) | |
ComposeMPIOp (short, std::plus, MPI_SUM) | |
ComposeMPIOp (int, std::plus, MPI_SUM) | |
ComposeMPIOp (long, std::plus, MPI_SUM) | |
ComposeMPIOp (float, std::plus, MPI_SUM) | |
ComposeMPIOp (double, std::plus, MPI_SUM) | |
ComposeMPIOp (char, std::multiplies, MPI_PROD) | |
ComposeMPIOp (unsigned char, std::multiplies, MPI_PROD) | |
ComposeMPIOp (short, std::multiplies, MPI_PROD) | |
ComposeMPIOp (int, std::multiplies, MPI_PROD) | |
ComposeMPIOp (long, std::multiplies, MPI_PROD) | |
ComposeMPIOp (float, std::multiplies, MPI_PROD) | |
ComposeMPIOp (double, std::multiplies, MPI_PROD) | |
ComposeMPIOp (char, Min, MPI_MIN) | |
ComposeMPIOp (unsigned char, Min, MPI_MIN) | |
ComposeMPIOp (short, Min, MPI_MIN) | |
ComposeMPIOp (int, Min, MPI_MIN) | |
ComposeMPIOp (long, Min, MPI_MIN) | |
ComposeMPIOp (float, Min, MPI_MIN) | |
ComposeMPIOp (double, Min, MPI_MIN) | |
ComposeMPIOp (char, Max, MPI_MAX) | |
ComposeMPIOp (unsigned char, Max, MPI_MAX) | |
ComposeMPIOp (short, Max, MPI_MAX) | |
ComposeMPIOp (int, Max, MPI_MAX) | |
ComposeMPIOp (long, Max, MPI_MAX) | |
ComposeMPIOp (float, Max, MPI_MAX) | |
ComposeMPIOp (double, Max, MPI_MAX) | |
template<class T > | |
std::ostream & | operator<< (std::ostream &os, const ParallelLocalIndex< T > &index) |
Print the local index to a stream. More... | |
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 More... | |
std::string | processPath (const std::string &p) |
sanitize a path for further processing More... | |
bool | pathIndicatesDirectory (const std::string &p) |
check whether the given path indicates that it is a directory More... | |
std::string | prettyPath (const std::string &p, bool isDirectory) |
pretty print path More... | |
std::string | prettyPath (const std::string &p) |
pretty print path More... | |
std::string | relativePath (const std::string &newbase, const std::string &p) |
compute a relative path between two paths More... | |
template<typename 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). More... | |
template<typename T > | |
shared_ptr< T > | stackobject_to_shared_ptr (T &t) |
Create a shared_ptr for a stack-allocated object. More... | |
template<typename T , typename T2 > | |
shared_ptr< T2 > | stackobject_to_shared_ptr (T &t) |
Create a shared_ptr to a base class for a stack-allocated object. More... | |
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. More... | |
template<typename C > | |
bool | hasPrefix (const C &c, const char *prefix) |
Check whether a character container has a given prefix. More... | |
template<typename C > | |
bool | hasSuffix (const C &c, const char *suffix) |
Check whether a character container has a given suffix. More... | |
template<class... T> | |
static std::string | formatString (const std::string &s, const T &...args) |
Format values according to printf format string. More... | |
template<typename T1 > | |
std::ostream & | operator<< (std::ostream &os, const tuple< T1 > &t) |
Print a tuple. More... | |
template<typename T1 , typename T2 > | |
std::ostream & | operator<< (std::ostream &os, const tuple< T1, T2 > &t) |
template<typename T1 , typename T2 , typename T3 > | |
std::ostream & | operator<< (std::ostream &os, const tuple< T1, T2, T3 > &t) |
template<typename T1 , typename T2 , typename T3 , typename T4 > | |
std::ostream & | operator<< (std::ostream &os, const tuple< T1, T2, T3, T4 > &t) |
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > | |
std::ostream & | operator<< (std::ostream &os, const tuple< T1, T2, T3, T4, T5 > &t) |
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > | |
std::ostream & | operator<< (std::ostream &os, const tuple< T1, T2, T3, T4, T5, T6 > &t) |
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 > | |
std::ostream & | operator<< (std::ostream &os, const tuple< T1, T2, T3, T4, T5, T6, T7 > &t) |
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 > | |
std::ostream & | operator<< (std::ostream &os, const tuple< T1, T2, T3, T4, T5, T6, T7, T8 > &t) |
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 > | |
std::ostream & | operator<< (std::ostream &os, const tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 > &t) |
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 > | |
std::ostream & | operator<< (std::ostream &os, const tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 > &t) |
template<typename T1 > | |
std::istream & | operator>> (std::istream &is, tuple< T1 > &t) |
Read a tuple. More... | |
template<typename T1 , typename T2 > | |
std::istream & | operator>> (std::istream &is, tuple< T1, T2 > &t) |
template<typename T1 , typename T2 , typename T3 > | |
std::istream & | operator>> (std::istream &is, tuple< T1, T2, T3 > &t) |
template<typename T1 , typename T2 , typename T3 , typename T4 > | |
std::istream & | operator>> (std::istream &is, tuple< T1, T2, T3, T4 > &t) |
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > | |
std::istream & | operator>> (std::istream &is, tuple< T1, T2, T3, T4, T5 > &t) |
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > | |
std::istream & | operator>> (std::istream &is, tuple< T1, T2, T3, T4, T5, T6 > &t) |
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 > | |
std::istream & | operator>> (std::istream &is, tuple< T1, T2, T3, T4, T5, T6, T7 > &t) |
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 > | |
std::istream & | operator>> (std::istream &is, tuple< T1, T2, T3, T4, T5, T6, T7, T8 > &t) |
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 > | |
std::istream & | operator>> (std::istream &is, tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 > &t) |
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 > | |
std::istream & | operator>> (std::istream &is, tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 > &t) |
template<class Tuple , class Functor > | |
ForEachType< Functor::template TypeEvaluator, Tuple >::Type | genericTransformTuple (Tuple &t, Functor &f) |
transform a tuple object into another tuple object More... | |
template<template< class > class TE, class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 > | |
TransformTupleFunctor< TE, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9 > | makeTransformTupleFunctor (A0 &a0, A1 &a1, A2 &a2, A3 &a3, A4 &a4, A5 &a5, A6 &a6, A7 &a7, A8 &a8, A9 &a9) |
syntactic sugar for creation of TransformTupleFunctor objects More... | |
template<template< class > class TypeEvaluator, class Tuple , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 > | |
remove_const< typename ForEachType< TypeEvaluator, Tuple >::Type >::type | transformTuple (Tuple &orig, A0 &a0, A1 &a1, A2 &a2, A3 &a3, A4 &a4, A5 &a5, A6 &a6, A7 &a7, A8 &a8, A9 &a9) |
transform a tuple's value according to a user-supplied policy More... | |
Variables | |
DVVerbType | dvverb (std::cout) |
stream for very verbose output. More... | |
DVerbType | dverb (std::cout) |
Singleton of verbose debug stream. More... | |
DInfoType | dinfo (std::cout) |
Stream for informative output. More... | |
DWarnType | dwarn (std::cerr) |
Stream for warnings indicating problems. More... | |
DGraveType | dgrave (std::cerr) |
Stream for warnings indicating fatal errors. More... | |
DErrType | derr (std::cerr) |
Stream for error messages. More... | |
static const DebugLevel | MINIMAL_DEBUG_LEVEL = DUNE_MINIMAL_DEBUG_LEVEL |
static const DebugLevel | VERY_VERBOSE_DEBUG_LEVEL = 1 |
The level of the very verbose debug stream. More... | |
static const DebugLevel | VERBOSE_DEBUG_LEVEL = 2 |
The level of the verbose debug stream. More... | |
static const DebugLevel | INFO_DEBUG_LEVEL = 3 |
The level of the informative debug stream. More... | |
static const DebugLevel | WARN_DEBUG_LEVEL = 4 |
The level of the debug stream for warnings. More... | |
static const DebugLevel | GRAVE_DEBUG_LEVEL = 5 |
The level of the debug stream for fatal errors. More... | |
Dune namespace.
typedef dune_nullptr_t Dune::nullptr_t |
anonymous enum |
Enumerator | |
---|---|
implementationDefined |
Dummy integral value used for documentation purposes. #include <dune/common/documentation.hh>
|
|
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.
References doAssertCallOnce(), and DUNE_UNUSED.
std::string Dune::className | ( | T & | t | ) |
Provide the demangled class name of a given object as a string.
References t.
Referenced by className().
std::string Dune::className | ( | ) |
Provide the demangled class name of a type T as a string.
References className().
Dune::ComposeMPIOp | ( | char | , |
std::plus | , | ||
MPI_SUM | |||
) |
Dune::ComposeMPIOp | ( | unsigned | char, |
std::plus | , | ||
MPI_SUM | |||
) |
Dune::ComposeMPIOp | ( | short | , |
std::plus | , | ||
MPI_SUM | |||
) |
Dune::ComposeMPIOp | ( | int | , |
std::plus | , | ||
MPI_SUM | |||
) |
Dune::ComposeMPIOp | ( | long | , |
std::plus | , | ||
MPI_SUM | |||
) |
Dune::ComposeMPIOp | ( | float | , |
std::plus | , | ||
MPI_SUM | |||
) |
Dune::ComposeMPIOp | ( | double | , |
std::plus | , | ||
MPI_SUM | |||
) |
Dune::ComposeMPIOp | ( | char | , |
std::multiplies | , | ||
MPI_PROD | |||
) |
Dune::ComposeMPIOp | ( | unsigned | char, |
std::multiplies | , | ||
MPI_PROD | |||
) |
Dune::ComposeMPIOp | ( | short | , |
std::multiplies | , | ||
MPI_PROD | |||
) |
Dune::ComposeMPIOp | ( | int | , |
std::multiplies | , | ||
MPI_PROD | |||
) |
Dune::ComposeMPIOp | ( | long | , |
std::multiplies | , | ||
MPI_PROD | |||
) |
Dune::ComposeMPIOp | ( | float | , |
std::multiplies | , | ||
MPI_PROD | |||
) |
Dune::ComposeMPIOp | ( | double | , |
std::multiplies | , | ||
MPI_PROD | |||
) |
Dune::ComposeMPIOp | ( | char | , |
Min | , | ||
MPI_MIN | |||
) |
Dune::ComposeMPIOp | ( | unsigned | char, |
Min | , | ||
MPI_MIN | |||
) |
Dune::ComposeMPIOp | ( | short | , |
Min | , | ||
MPI_MIN | |||
) |
Dune::ComposeMPIOp | ( | int | , |
Min | , | ||
MPI_MIN | |||
) |
Dune::ComposeMPIOp | ( | long | , |
Min | , | ||
MPI_MIN | |||
) |
Dune::ComposeMPIOp | ( | float | , |
Min | , | ||
MPI_MIN | |||
) |
Dune::ComposeMPIOp | ( | double | , |
Min | , | ||
MPI_MIN | |||
) |
Dune::ComposeMPIOp | ( | char | , |
Max | , | ||
MPI_MAX | |||
) |
Dune::ComposeMPIOp | ( | unsigned | char, |
Max | , | ||
MPI_MAX | |||
) |
Dune::ComposeMPIOp | ( | short | , |
Max | , | ||
MPI_MAX | |||
) |
Dune::ComposeMPIOp | ( | int | , |
Max | , | ||
MPI_MAX | |||
) |
Dune::ComposeMPIOp | ( | long | , |
Max | , | ||
MPI_MAX | |||
) |
Dune::ComposeMPIOp | ( | float | , |
Max | , | ||
MPI_MAX | |||
) |
Dune::ComposeMPIOp | ( | double | , |
Max | , | ||
MPI_MAX | |||
) |
|
inline |
compute conjugate complex of x
Referenced by Dune::DiagonalMatrix< K, n >::mmhv(), Dune::DenseMatrix< FieldMatrix< T, ROWS, COLS > >::mmhv(), Dune::DiagonalMatrix< K, n >::umhv(), Dune::DenseMatrix< FieldMatrix< T, ROWS, COLS > >::umhv(), Dune::DiagonalMatrix< K, n >::usmhv(), and Dune::DenseMatrix< FieldMatrix< T, ROWS, COLS > >::usmhv().
void Dune::doAssertCallOnce | ( | const char * | file, |
int | line, | ||
const char * | function | ||
) |
Referenced by assertCallOnce().
|
inline |
computes the dot product for fundamental data types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b
Specialization for real first arguments which replaces conj(a) by a.
a | |
b |
|
inline |
computes the dot product for various dune vector types according to Petsc's VectDot function: dot(a,b) := std::conj(a)*b
Specialization for real first arguments which replaces conj(a) by a.
a | |
b |
|
inline |
Computes an indefinite vector dot product for fundamental data types according to Petsc's VectTDot function: dotT(a,b) := a*b.
a | |
b |
|
inline |
Computes an indefinite vector dot product for various dune vector types according to Petsc's VectTDot function: dotT(a,b) := a*b.
a | |
b |
ForEachType<Functor::template TypeEvaluator, Tuple>::Type Dune::genericTransformTuple | ( | Tuple & | t, |
Functor & | f | ||
) |
transform a tuple object into another tuple object
This function does for the value of a tuple what ForEachType does for the type of a tuple: it transforms the value using a user-provided policy functor.
t | The tuple value to transform. |
f | The functor to use to transform the values. |
The functor should have the following form:
The member class template TypeEvaluator
should be a class template suitable as the TypeEvaluator
template parameter for ForEachType. The function call operator operator()
is used to transform the value; only the signatures of operator()
which are actually used must be present.
There are overloaded definitions of genericTransformTuple() wich take constant tuple and functor arguments so rvalues are permissible as arguments here. These overloaded definitions are not documented separately.
Referenced by transformTuple().
|
inline |
Referenced by Dune::tuple_writer< i >::get(), operator>>(), and Dune::tuple_writer< i >::put().
pointer_or_proxy_holder Dune::handle_proxy_member_access | ( | T && | t | ) |
Transparent support for providing member access to both lvalues and rvalues (temporary proxies).
If an iterator facade (like entity iterators) wants to allow the embedded implementation to return either an (internally stored) reference or a temporary object and expose these two behaviors to enable performance optimizations, operator->() needs special handling: If the implementation returns a reference, operator->() in the facade can simply return the address of the referenced object, but if the returned object is a temporary, we need to capture and store it in a helper object to make sure it outlives the member access. This function transparently supports both variants. It should be used like this:
|
inline |
Calculates the hash value of arg and combines it in-place with seed.
HAVE_DUNE_HASH
is defined.seed | The hash value that will be combined with the hash of arg. |
arg | The object for which to calculate a hash value and combine it with seed. |
Referenced by hash_range().
|
inline |
Hashes all elements in the range [first,last) and returns the combined hash.
HAVE_DUNE_HASH
is defined.first | Iterator pointing to the first object to hash. |
last | Iterator pointing one past the last object to hash. |
References hash_combine().
|
inline |
Hashes all elements in the range [first,last) and combines the hashes in-place with seed.
HAVE_DUNE_HASH
is defined.seed | Start value that will be combined with the hash values of all objects in the range using hash_combine() in sequential fashion. |
first | Iterator pointing to the first ojbect to hash. |
last | Iterator pointing one past the last object to hash. |
References hash_combine().
TransformTupleFunctor<TE, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> Dune::makeTransformTupleFunctor | ( | A0 & | a0, |
A1 & | a1, | ||
A2 & | a2, | ||
A3 & | a3, | ||
A4 & | a4, | ||
A5 & | a5, | ||
A6 & | a6, | ||
A7 & | a7, | ||
A8 & | a8, | ||
A9 & | a9 | ||
) |
syntactic sugar for creation of TransformTupleFunctor objects
TE | TypeEvaluator class template. |
A0 | Type of extra arguments to pass to TE<T>::apply() . It should not be necessary to specify these template parameters explicitly since they can be deduced. |
A1 | Type of extra arguments to pass to TE<T>::apply() . It should not be necessary to specify these template parameters explicitly since they can be deduced. |
A2 | Type of extra arguments to pass to TE<T>::apply() . It should not be necessary to specify these template parameters explicitly since they can be deduced. |
A3 | Type of extra arguments to pass to TE<T>::apply() . It should not be necessary to specify these template parameters explicitly since they can be deduced. |
A4 | Type of extra arguments to pass to TE<T>::apply() . It should not be necessary to specify these template parameters explicitly since they can be deduced. |
A5 | Type of extra arguments to pass to TE<T>::apply() . It should not be necessary to specify these template parameters explicitly since they can be deduced. |
A6 | Type of extra arguments to pass to TE<T>::apply() . It should not be necessary to specify these template parameters explicitly since they can be deduced. |
A7 | Type of extra arguments to pass to TE<T>::apply() . It should not be necessary to specify these template parameters explicitly since they can be deduced. |
A8 | Type of extra arguments to pass to TE<T>::apply() . It should not be necessary to specify these template parameters explicitly since they can be deduced. |
A9 | Type of extra arguments to pass to TE<T>::apply() . It should not be necessary to specify these template parameters explicitly since they can be deduced. |
a0 | Arguments to save references to in the TransformTupleFunctor. |
a1 | Arguments to save references to in the TransformTupleFunctor. |
a2 | Arguments to save references to in the TransformTupleFunctor. |
a3 | Arguments to save references to in the TransformTupleFunctor. |
a4 | Arguments to save references to in the TransformTupleFunctor. |
a5 | Arguments to save references to in the TransformTupleFunctor. |
a6 | Arguments to save references to in the TransformTupleFunctor. |
a7 | Arguments to save references to in the TransformTupleFunctor. |
a8 | Arguments to save references to in the TransformTupleFunctor. |
a9 | Arguments to save references to in the TransformTupleFunctor. |
There are overloads of this function (not documented separately) for any number of arguments, up to an implementation-defined arbitrary limit. The number of arguments given determines the number of non-void
template arguments in the type of the returned TransformTupleFunctor.
|
inline |
|
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.
|
inline |
Referenced by operator<<().
int Dune::sign | ( | const T & | val | ) |
Return the sign of the value.
|
inline |
Create a shared_ptr for a stack-allocated object.
Usage:
The 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.
References t.
|
inline |
Create a shared_ptr to a base class for a stack-allocated object.
Usage:
The 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.
References t.
remove_const<typename ForEachType<TypeEvaluator, Tuple>::Type>::type Dune::transformTuple | ( | Tuple & | orig, |
A0 & | a0, | ||
A1 & | a1, | ||
A2 & | a2, | ||
A3 & | a3, | ||
A4 & | a4, | ||
A5 & | a5, | ||
A6 & | a6, | ||
A7 & | a7, | ||
A8 & | a8, | ||
A9 & | a9 | ||
) |
transform a tuple's value according to a user-supplied policy
This function provides functionality similar to genericTransformTuple(), although less general and closer in spirit to ForEachType.
TypeEvaluator | Used as the TE template argument to TransformTupleFunctor internally. |
Tuple | Type of the tuple to transform. |
A0 | Types of extra argument to call the transformation function with. |
A1 | Types of extra argument to call the transformation function with. |
A2 | Types of extra argument to call the transformation function with. |
A3 | Types of extra argument to call the transformation function with. |
A4 | Types of extra argument to call the transformation function with. |
A5 | Types of extra argument to call the transformation function with. |
A6 | Types of extra argument to call the transformation function with. |
A7 | Types of extra argument to call the transformation function with. |
A8 | Types of extra argument to call the transformation function with. |
A9 | Types of extra argument to call the transformation function with. |
Tuple
and An
template arguments can be deduced from the function arguments, so they can usually be omitted.orig | Tuple value to be transformed. |
a0 | Extra argument values to provide to the transformation function. |
a1 | Extra argument values to provide to the transformation function. |
a2 | Extra argument values to provide to the transformation function. |
a3 | Extra argument values to provide to the transformation function. |
a4 | Extra argument values to provide to the transformation function. |
a5 | Extra argument values to provide to the transformation function. |
a6 | Extra argument values to provide to the transformation function. |
a7 | Extra argument values to provide to the transformation function. |
a8 | Extra argument values to provide to the transformation function. |
a9 | Extra argument values to provide to the transformation function. |
This function is overloaded for any number of extra arguments, up to an implementation-defined arbitrary limit. The overloads are not documented separately.
The TypeEvaluator
class template should be suitable as the TE
template argument for TransformTupleFunctor. It has the following form (an extension of the TypeEvaluator
template argument of ForEachType):
For any given element type T
of the tuple, the TypeEvaluator template class should provide a member typedef Type
which determines the type of the transformed value and a static function apply()
, taking the value of the tuple element t
and the extra arguments given to transformTuple(). The signature of apply()
does not have to match the one given above exactly, as long as it can be called that way.
const
SomeType
. Specifically this means that you cannot simply use literals or function return values as extra arguments. Providing overloads for all possible combinations of rvalue and lvalue extra arguments would result in References genericTransformTuple().