dune-functions  2.5.1
Namespaces | Classes | Typedefs | Functions
Dune::Functions::Imp Namespace Reference

Namespaces

 Concept
 

Classes

struct  AllTrueBitSetVector
 
struct  CoefficientType
 
struct  DifferentiableFunctionTraits
 Traits class providing type information for DifferentiableFunction. More...
 
class  DifferentiableFunctionWrapperImplementation
 
class  DifferentiableFunctionWrapperImplementation< Range(Domain), DerivativeInterface, B >
 
class  DifferentiableFunctionWrapperInterface
 
class  DifferentiableFunctionWrapperInterface< Range(Domain), DerivativeInterface >
 
struct  ExpandTupleHelper
 
struct  ExpandTupleHelper< T, ListType< Args... > >
 
struct  GridFunctionTraits
 Traits class providing type information for DifferentiableFunction. More...
 
class  GridFunctionWrapperImplementation
 
class  GridFunctionWrapperInterface
 
struct  HasFreeDerivative
 
struct  HasFreeLocalFunction
 
struct  IntegerSequenceTupleHelper
 
struct  IntegerSequenceTupleHelper< std::integer_sequence< I, k... > >
 
class  LocalAnalyticGridViewFunction
 
class  LocalAnalyticGridViewFunction< Range(LocalDomain), GV, F, DerivativeTraits >
 
struct  LocalFunctionTraits
 Traits class providing type information for DifferentiableFunction. More...
 
class  LocalFunctionWrapperImplementation
 
class  LocalFunctionWrapperInterface
 
class  LocalInterpolateVisitor
 
struct  MultiIndexResolver
 
struct  RotateHelper
 
struct  RotateHelper< std::tuple< T... >, std::index_sequence< I... > >
 
struct  SizeOf
 
struct  StaticFindInRange
 
struct  StaticFindInRange< ST, end, end >
 
struct  TransformTupleHelper
 
struct  TransformTupleHelper< T, typename std::tuple< Args1... > >
 
struct  TransformTupleHelper< T, typename std::tuple< Args1... >, typename std::tuple< Args2... > >
 
class  TypeErasureWrapperBase
 Base implementation of the internal wrapper interface. More...
 
class  TypeErasureWrapperImplementation
 Implementation of the internal wrapper interface. More...
 
class  TypeErasureWrapperInterface
 The internal wrapper interface for type erasure. More...
 

Typedefs

template<typename... T>
using index_sequence_for = std::make_index_sequence< SizeOf< T... >{}>
 

Functions

template<class Dummy , class F , typename std::enable_if< models< HasFreeDerivative, F >(), int >::type = 0>
auto derivativeIfImplemented (const F &f) -> decltype(derivative(f))
 
template<class Dummy , class F , typename std::enable_if< not(models< HasFreeDerivative, F >()), int >::type = 0>
Dummy derivativeIfImplemented (const F &f)
 
template<class T >
constexpr auto staticSize (const T *, const PriorityTag< 0 > &) -> decltype(std::integral_constant< std::size_t, T::size()>())
 
template<class T >
constexpr auto staticSize (const T *, const PriorityTag< 1 > &) -> decltype(std::integral_constant< std::size_t, T().size()>())
 
template<class T >
constexpr auto staticSize (const T *, const PriorityTag< 2 > &) -> decltype(std::integral_constant< std::size_t, std::tuple_size< T >::value >())
 
template<class T >
constexpr std::false_type hasStaticSize (const T *t, const PriorityTag< 0 > &p)
 
template<class T >
constexpr auto hasStaticSize (const T *t, const PriorityTag< 1 > &p) -> decltype(staticSize(t, PriorityTag< 42 >()), std::true_type())
 
template<class F , class... T, std::size_t... k>
auto transformTupleHelper (F &&f, const std::tuple< T... > &tuple, std::index_sequence< k... >) -> decltype(std::make_tuple(f(std::get< k >(tuple))...))
 
template<class F , class... T1, class... T2, std::size_t... k>
auto transformTupleHelper (F &&f, const std::tuple< T1... > &tuple1, const std::tuple< T2... > &tuple2, std::index_sequence< k... >) -> decltype(std::make_tuple(f(std::get< k >(tuple1), std::get< k >(tuple2))...))
 
template<class... T>
constexpr std::true_type isHybridTreePath (const TypeTree::HybridTreePath< T... > &)
 
template<class T >
constexpr std::false_type isHybridTreePath (const T &)
 
template<class T >
constexpr auto isHybridTreePath () -> decltype(isHybridTreePath(std::declval< std::decay_t< T >>()))
 

Typedef Documentation

◆ index_sequence_for

template<typename... T>
using Dune::Functions::Imp::index_sequence_for = typedef std::make_index_sequence<SizeOf<T...>{}>

Function Documentation

◆ derivativeIfImplemented() [1/2]

template<class Dummy , class F , typename std::enable_if< models< HasFreeDerivative, F >(), int >::type = 0>
auto Dune::Functions::Imp::derivativeIfImplemented ( const F &  f) -> decltype(derivative(f))

◆ derivativeIfImplemented() [2/2]

template<class Dummy , class F , typename std::enable_if< not(models< HasFreeDerivative, F >()), int >::type = 0>
Dummy Dune::Functions::Imp::derivativeIfImplemented ( const F &  f)

◆ hasStaticSize() [1/2]

template<class T >
constexpr std::false_type Dune::Functions::Imp::hasStaticSize ( const T *  t,
const PriorityTag< 0 > &  p 
)

◆ hasStaticSize() [2/2]

template<class T >
constexpr auto Dune::Functions::Imp::hasStaticSize ( const T *  t,
const PriorityTag< 1 > &  p 
) -> decltype(staticSize(t ,PriorityTag<42>()), std::true_type())

◆ isHybridTreePath() [1/3]

template<class... T>
constexpr std::true_type Dune::Functions::Imp::isHybridTreePath ( const TypeTree::HybridTreePath< T... > &  )

◆ isHybridTreePath() [2/3]

template<class T >
constexpr std::false_type Dune::Functions::Imp::isHybridTreePath ( const T &  )

◆ isHybridTreePath() [3/3]

template<class T >
constexpr auto Dune::Functions::Imp::isHybridTreePath ( ) -> decltype(isHybridTreePath(std::declval<std::decay_t<T>>()))

◆ staticSize() [1/3]

template<class T >
constexpr auto Dune::Functions::Imp::staticSize ( const T *  ,
const PriorityTag< 0 > &   
) -> decltype(std::integral_constant<std::size_t,T::size()>())

◆ staticSize() [2/3]

template<class T >
constexpr auto Dune::Functions::Imp::staticSize ( const T *  ,
const PriorityTag< 1 > &   
) -> decltype(std::integral_constant<std::size_t,T().size()>())

◆ staticSize() [3/3]

template<class T >
constexpr auto Dune::Functions::Imp::staticSize ( const T *  ,
const PriorityTag< 2 > &   
) -> decltype(std::integral_constant<std::size_t,std::tuple_size<T>::value>())

◆ transformTupleHelper() [1/2]

template<class F , class... T, std::size_t... k>
auto Dune::Functions::Imp::transformTupleHelper ( F &&  f,
const std::tuple< T... > &  tuple,
std::index_sequence< k... >   
) -> decltype(std::make_tuple(f(std::get<k>(tuple))...))

◆ transformTupleHelper() [2/2]

template<class F , class... T1, class... T2, std::size_t... k>
auto Dune::Functions::Imp::transformTupleHelper ( F &&  f,
const std::tuple< T1... > &  tuple1,
const std::tuple< T2... > &  tuple2,
std::index_sequence< k... >   
) -> decltype(std::make_tuple(f(std::get<k>(tuple1), std::get<k>(tuple2))...))