dune-common  2.3.1
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables

Dune namespace. More...

Namespaces

namespace  DenseMatrixHelp
namespace  DynamicMatrixHelp
namespace  FloatCmp
namespace  FMatrixHelp
namespace  fvmeta

Classes

struct  AlignmentOf
 Calculates the alignment requirement of a type. More...
class  array
 Simple fixed size array class. This replaces std::array, if that is not available. More...
class  ArrayList
 A dynamically growing random access list. 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  bigunsignedint
 Portable very large unsigned integers. More...
struct  Min
struct  Max
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...
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  BitSetVector
 A dynamic array of blocks of booleans. More...
class  DebugAllocator< void >
class  DebugAllocator
 Allocators implementation which performs different kind of memory checks. More...
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...
struct  FieldTraits< DenseMatrix< M > >
class  FMatrixError
 Error thrown if operations of a FieldMatrix fail. More...
class  DenseMatrix
 A dense n x m matrix. More...
struct  FieldTraits< DenseVector< V > >
class  DenseIterator
 Generic iterator class for dense vector and matrix implementations. More...
class  DenseVector
 Interface for a class of dense vectors over a given field. More...
class  DiagonalMatrix
 A diagonal matrix of static size. More...
class  DiagonalMatrixWrapper
class  DiagonalRowVectorConst
class  DiagonalRowVector
struct  const_reference< DiagonalRowVector< K, n > >
struct  const_reference< DiagonalRowVectorConst< K, n > >
struct  mutable_reference< DiagonalRowVector< K, n > >
struct  mutable_reference< DiagonalRowVectorConst< K, n > >
class  ContainerWrapperIterator
 Iterator class for sparse vector-like containers. More...
struct  ImplementationDefined
 Dummy struct used for documentation purposes. More...
struct  AlwaysVoid
struct  IsVector
struct  IsVector< T, typename AlwaysVoid< typename T::field_type >::type >
struct  DenseMatVecTraits< DynamicMatrix< K > >
struct  FieldTraits< DynamicMatrix< K > >
class  DynamicMatrix
 Construct a matrix with a dynamic size. More...
struct  DenseMatVecTraits< DynamicVector< K > >
struct  FieldTraits< DynamicVector< K > >
class  DynamicVector
 Construct a vector with a dynamic size. More...
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  FieldMatrix
 A dense n x m matrix. More...
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 >
class  FieldVector
 vector space out of a tensor product of fields. More...
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...
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  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  Power_m_p
 Calculates m^p at compile time. More...
struct  Power_m_p< m, 0 >
 end of recursion via specialization More...
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  ParallelIndexSet
 Manager class for the mapping between local indices and globally unique indices. More...
class  GlobalLookupIndexSet
 Decorates an index set with the possibility to find a global index that is mapped to a specific local. 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...
struct  MPITraits
 A traits class describing the mapping of types onto MPI_Datatypes. 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  RemoteIndex
 Information about an index residing on another processor. More...
class  RemoteIndices
 The indices present on remote processes. 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  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  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  PromotionTraits
 Class for type promotions. For example, the promotion traits are used for the implementation of dot products.
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...
class  SharedCount
 The object we reference. More...
class  shared_ptr
 A reference counting smart pointer. 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  SLList
 A single linked list. 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...
struct  AlwaysFalse
 template which always yields a false value More...
struct  AlwaysTrue
 template which always yields a true value 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  Nil
 An empty class. More...
struct  Pair
 A tuple consisting of two objects. More...
struct  Pair< T1, Nil >
 A tuple consisting of one object. Specialization of Pair that really is a single value. More...
struct  TupleToPairs
 Converts the Tuple to a list of pairs. More...
struct  TupleToPairs< T1, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil >
 Specialization for a tuple consisting only of one type. More...
class  tuple
 A Tuple of objects. More...
struct  tuple_element
 Get the type of the N-th element of the tuple. More...
struct  tuple_element< N, Pair< T1, T2 > >
struct  tuple_element< 0, Pair< T1, T2 > >
 Get the type of the first element of the tuple. More...
struct  Element
 Get the N-th element of a tuple. More...
struct  Element< 0 >
 Get the first element of a tuple. More...
struct  tuple_size
 Template meta_programm to query the size of a tuple. More...
struct  tuple_size< Pair< T1, T2 > >
struct  tuple_size< Pair< T1, Nil > >
struct  tuple_size< Pair< Nil, Nil > >
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 >
struct  remove_const
 Removes a const qualifier while preserving others. More...
struct  remove_reference
 Remove a reference from a type. More...
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  enable_if
 Enable typedef if condition is met. More...
struct  enable_if< false, T >
struct  EnableIfInterOperable
 Enable typedef if two types are interoperable. More...
struct  is_same
 Compile time test for testing whether two types are the same. More...
struct  is_same< T, T >
struct  SelectType
 Select a type based on a condition. More...
struct  SelectType< false, T1, T2 >
struct  conditional
 Select a type based on a condition. More...
struct  conditional< false, T1, T2 >
struct  integral_constant
 Generate a type for a given integral constant. 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...

Typedefs

typedef unsigned int DebugLevel
 Type for debug levels.
typedef dune_nullptr_t nullptr_t
typedef DebugStream
< VERY_VERBOSE_DEBUG_LEVEL,
MINIMAL_DEBUG_LEVEL
DVVerbType
 Type of very verbose debug stream.
typedef DebugStream
< VERBOSE_DEBUG_LEVEL,
MINIMAL_DEBUG_LEVEL
DVerbType
 Type of more verbose debug stream.
typedef DebugStream
< INFO_DEBUG_LEVEL,
MINIMAL_DEBUG_LEVEL
DInfoType
 Type of debug stream with info level.
typedef DebugStream
< WARN_DEBUG_LEVEL,
MINIMAL_DEBUG_LEVEL
DWarnType
 Type of debug stream with warn level.
typedef DebugStream
< GRAVE_DEBUG_LEVEL,
MINIMAL_DEBUG_LEVEL
DGraveType
 Type of debug stream for fatal errors.
typedef DebugStream< 1 > DErrType
 The type of the stream used for error messages.
typedef integral_constant
< bool, true > 
true_type
 type for true
typedef integral_constant
< bool, false > 
false_type
 type for false

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>
bool operator< (const array< T, N > &a, const array< T, N > &b)
template<class T , size_t N>
bool operator> (const array< T, N > &a, const array< T, N > &b)
template<class T , size_t N>
bool operator<= (const array< T, N > &a, const array< T, N > &b)
template<class T , size_t N>
bool operator>= (const array< T, N > &a, const array< T, N > &b)
template<class T , size_t N>
std::ostream & operator<< (std::ostream &s, const array< T, N > &e)
 Output operator for array.
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
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.
template<int k>
std::ostream & operator<< (std::ostream &s, const bigunsignedint< k > &x)
template<int k>
bigunsignedint< k > operator+ (const bigunsignedint< k > &x, std::size_t y)
template<int k>
bigunsignedint< k > operator- (const bigunsignedint< k > &x, std::size_t y)
template<int k>
bigunsignedint< k > operator* (const bigunsignedint< k > &x, std::size_t y)
template<int k>
bigunsignedint< k > operator/ (const bigunsignedint< k > &x, std::size_t y)
template<int k>
bigunsignedint< k > operator% (const bigunsignedint< k > &x, std::size_t y)
template<int k>
bigunsignedint< k > operator+ (std::size_t x, const bigunsignedint< k > &y)
template<int k>
bigunsignedint< k > operator- (std::size_t x, const bigunsignedint< k > &y)
template<int k>
bigunsignedint< k > operator* (std::size_t x, const bigunsignedint< k > &y)
template<int k>
bigunsignedint< k > operator/ (std::size_t x, const bigunsignedint< k > &y)
template<int k>
bigunsignedint< k > operator% (std::size_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.
template<class T >
std::string className ()
 Provide the demangled class name of a type T as a string.
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.
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
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.
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
template<class T , int s>
fvector_assigner< T, s > operator<<= (FieldVector< T, s > &v, Zero z)
 fvector assignment operator
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.
template<class T , int n, int m>
fmatrix_assigner< T, n, m > operator<<= (FieldMatrix< T, n, m > &v, Zero z)
 FieldMatrix assignment operator.
template<typename T >
void hash_combine (std::size_t &seed, const T &arg)
 Calculates the hash value of arg and combines it in-place with seed.
template<typename It >
std::size_t hash_range (It first, It last)
 Hashes all elements in the range [first,last) and returns the combined hash.
template<typename It >
void hash_range (std::size_t &seed, It first, It last)
 Hashes all elements in the range [first,last) and combines the hashes in-place with seed.
std::ostream & operator<< (std::ostream &s, const Indent &indent)
 write indentation to a stream
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2,
bool >::type 
operator== (const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
 Checks for equality.
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2,
bool >::type 
operator!= (const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
 Checks for inequality.
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
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.
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2,
bool >::type 
operator!= (const BidirectionalIteratorFacade< T1, V1, R1, D > &lhs, const BidirectionalIteratorFacade< T2, V2, R2, D > &rhs)
 Checks for inequality.
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2,
bool >::type 
operator== (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
 Checks for equality.
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2,
bool >::type 
operator!= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
 Checks for inequality.
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2,
bool >::type 
operator< (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
 Comparison operator.
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2,
bool >::type 
operator<= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
 Comparison operator.
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2,
bool >::type 
operator> (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
 Comparison operator.
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2,
bool >::type 
operator>= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
 Comparison operator.
template<class T1 , class V1 , class R1 , class D , class T2 , class V2 , class R2 >
EnableIfInterOperable< T1, T2,
D >::type 
operator- (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
 Calculates the difference between two pointers.
template<class K >
conjugateComplex (const K &x)
 compute conjugate complex of x
template<class T >
int sign (const T &val)
 Return the sign of the value.
template<class T >
SQR (T t)
 Compute the square of T.
std::string genFilename (const std::string &path, const std::string &fn, int ntime, int precision=6)
 Generate filenames with timestep number in it.
template<class TG , class TL >
std::ostream & operator<< (std::ostream &os, const IndexPair< TG, TL > &pair)
 Print an index pair.
template<class TG , class TL >
bool operator== (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
template<class TG , class TL >
bool operator!= (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
template<class TG , class TL >
bool operator< (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
template<class TG , class TL >
bool operator> (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
template<class TG , class TL >
bool operator<= (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
template<class TG , class TL >
bool operator>= (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
template<class TG , class TL >
bool operator== (const IndexPair< TG, TL > &, const TG &)
template<class TG , class TL >
bool operator!= (const IndexPair< TG, TL > &, const TG &)
template<class TG , class TL >
bool operator< (const IndexPair< TG, TL > &, const TG &)
template<class TG , class TL >
bool operator> (const IndexPair< TG, TL > &, const TG &)
template<class TG , class TL >
bool operator<= (const IndexPair< TG, TL > &, const TG &)
template<class TG , class TL >
bool operator>= (const IndexPair< TG, TL > &, const TG &)
template<class TG , class TL , int N>
std::ostream & operator<< (std::ostream &os, const ParallelIndexSet< TG, TL, N > &indexSet)
 Print an index set.
template<typename TG , typename TA >
bool operator< (const IndexPair< TG, ParallelLocalIndex< TA > > &i1, const std::pair< TG, TA > &i2)
template<typename TG , typename TA >
bool operator< (const std::pair< TG, TA > &i1, const IndexPair< TG, ParallelLocalIndex< TA > > &i2)
template<typename TG , typename TA >
bool operator== (const IndexPair< TG, ParallelLocalIndex< TA > > &i1, const std::pair< TG, TA > &i2)
template<typename TG , typename TA >
bool operator!= (const IndexPair< TG, ParallelLocalIndex< TA > > &i1, const std::pair< TG, TA > &i2)
template<typename TG , typename TA >
bool operator== (const std::pair< TG, TA > &i2, const IndexPair< TG, ParallelLocalIndex< TA > > &i1)
template<typename TG , typename TA >
bool operator!= (const std::pair< TG, TA > &i2, const IndexPair< TG, ParallelLocalIndex< TA > > &i1)
template<typename T , typename A , typename A1 >
void storeGlobalIndicesOfRemoteIndices (std::map< int, SLList< std::pair< typename T::GlobalIndex, typename T::LocalIndex::Attribute >, A > > &globalMap, const RemoteIndices< T, A1 > &remoteIndices, const T &indexSet)
 Stores the corresponding global indices of the remote index information.
template<typename T , typename A , typename A1 >
void repairLocalIndexPointers (std::map< int, SLList< std::pair< typename T::GlobalIndex, typename T::LocalIndex::Attribute >, A > > &globalMap, RemoteIndices< T, A1 > &remoteIndices, const T &indexSet)
 Repair the pointers to the local indices in the remote indices.
 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.
template<typename T >
bool operator== (const ParallelLocalIndex< T > &p1, const ParallelLocalIndex< T > &p2)
template<typename T >
bool operator!= (const ParallelLocalIndex< T > &p1, const ParallelLocalIndex< T > &p2)
template<typename T1 , typename T2 >
std::ostream & operator<< (std::ostream &os, const RemoteIndex< T1, T2 > &index)
template<class T , class A >
std::ostream & operator<< (std::ostream &os, const RemoteIndices< T, A > &indices)
template<typename TG , typename TA >
std::ostream & operator<< (std::ostream &os, const RemoteIndex< TG, TA > &index)
std::string concatPaths (const std::string &base, const std::string &p)
 concatenate two paths
std::string processPath (const std::string &p)
 sanitize a path for further processing
bool pathIndicatesDirectory (const std::string &p)
 check whether the given path indicates that it is a directory
std::string prettyPath (const std::string &p, bool isDirectory)
 pretty print path
std::string prettyPath (const std::string &p)
 pretty print path
std::string relativePath (const std::string &newbase, const std::string &p)
 compute a relative path between two paths
template<typename T1 , std::size_t t1, typename T2 , std::size_t t2>
bool operator== (const PoolAllocator< T1, t1 > &, const PoolAllocator< T2, t2 > &)
template<typename T1 , std::size_t t1, typename T2 , std::size_t t2>
bool operator!= (const PoolAllocator< T1, t1 > &, const PoolAllocator< T2, t2 > &)
template<typename T , std::size_t t1, std::size_t t2>
bool operator== (const PoolAllocator< T, t1 > &p1, const PoolAllocator< T, t2 > &p2)
template<typename T , std::size_t t1, std::size_t t2>
bool operator!= (const PoolAllocator< T, t1 > &p1, const PoolAllocator< T, t2 > &p2)
template<typename T , std::size_t t1, std::size_t t2>
bool operator== (const PoolAllocator< void, t1 > &, const PoolAllocator< T, t2 > &)
template<typename T , std::size_t t1, std::size_t t2>
bool operator!= (const PoolAllocator< void, t1 > &, const PoolAllocator< T, t2 > &)
template<std::size_t t1, std::size_t t2>
bool operator== (const PoolAllocator< void, t1 > &p1, const PoolAllocator< void, t2 > &p2)
template<std::size_t t1, std::size_t t2>
bool operator!= (const PoolAllocator< void, t1 > &p1, const PoolAllocator< void, t2 > &p2)
template<class Reference , class PropertyMap , class Key >
Reference get (const RAPropertyMapHelper< Reference, PropertyMap > &pmap, const Key &key)
template<class Reference , class PropertyMap , class Key , class Value >
void put (const RAPropertyMapHelper< Reference, PropertyMap > &pmap, const Key &key, const Value &value)
template<typename T >
shared_ptr< T > make_shared ()
template<typename T , typename Arg1 >
shared_ptr< T > make_shared (const Arg1 &arg1)
template<typename T , typename Arg1 , typename Arg2 >
shared_ptr< T > make_shared (const Arg1 &arg1, const Arg2 &arg2)
template<typename T , typename Arg1 , typename Arg2 , typename Arg3 >
shared_ptr< T > make_shared (const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
template<typename T , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 >
shared_ptr< T > make_shared (const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
template<typename T , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >
shared_ptr< T > make_shared (const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
template<typename T , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 >
shared_ptr< T > make_shared (const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5, const Arg6 &arg6)
template<typename T , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 >
shared_ptr< T > make_shared (const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5, const Arg6 &arg6, const Arg7 &arg7)
template<typename T , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 >
shared_ptr< T > make_shared (const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5, const Arg6 &arg6, const Arg7 &arg7, const Arg8 &arg8)
template<typename T , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 >
shared_ptr< T > make_shared (const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5, const Arg6 &arg6, const Arg7 &arg7, const Arg8 &arg8, const Arg9 &arg9)
template<typename C >
bool hasPrefix (const C &c, const char *prefix)
 Check whether a character container has a given prefix.
template<typename C >
bool hasSuffix (const C &c, const char *suffix)
 Check whether a character container has a given suffix.
template<int i, typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
TupleAccessTraits< typename
tuple_element< i, tuple< T1,
T2, T3, T4, T5, T6, T7, T8, T9 >
>::type >::NonConstType 
get (tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 > &t)
template<int i, typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
TupleAccessTraits< typename
tuple_element< i, tuple< T1,
T2, T3, T4, T5, T6, T7, T8, T9 >
>::type >::ConstType 
get (const tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 > &t)
template<typename T1 , typename T2 , typename U1 , typename U2 >
bool operator== (const Pair< T1, T2 > &tuple1, const Pair< U1, U2 > &tuple2)
 Equality comparison operator for tuples.
template<typename T1 , typename T2 , typename U1 , typename U2 >
bool operator!= (const Pair< T1, T2 > &tuple1, const Pair< U1, U2 > &tuple2)
 Inequality comparison operator for tuples.
template<typename T1 , typename T2 , typename U1 , typename U2 >
bool operator< (const Pair< T1, T2 > &tuple1, const Pair< U1, U2 > &tuple2)
 Less operator for tuples.
template<typename T1 , typename U1 >
bool operator== (const Pair< T1, Nil > &tuple1, const Pair< U1, Nil > &tuple2)
 Equality comparison operator for tuples.
template<typename T1 , typename U1 >
bool operator!= (const Pair< T1, Nil > &tuple1, const Pair< U1, Nil > &tuple2)
 Inequality comparison operator for tuples.
template<typename T1 , typename U1 >
bool operator< (const Pair< T1, Nil > &tuple1, const Pair< U1, Nil > &tuple2)
 Less operator for tuples.
template<typename T1 , typename U1 , typename U2 >
bool operator== (const Pair< T1, Nil > &tuple1, const Pair< U1, U2 > &tuple2)
 Equality comparison operator for tuples.
template<typename T1 , typename U1 , typename U2 >
bool operator!= (const Pair< T1, Nil > &tuple1, const Pair< U1, U2 > &tuple2)
 Inequality comparison operator for tuples.
template<typename T1 , typename T2 , typename U1 >
bool operator== (const Pair< T1, T2 > &tuple1, const Pair< U1, Nil > &tuple2)
 Equality comparison operator for tuples.
template<typename T1 , typename T2 , typename U1 >
bool operator!= (const Pair< T1, T2 > &tuple1, const Pair< U1, Nil > &tuple2)
 Inequality comparison operator for tuples.
template<typename T1 , typename T2 >
Pair< T1, T2 > makePair (const T1 &first, const T2 &second)
 Create a tuple and initialize it.
template<typename T1 , typename T2 >
std::ostream & operator<< (std::ostream &os, const Pair< T1, T2 > &pair)
 Print a pair or tuple.
template<typename T1 >
std::ostream & operator<< (std::ostream &os, const Pair< T1, Nil > &pair)
template<typename T1 , typename T2 >
std::istream & operator>> (std::istream &is, Pair< T1, T2 > &pair)
 Read a pair or tuple.
template<typename T1 >
std::istream & operator>> (std::istream &is, Pair< T1, Nil > &pair)
template<class T1 >
tuple< T1 & > tie (T1 &t1)
template<class T1 , class T2 >
tuple< T1 &, T2 & > tie (T1 &t1, T2 &t2)
template<class T1 , class T2 , class T3 >
tuple< T1 &, T2 &, T3 & > tie (T1 &t1, T2 &t2, T3 &t3)
template<class T1 , class T2 , class T3 , class T4 >
tuple< T1 &, T2 &, T3 &, T4 & > tie (T1 &t1, T2 &t2, T3 &t3, T4 &t4)
template<class T1 , class T2 , class T3 , class T4 , class T5 >
tuple< T1 &, T2 &, T3 &, T4
&, T5 & > 
tie (T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
tuple< T1 &, T2 &, T3 &, T4
&, T5 &, T6 & > 
tie (T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
tuple< T1 &, T2 &, T3 &, T4
&, T5 &, T6 &, T7 & > 
tie (T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6, T7 &t7)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
tuple< T1 &, T2 &, T3 &, T4
&, T5 &, T6 &, T7 &, T8 & > 
tie (T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
tuple< T1 &, T2 &, T3 &, T4
&, T5 &, T6 &, T7 &, T8 &, T9 & > 
tie (T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9)
template<class T1 >
tuple< T1 > make_tuple (const T1 &t1)
template<class T1 , class T2 >
tuple< T1, T2 > make_tuple (const T1 &t1, const T2 &t2)
template<class T1 , class T2 , class T3 >
tuple< T1, T2, T3 > make_tuple (const T1 &t1, const T2 &t2, const T3 &t3)
template<class T1 , class T2 , class T3 , class T4 >
tuple< T1, T2, T3, T4 > make_tuple (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4)
template<class T1 , class T2 , class T3 , class T4 , class T5 >
tuple< T1, T2, T3, T4, T5 > make_tuple (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
tuple< T1, T2, T3, T4, T5, T6 > make_tuple (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
tuple< T1, T2, T3, T4, T5, T6, T7 > make_tuple (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
tuple< T1, T2, T3, T4, T5, T6,
T7, T8 > 
make_tuple (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8)
template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
tuple< T1, T2, T3, T4, T5, T6,
T7, T8, T9 > 
make_tuple (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8, const T9 &t9)
template<class Tuple , class Functor >
ForEachType< Functor::template
TypeEvaluator, Tuple >::Type 
genericTransformTuple (Tuple &t, Functor &f)
 transform a tuple object into another tuple object
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
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

Variables

DVVerbType dvverb (std::cout)
 stream for very verbose output.
DVerbType dverb (std::cout)
 Singleton of verbose debug stream.
DInfoType dinfo (std::cout)
 Stream for informative output.
DWarnType dwarn (std::cerr)
 Stream for warnings indicating problems.
DGraveType dgrave (std::cerr)
 Stream for warnings indicating fatal errors.
DErrType derr (std::cerr)
 Stream for error messages.
static const DebugLevel MINIMAL_DEBUG_LEVEL = DUNE_MINIMAL_DEBUG_LEVEL
static const DebugLevel VERY_VERBOSE_DEBUG_LEVEL = 1
 The level of the very verbose debug stream.
static const DebugLevel VERBOSE_DEBUG_LEVEL = 2
 The level of the verbose debug stream.
static const DebugLevel INFO_DEBUG_LEVEL = 3
 The level of the informative debug stream.
static const DebugLevel WARN_DEBUG_LEVEL = 4
 The level of the debug stream for warnings.
static const DebugLevel GRAVE_DEBUG_LEVEL = 5
 The level of the debug stream for fatal errors.

Detailed Description

Dune namespace.

Typedef Documentation

Enumeration Type Documentation

anonymous enum
Enumerator:
implementationDefined 

Dummy integral value used for documentation purposes.

See Also
ImplementationDefined

Function Documentation

template<class T >
std::string Dune::className ( T &  t)

Provide the demangled class name of a given object as a string.

References t.

Referenced by className().

template<class T >
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   
)
template<class K >
K Dune::conjugateComplex ( const K &  x)
inline
template<class A , class B >
enable_if< IsVector< A >::value, typename PromotionTraits< typename A::field_type, typename B::field_type >::PromotedType >::type Dune::dotT ( const A &  a,
const B &  b 
)
inline

Computes an indefinite vector dot product for fundamental data types according to Petsc's VectTDot function: dotT(a,b) := a*b.

Computes an indefinite vector dot product for various dune vector types according to Petsc's VectTDot function: dotT(a,b) := a*b.

See Also
http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Vec/VecTDot.html#VecTDot
Parameters
a
b
Returns
a*b
template<class Tuple , class Functor >
ForEachType<Functor::template TypeEvaluator, Tuple>::Type Dune::genericTransformTuple ( Tuple &  t,
Functor &  f 
)

transform a tuple object into another tuple object

#include <dune/common/utility.hh>

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.

Parameters
tThe tuple value to transform.
fThe functor to use to transform the values.

The functor should have the following form:

struct Functor {
template<class> struct TypeEvaluator {
typedef user-defined Type;
};
template<class T>
typename TypeEvaluator<T>::Type operator()(T& val);
template<class T>
typename TypeEvaluator<T>::Type operator()(T& val) const;
template<class T>
typename TypeEvaluator<T>::Type operator()(const T& val);
template<class T>
typename TypeEvaluator<T>::Type operator()(const T& val) const;
};

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

template<class Reference , class PropertyMap , class Key >
Reference Dune::get ( const RAPropertyMapHelper< Reference, PropertyMap > &  pmap,
const Key &  key 
)
inline
template<typename T >
void Dune::hash_combine ( std::size_t &  seed,
const T &  arg 
)
inline

Calculates the hash value of arg and combines it in-place with seed.

Note
This function is only available if the macro HAVE_DUNE_HASH is defined.
Parameters
seedThe hash value that will be combined with the hash of arg.
argThe object for which to calculate a hash value and combine it with seed.

Referenced by hash_range().

template<typename It >
std::size_t Dune::hash_range ( It  first,
It  last 
)
inline

Hashes all elements in the range [first,last) and returns the combined hash.

Note
This function is only available if the macro HAVE_DUNE_HASH is defined.
Parameters
firstIterator pointing to the first object to hash.
lastIterator pointing one past the last object to hash.
Returns
The result of hashing all objects in the range and combining them using hash_combine() in sequential fashion, starting with seed 0.

References hash_combine().

template<typename It >
void Dune::hash_range ( std::size_t &  seed,
It  first,
It  last 
)
inline

Hashes all elements in the range [first,last) and combines the hashes in-place with seed.

Note
This function is only available if the macro HAVE_DUNE_HASH is defined.
Parameters
seedStart value that will be combined with the hash values of all objects in the range using hash_combine() in sequential fashion.
firstIterator pointing to the first ojbect to hash.
lastIterator pointing one past the last object to hash.

References hash_combine().

template<typename T >
shared_ptr<T> Dune::make_shared ( )
template<typename T , typename Arg1 >
shared_ptr<T> Dune::make_shared ( const Arg1 &  arg1)
template<typename T , typename Arg1 , typename Arg2 >
shared_ptr<T> Dune::make_shared ( const Arg1 &  arg1,
const Arg2 &  arg2 
)
template<typename T , typename Arg1 , typename Arg2 , typename Arg3 >
shared_ptr<T> Dune::make_shared ( const Arg1 &  arg1,
const Arg2 &  arg2,
const Arg3 &  arg3 
)
template<typename T , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 >
shared_ptr<T> Dune::make_shared ( const Arg1 &  arg1,
const Arg2 &  arg2,
const Arg3 &  arg3,
const Arg4 &  arg4 
)
template<typename T , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >
shared_ptr<T> Dune::make_shared ( const Arg1 &  arg1,
const Arg2 &  arg2,
const Arg3 &  arg3,
const Arg4 &  arg4,
const Arg5 &  arg5 
)
template<typename T , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 >
shared_ptr<T> Dune::make_shared ( const Arg1 &  arg1,
const Arg2 &  arg2,
const Arg3 &  arg3,
const Arg4 &  arg4,
const Arg5 &  arg5,
const Arg6 &  arg6 
)
template<typename T , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 >
shared_ptr<T> Dune::make_shared ( const Arg1 &  arg1,
const Arg2 &  arg2,
const Arg3 &  arg3,
const Arg4 &  arg4,
const Arg5 &  arg5,
const Arg6 &  arg6,
const Arg7 &  arg7 
)
template<typename T , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 >
shared_ptr<T> Dune::make_shared ( const Arg1 &  arg1,
const Arg2 &  arg2,
const Arg3 &  arg3,
const Arg4 &  arg4,
const Arg5 &  arg5,
const Arg6 &  arg6,
const Arg7 &  arg7,
const Arg8 &  arg8 
)
template<typename T , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 >
shared_ptr<T> Dune::make_shared ( const Arg1 &  arg1,
const Arg2 &  arg2,
const Arg3 &  arg3,
const Arg4 &  arg4,
const Arg5 &  arg5,
const Arg6 &  arg6,
const Arg7 &  arg7,
const Arg8 &  arg8,
const Arg9 &  arg9 
)
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> 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

#include <dune/common/utility.hh>
Template Parameters
TETypeEvaluator class template.
A0Type 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.
A1Type 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.
A2Type 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.
A3Type 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.
A4Type 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.
A5Type 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.
A6Type 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.
A7Type 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.
A8Type 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.
A9Type 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.
Parameters
a0Arguments to save references to in the TransformTupleFunctor.
a1Arguments to save references to in the TransformTupleFunctor.
a2Arguments to save references to in the TransformTupleFunctor.
a3Arguments to save references to in the TransformTupleFunctor.
a4Arguments to save references to in the TransformTupleFunctor.
a5Arguments to save references to in the TransformTupleFunctor.
a6Arguments to save references to in the TransformTupleFunctor.
a7Arguments to save references to in the TransformTupleFunctor.
a8Arguments to save references to in the TransformTupleFunctor.
a9Arguments 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.

template<typename TG , typename TA >
std::ostream& Dune::operator<< ( std::ostream &  os,
const RemoteIndex< TG, TA > &  index 
)
inline
template<class Reference , class PropertyMap , class Key , class Value >
void Dune::put ( const RAPropertyMapHelper< Reference, PropertyMap > &  pmap,
const Key &  key,
const Value &  value 
)
inline

References dune_static_assert.

template<class T >
int Dune::sign ( const T &  val)

Return the sign of the value.

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

#include <dune/common/utility.hh>

This function provides functionality similiar to genericTransformTuple(), although less general and closer in spirit to ForEachType.

Template Parameters
TypeEvaluatorUsed as the TE template argument to TransformTupleFunctor internally.
TupleType of the tuple to transform.
A0Types of extra argument to call the transformation function with.
A1Types of extra argument to call the transformation function with.
A2Types of extra argument to call the transformation function with.
A3Types of extra argument to call the transformation function with.
A4Types of extra argument to call the transformation function with.
A5Types of extra argument to call the transformation function with.
A6Types of extra argument to call the transformation function with.
A7Types of extra argument to call the transformation function with.
A8Types of extra argument to call the transformation function with.
A9Types of extra argument to call the transformation function with.
Note
The Tuple and An template arguments can be deduced from the function arguments, so they can usually be omitted.
Parameters
origTuple value to be transformed.
a0Extra argument values to provide to the transformation function.
a1Extra argument values to provide to the transformation function.
a2Extra argument values to provide to the transformation function.
a3Extra argument values to provide to the transformation function.
a4Extra argument values to provide to the transformation function.
a5Extra argument values to provide to the transformation function.
a6Extra argument values to provide to the transformation function.
a7Extra argument values to provide to the transformation function.
a8Extra argument values to provide to the transformation function.
a9Extra 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):

template <class T>
struct TypeEvaluator {
typedef UserDefined Type;
template<class A0, class A1, class A2, class A3, class A4, class A5,
class A6, class A7, class A8, class A9>
static Type apply(T& t, A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5,
A6& a6, A7& a7, A8& a8, A9& a9);
};

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.

Note
Since transformTuple() takes non-const references to the extra arguments, it will only bind to lvalue extra arguments, unless you specify the corresponding template parameter as 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 $2^{n+1}-1$ overloads where $n$ is the implementation defined limit in the number of extra arguments.
See Also
genericTransforTuple(), ForEachType, AddRefTypeEvaluator, and AddPtrTypeEvaluator.

References genericTransformTuple().