dune-common
2.4.1-rc2
|
Namespaces | |
DenseMatrixHelp | |
DynamicMatrixHelp | |
FloatCmp | |
FMatrixHelp | |
fvmeta | |
Std | |
Classes | |
struct | AlignmentOf |
Calculates the alignment requirement of a type. More... | |
class | ArrayListIterator |
A random access iterator for the Dune::ArrayList class. More... | |
class | ConstArrayListIterator |
A constant random access iterator for the Dune::ArrayList class. More... | |
class | ArrayList |
A dynamically growing random access list. More... | |
struct | MPITraits |
A traits class describing the mapping of types onto MPI_Datatypes. More... | |
class | bigunsignedint |
Portable very large unsigned integers. More... | |
struct | Min |
struct | Max |
class | BitSetVector |
A dynamic array of blocks of booleans. More... | |
class | BitSetVectorReference |
A proxy class that acts as a mutable reference to a single bitset in a BitSetVector. More... | |
class | BitSetVectorConstReference |
A proxy class that acts as a const reference to a single bitset in a BitSetVector. More... | |
struct | const_reference< BitSetVectorReference< block_size, Alloc > > |
struct | const_reference< BitSetVectorConstReference< block_size, Alloc > > |
struct | mutable_reference< BitSetVectorReference< block_size, Alloc > > |
struct | mutable_reference< BitSetVectorConstReference< block_size, Alloc > > |
class | DebugAllocator |
Allocators implementation which performs different kind of memory checks. More... | |
class | DebugAllocator< void > |
struct | greater_or_equal |
Greater or equal template test. More... | |
struct | common_bits |
activate if current and mask have common bits switched on. More... | |
class | DebugStreamError |
standard exception for the debugstream More... | |
class | StreamWrap |
class | DebugStreamState |
Intermediate class to implement tie-operation of DebugStream. More... | |
class | DebugStream |
Generic class to implement debug output streams. More... | |
class | DenseMatrix |
A dense n x m matrix. More... | |
struct | FieldTraits< DenseMatrix< M > > |
class | FieldMatrix |
A dense n x m matrix. More... | |
class | FieldVector |
vector space out of a tensor product of fields. More... | |
struct | DenseMatrixAssigner |
you have to specialize this structure for any type that should be assignable to a DenseMatrix More... | |
class | FMatrixError |
Error thrown if operations of a FieldMatrix fail. More... | |
class | DenseVector |
Interface for a class of dense vectors over a given field. More... | |
struct | FieldTraits< DenseVector< V > > |
class | DenseIterator |
Generic iterator class for dense vector and matrix implementations. More... | |
class | DiagonalRowVectorConst |
class | DiagonalRowVector |
class | DiagonalMatrixWrapper |
class | ContainerWrapperIterator |
Iterator class for sparse vector-like containers. More... | |
class | DiagonalMatrix |
A diagonal matrix of static size. More... | |
struct | const_reference< DiagonalRowVector< K, n > > |
struct | const_reference< DiagonalRowVectorConst< K, n > > |
struct | mutable_reference< DiagonalRowVector< K, n > > |
struct | mutable_reference< DiagonalRowVectorConst< K, n > > |
struct | ImplementationDefined |
Dummy struct used for documentation purposes. More... | |
struct | AlwaysVoid |
struct | IsVector |
struct | IsVector< T, typename AlwaysVoid< typename T::field_type >::type > |
class | DynamicMatrix |
Construct a matrix with a dynamic size. More... | |
struct | DenseMatVecTraits< DynamicMatrix< K > > |
struct | FieldTraits< DynamicMatrix< K > > |
class | DynamicVector |
Construct a vector with a dynamic size. More... | |
struct | DenseMatVecTraits< DynamicVector< K, Allocator > > |
struct | FieldTraits< DynamicVector< K, Allocator > > |
class | EmptySet |
An empty set. More... | |
class | AllSet |
A set containing everything. More... | |
class | EnumItem |
A set consisting only of one item. More... | |
class | EnumRange |
A set representing a range including the borders. More... | |
class | NegateSet |
The negation of a set. An item is contained in the set if and only if it is not contained in the negated set. More... | |
class | Combine |
A set combining two other sets. More... | |
class | Exception |
Base class for Dune-Exceptions. More... | |
struct | ExceptionHook |
Base class to add a hook to the Dune::Exception. More... | |
class | IOError |
Default exception class for I/O errors. More... | |
class | MathError |
Default exception class for mathematical errors. More... | |
class | RangeError |
Default exception class for range errors. More... | |
class | NotImplemented |
Default exception for dummy implementations. More... | |
class | SystemError |
Default exception class for OS errors. More... | |
class | OutOfMemoryError |
Default exception if memory allocation fails. More... | |
class | InvalidStateException |
Default exception if a function was called while the object is not in a valid state for that function. More... | |
class | ParallelError |
Default exception if an error in the parallel communication of the programm occured. More... | |
class | fvector_assigner |
fvector assignment operator More... | |
class | fmatrix_assigner |
fmatrix assignment operator More... | |
class | FloatCmpOps |
Class encapsulating a default epsilon. More... | |
struct | DenseMatVecTraits< FieldMatrix< K, ROWS, COLS > > |
struct | FieldTraits< FieldMatrix< K, ROWS, COLS > > |
class | ForLoop |
A static loop using TMP. More... | |
struct | FieldTraits |
struct | FieldTraits< const T > |
struct | FieldTraits< std::complex< T > > |
class | Function |
Base class template for function classes. More... | |
class | VirtualFunction |
Virtual base class template for function classes. More... | |
struct | DenseMatVecTraits< FieldVector< K, SIZE > > |
struct | FieldTraits< FieldVector< K, SIZE > > |
struct | IsFieldVectorSizeCorrect |
TMP to check the size of a DenseVectors statically, if possible. More... | |
struct | IsFieldVectorSizeCorrect< FieldVector< T, SIZE >, SIZE > |
struct | IsFieldVectorSizeCorrect< FieldVector< T, SIZE1 >, SIZE > |
struct | Gcd |
Calculator of the greatest common divisor. More... | |
struct | const_reference |
Get the 'const' version of a reference to a mutable object. More... | |
struct | const_reference< const R > |
struct | const_reference< R & > |
struct | const_reference< const R & > |
struct | mutable_reference |
get the 'mutable' version of a reference to a const object More... | |
struct | mutable_reference< const R > |
struct | mutable_reference< R & > |
struct | mutable_reference< const R & > |
class | GenericIterator |
Generic class for stl-conforming iterators for container classes with operator[]. More... | |
struct | hash |
Functor for hashing objects of type T. More... | |
class | IdentityMatrix |
Read-only identity matrix. More... | |
class | Indent |
Utility class for handling nested indentation in output. More... | |
struct | Cloneable |
An interface class for cloneable objects. More... | |
class | ios_base_all_saver |
Utility class for storing and resetting stream attributes. More... | |
class | ForwardIteratorFacade |
Base class for stl conformant forward iterators. More... | |
class | BidirectionalIteratorFacade |
Facade class for stl conformant bidirectional iterators. More... | |
class | RandomAccessIteratorFacade |
Base class for stl conformant forward iterators. More... | |
class | IteratorRange |
Simple range between a begin and an end iterator. More... | |
struct | Lcm |
Calculate the least common multiple of two numbers. More... | |
class | lru |
LRU Cache Container. More... | |
class | MallocAllocator |
Allocators implementation which simply calls malloc/free. More... | |
struct | MathematicalConstants |
Provides commonly used mathematical constants. More... | |
struct | StandardMathematicalConstants |
Standard implementation of MathematicalConstants. More... | |
struct | Factorial |
Calculates the factorial of m at compile time. More... | |
struct | Factorial< 0 > |
end of recursion of factorial via specialization More... | |
struct | DenseMatVecTraits |
struct | No_Comm |
class | CollectiveCommunication |
Collective communication interface and sequential default implementation. More... | |
struct | SizeOne |
Flag for marking indexed data structures where data at each index is of the same size. More... | |
struct | VariableSize |
Flag for marking indexed data structures where the data at each index may be a variable multiple of another type. More... | |
struct | CommPolicy |
Default policy used for communicating an indexed type. More... | |
class | BufferedCommunicator |
A communicator that uses buffers to gather and scatter the data to be send or received. More... | |
class | IndexPair |
A pair consisting of a global and local index. More... | |
class | InvalidIndexSetState |
Exception indicating that the index set is not in the expected state. More... | |
class | GlobalLookupIndexSet |
Decorates an index set with the possibility to find a global index that is mapped to a specific local. More... | |
class | ParallelIndexSet |
Manager class for the mapping between local indices and globally unique indices. More... | |
struct | LocalIndexComparator |
struct | IndexSetSortFunctor |
class | IndicesSyncer |
Class for recomputing missing indices of a distributed index set. More... | |
class | InterfaceBuilder |
Base class of all classes representing a communication interface. More... | |
class | InterfaceInformation |
Information describing an interface. More... | |
class | Interface |
Communication interface between remote and local indices. More... | |
class | LocalIndex |
An index present on the local process. More... | |
class | Generic_MPI_Op |
class | CollectiveCommunication< MPI_Comm > |
Specialization of CollectiveCommunication for MPI. More... | |
class | MPIGuardError |
This exception is thrown if the MPIGuard detects an error on a remote process. More... | |
class | MPIGuard |
detects a thrown exception and communicates to all other processes More... | |
class | FakeMPIHelper |
A fake mpi helper. More... | |
class | MPIHelper |
A real mpi helper.This helper should be used for parallel programs. More... | |
class | ParallelLocalIndex |
An index present on the local process with an additional attribute flag. More... | |
struct | LocalIndexComparator< ParallelLocalIndex< T > > |
class | MPITraits< ParallelLocalIndex< T > > |
class | MPITraits< IndexPair< TG, ParallelLocalIndex< TA > > > |
class | RemoteIndices |
The indices present on remote processes. More... | |
class | RemoteIndex |
Information about an index residing on another processor. More... | |
class | RemoteIndexListModifier |
Modifier for adding and/or deleting remote indices from the remote index list. More... | |
class | CollectiveIterator |
A collective iterator for moving over the remote indices for all processes collectively. More... | |
class | OwnerOverlapCopyCommunication |
class | SelectionIterator |
A const iterator over an uncached selection. More... | |
class | UncachedSelection |
An uncached selection of indices. More... | |
class | Selection |
A cached selection of indices. More... | |
class | VariableSizeCommunicator |
A buffered communicator where the amount of data sent does not have to be known a priori. More... | |
class | ParameterTree |
Hierarchical structure of string parameters. More... | |
class | ParameterTreeParserError |
report parser error while reading ParameterTree More... | |
class | HelpRequest |
exception thrown if the user wants to see help string More... | |
class | ParameterTreeParser |
Parsers to set up a ParameterTree from various input sources. More... | |
class | Pool |
A memory pool of objects. More... | |
class | PoolAllocator |
An allocator managing a pool of objects for reuse. More... | |
class | PoolAllocator< void, s > |
struct | StaticPower |
Calculates m^p at compile time. More... | |
struct | StaticPower< m, 0 > |
end of recursion via specialization More... | |
struct | Power |
Compute power for a run-time mantissa and a compile-time integer exponent. More... | |
class | FMatrixPrecision |
Precisions for calculations with FieldMatrix and FieldVector. More... | |
struct | PropertyMapTraits |
struct | ReadablePropertyMapTag |
Tag for the category of readable property maps. More... | |
struct | WritablePropertyMapTag |
Tag for the category of writable property maps. More... | |
struct | ReadWritePropertyMapTag |
Tag for the category of readable and writable property maps. More... | |
struct | LvaluePropertyMapTag |
Tag for the category of lvalue property maps. More... | |
struct | PropertyMapTraits< T * > |
struct | PropertyMapTraits< const T * > |
struct | RAPropertyMapHelper |
class | IteratorPropertyMap |
Adapter to turn a random access iterator into a property map. More... | |
class | AssociativePropertyMap |
An adapter to turn an unique associative container into a property map. More... | |
class | ConstAssociativePropertyMap |
An adaptor to turn an unique associative container into a property map. More... | |
struct | IdentityMap |
A property map that applies the identity function to integers. More... | |
struct | PropertyMapTypeSelector |
Selector for the property map type. More... | |
class | ReservedVector |
A Vector class with statically reserved memory. More... | |
struct | null_deleter |
implements the Deleter concept of shared_ptr without deleting anything More... | |
class | Singleton |
An adapter to turn a class into a singleton. More... | |
class | SLListIterator |
A mutable iterator for the SLList. More... | |
class | SLListConstIterator |
A constant iterator for the SLList. More... | |
class | SLListModifyIterator |
A mutable iterator for the SLList. More... | |
class | SLList |
A single linked list. More... | |
class | TimerError |
Exception thrown by the Timer class More... | |
class | Timer |
A simple stop watch. More... | |
struct | TupleAccessTraits |
struct | TupleAccessTraits< T * > |
struct | TupleAccessTraits< T & > |
struct | tuple_writer |
struct | tuple_writer< 1 > |
struct | tuple_writer< 0 > |
class | NullPointerInitialiser |
A helper template that initializes a tuple consisting of pointers to NULL. 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 | TransformTupleFunctor |
helper class to implement transformTuple() More... | |
struct | AddRefTypeEvaluator |
TypeEvaluator to turn a type T into a reference to T More... | |
struct | AddPtrTypeEvaluator |
TypeEvaluator to turn a type T into a pointer to T More... | |
struct | AddPtrTypeEvaluator< T & > |
class | ForEachValue |
Helper template which implements iteration over all storage elements in a tuple. More... | |
class | ForEachValuePair |
Extension of ForEachValue to two tuples... More... | |
struct | AtType |
Type for reverse element access. More... | |
struct | At |
Reverse element access. More... | |
class | PointerPairDeletor |
Deletes all objects pointed to in a tuple of pointers. More... | |
class | FirstPredicateIndex |
Finding the index of a certain type in a tuple. More... | |
struct | IsType |
Generator for predicates accepting one particular type. More... | |
struct | FirstTypeIndex |
Find the first occurance of a type in a tuple. 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... | |
struct | ReduceTuple |
Apply reduce with meta binary function to template. More... | |
struct | ReduceTuple< F, Tuple, Seed, 0 > |
Apply reduce with meta binary function to template. More... | |
struct | JoinTuples |
Join two tuples. More... | |
struct | FlattenTuple |
Flatten a tuple of tuples. More... | |
struct | Empty |
Just an empty class. More... | |
class | TypeTraits |
General type traits class to check whether type is reference or pointer type. More... | |
struct | ConstantVolatileTraits |
Determines wether a type is const or volatile and provides the unqualified types. More... | |
struct | ConstantVolatileTraits< const T > |
struct | ConstantVolatileTraits< volatile T > |
struct | ConstantVolatileTraits< const volatile T > |
struct | IsVolatile |
Tests wether a type is volatile. More... | |
struct | IsConst |
Tests wether a type is constant. More... | |
struct | RemoveConstHelper |
struct | RemoveConstHelper< T, true > |
class | Conversion |
Checks wether a type is convertible to another. More... | |
class | Conversion< From, void > |
class | Conversion< void, To > |
class | Conversion< int, double > |
class | Conversion< T, T > |
class | IsBaseOf |
Checks wether a type is derived from another. More... | |
struct | IsInteroperable |
Checks wether two types are interoperable. More... | |
struct | EnableIfInterOperable |
Enable typedef if two types are interoperable. More... | |
struct | __is_pointer_helper |
struct | __is_pointer_helper< T * > |
struct | is_pointer |
is_pointer More... | |
struct | __is_lvalue_reference_helper |
struct | __is_lvalue_reference_helper< T & > |
struct | is_lvalue_reference |
Determine whether a type is a lvalue reference type. More... | |
struct | __remove_pointer_helper |
struct | __remove_pointer_helper< _Tp * > |
struct | remove_pointer |
Return the type a pointer type points to. More... | |
struct | AlwaysFalse |
template which always yields a false value More... | |
struct | AlwaysTrue |
template which always yields a true value More... | |
struct | is_indexable |
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().