│ │ │ │
Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
7 #ifndef DUNE_FUNCTIONS_COMMON_LOCAL_FUNCTION_HH
│ │ │ │ -
8 #define DUNE_FUNCTIONS_COMMON_LOCAL_FUNCTION_HH
│ │ │ │ +
7 #ifndef DUNE_FUNCTIONS_COMMON_DIFFERENTIABLE_FUNCTION_HH
│ │ │ │ +
8 #define DUNE_FUNCTIONS_COMMON_DIFFERENTIABLE_FUNCTION_HH
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
12 #include <dune/common/typeutilities.hh>
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
32 template <
class Signature,
class LocalContext,
template <
class >
class DerivativeTraits=DefaultDerivativeTraits,
size_t bufferSize=56>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
31 template <
class Signature,
template <
class >
class DerivativeTraits=DefaultDerivativeTraits,
size_t bufferSize=56>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
42 template <
class S,
class L,
template <
class >
class DerivativeTraits,
size_t bufferSize>
│ │ │ │ -
43 struct LocalFunctionTraits :
│ │ │ │ -
44 DifferentiableFunctionTraits<S, DerivativeTraits, bufferSize>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
47 using Base=DifferentiableFunctionTraits<S, DerivativeTraits, bufferSize>;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
51 using LocalContext = L;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
41 template <
class S,
template <
class >
class DerivativeTraits,
size_t bufferSize>
│ │ │ │ +
42 struct DifferentiableFunctionTraits
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
54 using DerivativeSignature =
typename Base::DerivativeSignature;
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
60 using Concept = LocalFunctionWrapperInterface<S, DerivativeInterface, L>;
│ │ │ │ +
60 using Concept = DifferentiableFunctionWrapperInterface<Signature, DerivativeInterface>;
│ │ │ │
│ │ │ │
│ │ │ │ -
64 using Model = LocalFunctionWrapperImplementation<S, DerivativeInterface, L, B>;
│ │ │ │ +
64 using Model = DifferentiableFunctionWrapperImplementation<Signature, DerivativeInterface, B>;
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
90 template <
class Range,
class Domain,
class LocalContext,
template <
class >
class DerivativeTraits,
size_t bufferSize>
│ │ │ │ -
│ │ │ │ -
91 class LocalFunction < Range(Domain), LocalContext, DerivativeTraits, bufferSize> :
│ │ │ │ -
│ │ │ │ -
93 typename Imp::LocalFunctionTraits<Range(Domain), LocalContext, DerivativeTraits, bufferSize>::Concept,
│ │ │ │ -
94 Imp::LocalFunctionTraits<Range(Domain), LocalContext, DerivativeTraits, bufferSize>::template Model>
│ │ │ │ -
│ │ │ │ -
96 using Traits = Imp::LocalFunctionTraits<Range(Domain), LocalContext, DerivativeTraits, bufferSize>;
│ │ │ │ +
84 template <
class Range,
class Domain,
template <
class >
class DerivativeTraits,
size_t bufferSize>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
87 typename Imp::DifferentiableFunctionTraits<Range(Domain), DerivativeTraits, bufferSize>::Concept,
│ │ │ │ +
88 Imp::DifferentiableFunctionTraits<Range(Domain), DerivativeTraits, bufferSize>::template Model>
│ │ │ │ +
│ │ │ │ +
90 using Traits = Imp::DifferentiableFunctionTraits<Range(Domain), DerivativeTraits, bufferSize>;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
115 template <
class F, disableCopyMove<LocalFunction, F> = 0 >
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
117 Base (std::forward<F>(f))
│ │ │ │ -
│ │ │ │ -
119 static_assert (Dune::Functions::Concept::isLocalFunction<F, Range(Domain), LocalContext>(),
"Trying to construct a LocalFunction from type that does not model the LocalFunction concept" );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
127 Range operator() (
const Domain& x)
const
│ │ │ │ -
│ │ │ │ -
129 return this->asInterface().operator()(x);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
141 return t.asInterface().derivative();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
109 template <
class F, disableCopyMove<DifferentiableFunction, F> = 0 >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
111 Base (std::forward<F>(f))
│ │ │ │ +
│ │ │ │ +
113 static_assert (Dune::Functions::Concept::isFunction<F, Range(Domain)>(),
"Trying to construct a DifferentiableFunction from type that does not model the Function concept" );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
122 Range operator() (
const Domain& x)
const
│ │ │ │ +
│ │ │ │ +
124 return this->asInterface().operator()(x);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
136 return t.asInterface().derivative();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
150 void bind (
const LocalContext& context)
│ │ │ │ -
│ │ │ │ -
152 this->asInterface().bind(context);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
160 this->asInterface().unbind();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
167 return this->asInterface().bound();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
175 return this->asInterface().localContext();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
friend DerivativeInterface derivative(const LocalFunction &t)
Get derivative of wrapped function.
Definition localfunction.hh:139
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
friend DerivativeInterface derivative(const DifferentiableFunction &t)
Get derivative of wrapped function.
Definition differentiablefunction.hh:134
│ │ │ │
Definition polynomial.hh:17
│ │ │ │ -
Definition localfunction.hh:34
│ │ │ │ -
const LocalContext & localContext() const
Obtain local context this LocalFunction is bound to.
Definition localfunction.hh:173
│ │ │ │ -
LocalFunction(F &&f)
Construct from function.
Definition localfunction.hh:116
│ │ │ │ -
void unbind()
Unbind from local context.
Definition localfunction.hh:158
│ │ │ │ -
bool bound() const
Return if the local function is bound to a grid element.
Definition localfunction.hh:165
│ │ │ │ -
void bind(const LocalContext &context)
Bind function to a local context.
Definition localfunction.hh:150
│ │ │ │ -
│ │ │ │ +
Definition differentiablefunction.hh:33
│ │ │ │ +
DifferentiableFunction(F &&f)
Construct from function.
Definition differentiablefunction.hh:110
│ │ │ │ +
DifferentiableFunction()=default
Default constructor.
│ │ │ │ +
Helper class to deduce the signature of a callable.
Definition signature.hh:60
│ │ │ │
Base class for type-erased interface wrapper.
Definition typeerasure.hh:169
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,194 +1,157 @@
│ │ │ │ │ dune-functions 2.10
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _f_u_n_c_t_i_o_n_s
│ │ │ │ │ * _c_o_m_m_o_n
│ │ │ │ │ -localfunction.hh
│ │ │ │ │ +differentiablefunction.hh
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ 2// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ 3
│ │ │ │ │ 4// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file
│ │ │ │ │ AUTHORS.md
│ │ │ │ │ 5// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception OR
│ │ │ │ │ LGPL-3.0-or-later
│ │ │ │ │ 6
│ │ │ │ │ -7#ifndef DUNE_FUNCTIONS_COMMON_LOCAL_FUNCTION_HH
│ │ │ │ │ -8#define DUNE_FUNCTIONS_COMMON_LOCAL_FUNCTION_HH
│ │ │ │ │ +7#ifndef DUNE_FUNCTIONS_COMMON_DIFFERENTIABLE_FUNCTION_HH
│ │ │ │ │ +8#define DUNE_FUNCTIONS_COMMON_DIFFERENTIABLE_FUNCTION_HH
│ │ │ │ │ 9
│ │ │ │ │ 10#include
│ │ │ │ │ 11
│ │ │ │ │ 12#include
│ │ │ │ │ 13
│ │ │ │ │ -14#include <_d_u_n_e_/_f_u_n_c_t_i_o_n_s_/_c_o_m_m_o_n_/_d_e_f_a_u_l_t_d_e_r_i_v_a_t_i_v_e_t_r_a_i_t_s_._h_h>
│ │ │ │ │ -15#include <_d_u_n_e_/_f_u_n_c_t_i_o_n_s_/_c_o_m_m_o_n_/_d_i_f_f_e_r_e_n_t_i_a_b_l_e_f_u_n_c_t_i_o_n_._h_h>
│ │ │ │ │ -16#include <_d_u_n_e_/_f_u_n_c_t_i_o_n_s_/_c_o_m_m_o_n_/_l_o_c_a_l_f_u_n_c_t_i_o_n___i_m_p_._h_h>
│ │ │ │ │ -17#include <_d_u_n_e_/_f_u_n_c_t_i_o_n_s_/_c_o_m_m_o_n_/_t_y_p_e_e_r_a_s_u_r_e_._h_h>
│ │ │ │ │ -18#include <_d_u_n_e_/_f_u_n_c_t_i_o_n_s_/_c_o_m_m_o_n_/_f_u_n_c_t_i_o_n_c_o_n_c_e_p_t_s_._h_h>
│ │ │ │ │ -19
│ │ │ │ │ +14#include <_d_u_n_e_/_f_u_n_c_t_i_o_n_s_/_c_o_m_m_o_n_/_t_y_p_e___t_r_a_i_t_s_._h_h>
│ │ │ │ │ +15#include <_d_u_n_e_/_f_u_n_c_t_i_o_n_s_/_c_o_m_m_o_n_/_d_e_f_a_u_l_t_d_e_r_i_v_a_t_i_v_e_t_r_a_i_t_s_._h_h>
│ │ │ │ │ +16#include <_d_u_n_e_/_f_u_n_c_t_i_o_n_s_/_c_o_m_m_o_n_/_d_i_f_f_e_r_e_n_t_i_a_b_l_e_f_u_n_c_t_i_o_n___i_m_p_._h_h>
│ │ │ │ │ +17#include <_d_u_n_e_/_f_u_n_c_t_i_o_n_s_/_c_o_m_m_o_n_/_s_i_g_n_a_t_u_r_e_._h_h>
│ │ │ │ │ +18#include <_d_u_n_e_/_f_u_n_c_t_i_o_n_s_/_c_o_m_m_o_n_/_t_y_p_e_e_r_a_s_u_r_e_._h_h>
│ │ │ │ │ +19#include <_d_u_n_e_/_f_u_n_c_t_i_o_n_s_/_c_o_m_m_o_n_/_f_u_n_c_t_i_o_n_c_o_n_c_e_p_t_s_._h_h>
│ │ │ │ │ 20
│ │ │ │ │ -21
│ │ │ │ │ -22namespace _D_u_n_e {
│ │ │ │ │ -23namespace Functions {
│ │ │ │ │ +21namespace _D_u_n_e {
│ │ │ │ │ +22namespace Functions {
│ │ │ │ │ +23
│ │ │ │ │ 24
│ │ │ │ │ 25
│ │ │ │ │ -26
│ │ │ │ │ -27/*
│ │ │ │ │ -28 * Default implementation is empty
│ │ │ │ │ -29 * The actual implementation is only given if Signature is an type
│ │ │ │ │ -30 * describing a function signature as Range(Domain).
│ │ │ │ │ -31 */
│ │ │ │ │ -32template class
│ │ │ │ │ +26/*
│ │ │ │ │ +27 * Default implementation is empty
│ │ │ │ │ +28 * The actual implementation is only given if Signature is an type
│ │ │ │ │ +29 * describing a function signature as Range(Domain).
│ │ │ │ │ +30 */
│ │ │ │ │ +31template class
│ │ │ │ │ DerivativeTraits=DefaultDerivativeTraits, size_t bufferSize=56>
│ │ │ │ │ -_3_3class _L_o_c_a_l_F_u_n_c_t_i_o_n
│ │ │ │ │ -34{};
│ │ │ │ │ +_3_2class _D_i_f_f_e_r_e_n_t_i_a_b_l_e_F_u_n_c_t_i_o_n
│ │ │ │ │ +33{};
│ │ │ │ │ +34
│ │ │ │ │ 35
│ │ │ │ │ 36
│ │ │ │ │ -37
│ │ │ │ │ -38namespace Imp
│ │ │ │ │ -39{
│ │ │ │ │ -40
│ │ │ │ │ -42 template class DerivativeTraits, size_t
│ │ │ │ │ -bufferSize>
│ │ │ │ │ -43 struct LocalFunctionTraits :
│ │ │ │ │ -44 DifferentiableFunctionTraits
│ │ │ │ │ -45 {
│ │ │ │ │ -46 protected:
│ │ │ │ │ -47 using Base=DifferentiableFunctionTraits;
│ │ │ │ │ -48
│ │ │ │ │ -49 public:
│ │ │ │ │ -51 using LocalContext = L;
│ │ │ │ │ +37namespace Imp
│ │ │ │ │ +38{
│ │ │ │ │ +39
│ │ │ │ │ +41 template class DerivativeTraits, size_t bufferSize>
│ │ │ │ │ +42 struct DifferentiableFunctionTraits
│ │ │ │ │ +43 {
│ │ │ │ │ +45 using Signature = S;
│ │ │ │ │ +46
│ │ │ │ │ +48 using Range = typename _S_i_g_n_a_t_u_r_e_T_r_a_i_t_s_<_S_i_g_n_a_t_u_r_e_>_:_:_R_a_n_g_e;
│ │ │ │ │ +49
│ │ │ │ │ +51 using Domain = typename _S_i_g_n_a_t_u_r_e_T_r_a_i_t_s_<_S_i_g_n_a_t_u_r_e_>_:_:_D_o_m_a_i_n;
│ │ │ │ │ 52
│ │ │ │ │ -54 using DerivativeSignature = typename Base::DerivativeSignature;
│ │ │ │ │ +54 using DerivativeSignature = typename _S_i_g_n_a_t_u_r_e_T_r_a_i_t_s_<_S_i_g_n_a_t_u_r_e_>_:_:_t_e_m_p_l_a_t_e
│ │ │ │ │ +DerivativeSignature;
│ │ │ │ │ 55
│ │ │ │ │ -57 using DerivativeInterface = _L_o_c_a_l_F_u_n_c_t_i_o_n_<_D_e_r_i_v_a_t_i_v_e_S_i_g_n_a_t_u_r_e_,_ _L_,
│ │ │ │ │ +57 using DerivativeInterface = _D_i_f_f_e_r_e_n_t_i_a_b_l_e_F_u_n_c_t_i_o_n_<_D_e_r_i_v_a_t_i_v_e_S_i_g_n_a_t_u_r_e_,
│ │ │ │ │ _D_e_r_i_v_a_t_i_v_e_T_r_a_i_t_s_,_ _b_u_f_f_e_r_S_i_z_e_>;
│ │ │ │ │ 58
│ │ │ │ │ -60 using Concept = LocalFunctionWrapperInterface;
│ │ │ │ │ +60 using Concept = DifferentiableFunctionWrapperInterface;
│ │ │ │ │ 61
│ │ │ │ │ 63 template
│ │ │ │ │ -64 using Model = LocalFunctionWrapperImplementation;
│ │ │ │ │ +64 using Model = DifferentiableFunctionWrapperImplementation;
│ │ │ │ │ 65 };
│ │ │ │ │ 66}
│ │ │ │ │ 67
│ │ │ │ │ 68
│ │ │ │ │ 69
│ │ │ │ │ -90template class
│ │ │ │ │ -DerivativeTraits, size_t bufferSize>
│ │ │ │ │ -_9_1class _L_o_c_a_l_F_u_n_c_t_i_o_n< Range(Domain), LocalContext, DerivativeTraits,
│ │ │ │ │ -bufferSize> :
│ │ │ │ │ -92 public _T_y_p_e_E_r_a_s_u_r_e_B_a_s_e<
│ │ │ │ │ -93 typename Imp::LocalFunctionTraits::Concept,
│ │ │ │ │ -94 Imp::LocalFunctionTraits class DerivativeTraits,
│ │ │ │ │ +size_t bufferSize>
│ │ │ │ │ +_8_5class _D_i_f_f_e_r_e_n_t_i_a_b_l_e_F_u_n_c_t_i_o_n< Range(Domain), DerivativeTraits, bufferSize> :
│ │ │ │ │ +86 public _T_y_p_e_E_r_a_s_u_r_e_B_a_s_e<
│ │ │ │ │ +87 typename Imp::DifferentiableFunctionTraits::Concept,
│ │ │ │ │ +88 Imp::DifferentiableFunctionTraits::template Model>
│ │ │ │ │ -95{
│ │ │ │ │ -96 using Traits = Imp::LocalFunctionTraits;
│ │ │ │ │ -97
│ │ │ │ │ -98 using _B_a_s_e = _T_y_p_e_E_r_a_s_u_r_e_B_a_s_e_<_t_y_p_e_n_a_m_e_ _T_r_a_i_t_s_:_:_C_o_n_c_e_p_t_,_ _T_r_a_i_t_s_:_:_t_e_m_p_l_a_t_e
│ │ │ │ │ +91
│ │ │ │ │ +92 using _B_a_s_e = _T_y_p_e_E_r_a_s_u_r_e_B_a_s_e_<_t_y_p_e_n_a_m_e_ _T_r_a_i_t_s_:_:_C_o_n_c_e_p_t_,_ _T_r_a_i_t_s_:_:_t_e_m_p_l_a_t_e
│ │ │ │ │ _M_o_d_e_l_>;
│ │ │ │ │ -99
│ │ │ │ │ -100 using DerivativeInterface = typename _T_r_a_i_t_s_:_:_D_e_r_i_v_a_t_i_v_e_I_n_t_e_r_f_a_c_e;
│ │ │ │ │ -101
│ │ │ │ │ -102public:
│ │ │ │ │ -103
│ │ │ │ │ -115 template = 0 >
│ │ │ │ │ -_1_1_6 _L_o_c_a_l_F_u_n_c_t_i_o_n(F&& f) :
│ │ │ │ │ -117 _B_a_s_e(std::forward(f))
│ │ │ │ │ -118 {
│ │ │ │ │ -119 static_assert(Dune::Functions::Concept::isLocalFunction(), "Trying to construct a LocalFunction from type that does not
│ │ │ │ │ -model the LocalFunction concept");
│ │ │ │ │ -120 }
│ │ │ │ │ -121
│ │ │ │ │ -_1_2_2 _L_o_c_a_l_F_u_n_c_t_i_o_n() = default;
│ │ │ │ │ -123
│ │ │ │ │ -_1_2_7 Range operator() (const Domain& x) const
│ │ │ │ │ -128 {
│ │ │ │ │ -129 return this->asInterface().operator()(x);
│ │ │ │ │ -130 }
│ │ │ │ │ -131
│ │ │ │ │ -_1_3_9 friend DerivativeInterface _d_e_r_i_v_a_t_i_v_e(const _L_o_c_a_l_F_u_n_c_t_i_o_n& t)
│ │ │ │ │ -140 {
│ │ │ │ │ -141 return t.asInterface().derivative();
│ │ │ │ │ -142 }
│ │ │ │ │ +93
│ │ │ │ │ +94 using DerivativeInterface = typename _T_r_a_i_t_s_:_:_D_e_r_i_v_a_t_i_v_e_I_n_t_e_r_f_a_c_e;
│ │ │ │ │ +95
│ │ │ │ │ +96public:
│ │ │ │ │ +97
│ │ │ │ │ +109 template = 0 >
│ │ │ │ │ +_1_1_0 _D_i_f_f_e_r_e_n_t_i_a_b_l_e_F_u_n_c_t_i_o_n(F&& f) :
│ │ │ │ │ +111 _B_a_s_e(std::forward(f))
│ │ │ │ │ +112 {
│ │ │ │ │ +113 static_assert(Dune::Functions::Concept::isFunction(),
│ │ │ │ │ +"Trying to construct a DifferentiableFunction from type that does not model the
│ │ │ │ │ +Function concept");
│ │ │ │ │ +114 }
│ │ │ │ │ +115
│ │ │ │ │ +_1_1_7 _D_i_f_f_e_r_e_n_t_i_a_b_l_e_F_u_n_c_t_i_o_n() = default;
│ │ │ │ │ +118
│ │ │ │ │ +_1_2_2 Range operator() (const Domain& x) const
│ │ │ │ │ +123 {
│ │ │ │ │ +124 return this->asInterface().operator()(x);
│ │ │ │ │ +125 }
│ │ │ │ │ +126
│ │ │ │ │ +_1_3_4 friend DerivativeInterface _d_e_r_i_v_a_t_i_v_e(const _D_i_f_f_e_r_e_n_t_i_a_b_l_e_F_u_n_c_t_i_o_n& t)
│ │ │ │ │ +135 {
│ │ │ │ │ +136 return t.asInterface().derivative();
│ │ │ │ │ +137 }
│ │ │ │ │ +138};
│ │ │ │ │ +139
│ │ │ │ │ +140
│ │ │ │ │ +141
│ │ │ │ │ +142}} // namespace Dune::Functions
│ │ │ │ │ 143
│ │ │ │ │ -_1_5_0 void _b_i_n_d(const LocalContext& context)
│ │ │ │ │ -151 {
│ │ │ │ │ -152 this->asInterface().bind(context);
│ │ │ │ │ -153 }
│ │ │ │ │ -154
│ │ │ │ │ -_1_5_8 void _u_n_b_i_n_d()
│ │ │ │ │ -159 {
│ │ │ │ │ -160 this->asInterface().unbind();
│ │ │ │ │ -161 }
│ │ │ │ │ -162
│ │ │ │ │ -_1_6_5 bool _b_o_u_n_d() const
│ │ │ │ │ -166 {
│ │ │ │ │ -167 return this->asInterface().bound();
│ │ │ │ │ -168 }
│ │ │ │ │ -169
│ │ │ │ │ -_1_7_3 const LocalContext& _l_o_c_a_l_C_o_n_t_e_x_t() const
│ │ │ │ │ -174 {
│ │ │ │ │ -175 return this->asInterface().localContext();
│ │ │ │ │ -176 }
│ │ │ │ │ -177};
│ │ │ │ │ -178
│ │ │ │ │ -179
│ │ │ │ │ -180
│ │ │ │ │ -181}} // namespace Dune::Functions
│ │ │ │ │ -182
│ │ │ │ │ -183
│ │ │ │ │ -184
│ │ │ │ │ -185#endif // DUNE_FUNCTIONS_COMMON_LOCAL_FUNCTION_HH
│ │ │ │ │ -_d_i_f_f_e_r_e_n_t_i_a_b_l_e_f_u_n_c_t_i_o_n_._h_h
│ │ │ │ │ +144
│ │ │ │ │ +145
│ │ │ │ │ +146#endif // DUNE_FUNCTIONS_COMMON_DIFFERENTIABLE_FUNCTION_HH
│ │ │ │ │ +_s_i_g_n_a_t_u_r_e_._h_h
│ │ │ │ │ +_f_u_n_c_t_i_o_n_c_o_n_c_e_p_t_s_._h_h
│ │ │ │ │ +_t_y_p_e___t_r_a_i_t_s_._h_h
│ │ │ │ │ _d_e_f_a_u_l_t_d_e_r_i_v_a_t_i_v_e_t_r_a_i_t_s_._h_h
│ │ │ │ │ _t_y_p_e_e_r_a_s_u_r_e_._h_h
│ │ │ │ │ -_l_o_c_a_l_f_u_n_c_t_i_o_n___i_m_p_._h_h
│ │ │ │ │ -_f_u_n_c_t_i_o_n_c_o_n_c_e_p_t_s_._h_h
│ │ │ │ │ -_D_u_n_e_:_:_F_u_n_c_t_i_o_n_s_:_:_L_o_c_a_l_F_u_n_c_t_i_o_n_<_ _R_a_n_g_e_(_D_o_m_a_i_n_)_,_ _L_o_c_a_l_C_o_n_t_e_x_t_,_ _D_e_r_i_v_a_t_i_v_e_T_r_a_i_t_s_,
│ │ │ │ │ +_d_i_f_f_e_r_e_n_t_i_a_b_l_e_f_u_n_c_t_i_o_n___i_m_p_._h_h
│ │ │ │ │ +_D_u_n_e_:_:_F_u_n_c_t_i_o_n_s_:_:_D_i_f_f_e_r_e_n_t_i_a_b_l_e_F_u_n_c_t_i_o_n_<_ _R_a_n_g_e_(_D_o_m_a_i_n_)_,_ _D_e_r_i_v_a_t_i_v_e_T_r_a_i_t_s_,
│ │ │ │ │ _b_u_f_f_e_r_S_i_z_e_ _>_:_:_d_e_r_i_v_a_t_i_v_e
│ │ │ │ │ -friend DerivativeInterface derivative(const LocalFunction &t)
│ │ │ │ │ +friend DerivativeInterface derivative(const DifferentiableFunction &t)
│ │ │ │ │ Get derivative of wrapped function.
│ │ │ │ │ -DDeeffiinniittiioonn localfunction.hh:139
│ │ │ │ │ +DDeeffiinniittiioonn differentiablefunction.hh:134
│ │ │ │ │ _D_u_n_e
│ │ │ │ │ DDeeffiinniittiioonn polynomial.hh:17
│ │ │ │ │ -_D_u_n_e_:_:_F_u_n_c_t_i_o_n_s_:_:_L_o_c_a_l_F_u_n_c_t_i_o_n
│ │ │ │ │ -DDeeffiinniittiioonn localfunction.hh:34
│ │ │ │ │ -_D_u_n_e_:_:_F_u_n_c_t_i_o_n_s_:_:_L_o_c_a_l_F_u_n_c_t_i_o_n_<_ _R_a_n_g_e_(_D_o_m_a_i_n_)_,_ _L_o_c_a_l_C_o_n_t_e_x_t_,_ _D_e_r_i_v_a_t_i_v_e_T_r_a_i_t_s_,
│ │ │ │ │ -_b_u_f_f_e_r_S_i_z_e_ _>_:_:_l_o_c_a_l_C_o_n_t_e_x_t
│ │ │ │ │ -const LocalContext & localContext() const
│ │ │ │ │ -Obtain local context this LocalFunction is bound to.
│ │ │ │ │ -DDeeffiinniittiioonn localfunction.hh:173
│ │ │ │ │ -_D_u_n_e_:_:_F_u_n_c_t_i_o_n_s_:_:_L_o_c_a_l_F_u_n_c_t_i_o_n_<_ _R_a_n_g_e_(_D_o_m_a_i_n_)_,_ _L_o_c_a_l_C_o_n_t_e_x_t_,_ _D_e_r_i_v_a_t_i_v_e_T_r_a_i_t_s_,
│ │ │ │ │ -_b_u_f_f_e_r_S_i_z_e_ _>_:_:_L_o_c_a_l_F_u_n_c_t_i_o_n
│ │ │ │ │ -LocalFunction(F &&f)
│ │ │ │ │ +_D_u_n_e_:_:_F_u_n_c_t_i_o_n_s_:_:_D_i_f_f_e_r_e_n_t_i_a_b_l_e_F_u_n_c_t_i_o_n
│ │ │ │ │ +DDeeffiinniittiioonn differentiablefunction.hh:33
│ │ │ │ │ +_D_u_n_e_:_:_F_u_n_c_t_i_o_n_s_:_:_D_i_f_f_e_r_e_n_t_i_a_b_l_e_F_u_n_c_t_i_o_n_<_ _R_a_n_g_e_(_D_o_m_a_i_n_)_,_ _D_e_r_i_v_a_t_i_v_e_T_r_a_i_t_s_,
│ │ │ │ │ +_b_u_f_f_e_r_S_i_z_e_ _>_:_:_D_i_f_f_e_r_e_n_t_i_a_b_l_e_F_u_n_c_t_i_o_n
│ │ │ │ │ +DifferentiableFunction(F &&f)
│ │ │ │ │ Construct from function.
│ │ │ │ │ -DDeeffiinniittiioonn localfunction.hh:116
│ │ │ │ │ -_D_u_n_e_:_:_F_u_n_c_t_i_o_n_s_:_:_L_o_c_a_l_F_u_n_c_t_i_o_n_<_ _R_a_n_g_e_(_D_o_m_a_i_n_)_,_ _L_o_c_a_l_C_o_n_t_e_x_t_,_ _D_e_r_i_v_a_t_i_v_e_T_r_a_i_t_s_,
│ │ │ │ │ -_b_u_f_f_e_r_S_i_z_e_ _>_:_:_u_n_b_i_n_d
│ │ │ │ │ -void unbind()
│ │ │ │ │ -Unbind from local context.
│ │ │ │ │ -DDeeffiinniittiioonn localfunction.hh:158
│ │ │ │ │ -_D_u_n_e_:_:_F_u_n_c_t_i_o_n_s_:_:_L_o_c_a_l_F_u_n_c_t_i_o_n_<_ _R_a_n_g_e_(_D_o_m_a_i_n_)_,_ _L_o_c_a_l_C_o_n_t_e_x_t_,_ _D_e_r_i_v_a_t_i_v_e_T_r_a_i_t_s_,
│ │ │ │ │ -_b_u_f_f_e_r_S_i_z_e_ _>_:_:_b_o_u_n_d
│ │ │ │ │ -bool bound() const
│ │ │ │ │ -Return if the local function is bound to a grid element.
│ │ │ │ │ -DDeeffiinniittiioonn localfunction.hh:165
│ │ │ │ │ -_D_u_n_e_:_:_F_u_n_c_t_i_o_n_s_:_:_L_o_c_a_l_F_u_n_c_t_i_o_n_<_ _R_a_n_g_e_(_D_o_m_a_i_n_)_,_ _L_o_c_a_l_C_o_n_t_e_x_t_,_ _D_e_r_i_v_a_t_i_v_e_T_r_a_i_t_s_,
│ │ │ │ │ -_b_u_f_f_e_r_S_i_z_e_ _>_:_:_b_i_n_d
│ │ │ │ │ -void bind(const LocalContext &context)
│ │ │ │ │ -Bind function to a local context.
│ │ │ │ │ -DDeeffiinniittiioonn localfunction.hh:150
│ │ │ │ │ -_D_u_n_e_:_:_F_u_n_c_t_i_o_n_s_:_:_L_o_c_a_l_F_u_n_c_t_i_o_n_<_ _R_a_n_g_e_(_D_o_m_a_i_n_)_,_ _L_o_c_a_l_C_o_n_t_e_x_t_,_ _D_e_r_i_v_a_t_i_v_e_T_r_a_i_t_s_,
│ │ │ │ │ -_b_u_f_f_e_r_S_i_z_e_ _>_:_:_L_o_c_a_l_F_u_n_c_t_i_o_n
│ │ │ │ │ -LocalFunction()=default
│ │ │ │ │ +DDeeffiinniittiioonn differentiablefunction.hh:110
│ │ │ │ │ +_D_u_n_e_:_:_F_u_n_c_t_i_o_n_s_:_:_D_i_f_f_e_r_e_n_t_i_a_b_l_e_F_u_n_c_t_i_o_n_<_ _R_a_n_g_e_(_D_o_m_a_i_n_)_,_ _D_e_r_i_v_a_t_i_v_e_T_r_a_i_t_s_,
│ │ │ │ │ +_b_u_f_f_e_r_S_i_z_e_ _>_:_:_D_i_f_f_e_r_e_n_t_i_a_b_l_e_F_u_n_c_t_i_o_n
│ │ │ │ │ +DifferentiableFunction()=default
│ │ │ │ │ +Default constructor.
│ │ │ │ │ +_D_u_n_e_:_:_F_u_n_c_t_i_o_n_s_:_:_S_i_g_n_a_t_u_r_e_T_r_a_i_t_s
│ │ │ │ │ +Helper class to deduce the signature of a callable.
│ │ │ │ │ +DDeeffiinniittiioonn signature.hh:60
│ │ │ │ │ _D_u_n_e_:_:_F_u_n_c_t_i_o_n_s_:_:_T_y_p_e_E_r_a_s_u_r_e_B_a_s_e
│ │ │ │ │ Base class for type-erased interface wrapper.
│ │ │ │ │ DDeeffiinniittiioonn typeerasure.hh:169
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-functions-doc/doxygen/a00014.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-functions: indexaccess.hh File Reference
│ │ │ │ +dune-functions: functionconcepts.hh File Reference
│ │ │ │
│ │ │ │
Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
7 #ifndef DUNE_FUNCTIONS_COMMON_INDEX_ACCESS_HH
│ │ │ │ -
8 #define DUNE_FUNCTIONS_COMMON_INDEX_ACCESS_HH
│ │ │ │ +
7 #ifndef DUNE_FUNCTIONS_COMMON_FUNCTIONCONCEPT_HH
│ │ │ │ +
8 #define DUNE_FUNCTIONS_COMMON_FUNCTIONCONCEPT_HH
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
14 #include <dune/common/typetraits.hh>
│ │ │ │ -
15 #include <dune/common/concept.hh>
│ │ │ │ -
16 #include <dune/common/hybridutilities.hh>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
10 #include <dune/common/typelist.hh>
│ │ │ │ +
11 #include <dune/common/concept.hh>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
21 using namespace Dune::Concept;
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
30 template <
class size_t ype>
│ │ │ │ -
31 struct HasDynamicIndexAccess
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
34 auto require(C&& c) ->
decltype (
│ │ │ │ -
35 c[std::declval<size_type>()]
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
39 struct HasStaticIndexAccess
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
42 auto require(C&& c) ->
decltype (
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
65 template <
class C,
class I,
class F,
│ │ │ │ -
66 std::enable_if_t< Dune::models<Imp::Concept::HasDynamicIndexAccess<I>, C>(),
int > = 0>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
90 template <
class C,
class I,
class F,
│ │ │ │ -
91 std::enable_if_t< not Dune::models<Imp::Concept::HasDynamicIndexAccess<I>, C>(),
int > = 0>
│ │ │ │ +
35 template <
class ... Args>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
40 f(std::declval<Args>()...)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
50 template <
class F,
class ... Args>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
60 template <
class F,
class ... Args>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
69 template <
class Signature>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
80 template <
class Range,
class Domain>
│ │ │ │ +
│ │ │ │ +
81 struct Function <Range(Domain)> : Refines<Callable<Domain> >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
86 requireConvertible<Range>(f(std::declval<Domain>()))
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
91 template <
class F,
class Signature>
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
94 using Size =
decltype (Hybrid::size(c));
│ │ │ │ -
95 return Hybrid::switchCases(std::make_index_sequence<Size::value>(), i,
│ │ │ │ -
96 [&](
const auto & ii) ->
decltype (
auto ){
│ │ │ │ -
│ │ │ │ -
98 }, [&]() ->
decltype (
auto ){
│ │ │ │ -
99 return f(c[Dune::Indices::_0]);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
93 {
return models<Concept::Function<Signature>, F>(); }
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
96 template <
class F,
class Signature,
template <
class >
class DerivativeTraits>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
98 {
return models<Concept::Function<Signature>, F>(); }
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
119 template <
class Index, std::
size_t offset=1>
│ │ │ │ -
120 class ShiftedDynamicMultiIndex
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
123 ShiftedDynamicMultiIndex(
const Index& index) :
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
127 std::size_t operator[](std::size_t position)
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
130 return index_[position+offset];
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
138 ShiftedDynamicMultiIndex<Index, offset+1> pop()
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
143 std::size_t size()
const
│ │ │ │ -
│ │ │ │ -
145 if (offset < index_.size())
│ │ │ │ -
146 return index_.size() - offset;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
151 const Index& originalIndex()
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
160 template <
class Index, std::
size_t offset=1>
│ │ │ │ -
161 class ShiftedStaticMultiIndex
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
164 ShiftedStaticMultiIndex(
const Index& index) :
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
117 template <
class Range,
class Domain,
template <
class >
class DerivativeTraits>
│ │ │ │ +
│ │ │ │ +
118 struct DifferentiableFunction <Range(Domain), DerivativeTraits> : Refines<Dune::Functions::Concept::Function<Range(Domain)> >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
125 requireConcept<Function<DerivativeSignature>>(
derivative (f))
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
132 {
return models<Concept::DifferentiableFunction<Signature, DerivativeTraits>, F>(); }
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
135 template <
class F,
class Signature,
template <
class >
class DerivativeTraits>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
137 {
return models<Concept::DifferentiableFunction<Signature, DerivativeTraits>, F>(); }
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
142 template <
class Signature,
class LocalContext>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
154 template <
class Range,
class Domain,
class LocalContext>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
156 Refines<Dune::Functions::Concept::Function<Range(Domain)> >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
160 f.bind(std::declval<LocalContext>()),
│ │ │ │ +
│ │ │ │ +
162 requireConvertible<bool>(f.bound()),
│ │ │ │ +
│ │ │ │ +
164 requireConvertible<LocalContext>(f.localContext())
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
168 template <std::
size_t i>
│ │ │ │ -
169 auto operator[](Dune::index_constant<i>)
const
│ │ │ │ -
│ │ │ │ -
171 if constexpr (i<size()) {
│ │ │ │ -
172 return index_[Dune::index_constant<i+offset>{}];
│ │ │ │ -
│ │ │ │ -
174 return Dune::index_constant<0>{};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
169 template <
class F,
class Signature,
class LocalContext>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
171 {
return models<Concept::LocalFunction<Signature, LocalContext>, F>(); }
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
181 ShiftedStaticMultiIndex<Index, offset+1> pop()
const
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
186 static constexpr std::size_t size()
│ │ │ │ -
│ │ │ │ -
188 auto fullSize =
decltype (Hybrid::size(std::declval<Index>()))::value;
│ │ │ │ -
189 if (offset < fullSize)
│ │ │ │ -
190 return fullSize - offset;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
204 template <std::
size_t offset,
class Index>
│ │ │ │ -
205 ShiftedDynamicMultiIndex<Index, offset> shiftedDynamicMultiIndex(
const Index& index)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
218 template <std::
size_t offset,
class Index, std::
size_t oldOffset>
│ │ │ │ -
219 ShiftedDynamicMultiIndex<Index, offset+oldOffset> shiftedDynamicMultiIndex(
const ShiftedDynamicMultiIndex<Index, oldOffset>& index)
│ │ │ │ -
│ │ │ │ -
221 return {index.originalIndex()};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
224 template <std::
size_t offset,
class Index>
│ │ │ │ -
225 ShiftedStaticMultiIndex<Index, offset> shiftedStaticMultiIndex(
const Index& index)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
190 template <
class Range,
class Domain,
class LocalContext,
template <
class >
class DerivativeTraits>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
193 Dune::Functions::Concept::DifferentiableFunction<Range(Domain), DerivativeTraits>,
│ │ │ │ +
194 Dune::Functions::Concept::LocalFunction<Range(Domain),LocalContext>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
199 f.bind(std::declval<LocalContext>()),
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
202 requireConvertible<LocalContext>(f.localContext())
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
207 template <
class F,
class Signature,
class LocalContext,
template <
class >
class DerivativeTraits =
DefaultDerivativeTraits >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
209 {
return models<Concept::DifferentiableLocalFunction<Signature, LocalContext, DerivativeTraits>, F>(); }
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
227 requireType<typename E::Element>(),
│ │ │ │ +
228 requireType<typename E::LocalCoordinate>(),
│ │ │ │ +
229 requireType<typename E::GlobalCoordinate>()
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
237 template <
class Result,
class Index>
│ │ │ │ -
238 struct MultiIndexResolver
│ │ │ │ -
│ │ │ │ -
240 MultiIndexResolver(
const Index& index) :
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
236 {
return models<Concept::EntitySet, E>(); }
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
241 template <
class Signature,
class EntitySet>
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
245 std::enable_if_t<not std::is_convertible_v<C&, Result>,
int > = 0>
│ │ │ │ -
246 Result operator()(C&& c)
│ │ │ │ -
│ │ │ │ -
248 auto && subIndex = Imp::shiftedDynamicMultiIndex<1>(index_);
│ │ │ │ -
249 auto && subIndexResolver = MultiIndexResolver<Result, decltype(subIndex)>(subIndex);
│ │ │ │ -
250 return (Result)(
hybridIndexAccess (c, index_[Dune::Indices::_0], subIndexResolver));
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
254 std::enable_if_t<std::is_convertible_v<C&, Result>,
int > = 0>
│ │ │ │ -
255 Result operator()(C&& c)
│ │ │ │ -
│ │ │ │ -
257 return (Result)(std::forward<C>(c));
│ │ │ │ -
│ │ │ │ +
253 template <
class Range,
class Domain,
class EntitySet>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
255 Refines<Dune::Functions::Concept::Function<Range(Domain)> >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
285 template <
class Result,
class C,
class MultiIndex>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
289 Imp::MultiIndexResolver<Result, MultiIndex> multiIndexResolver(index);
│ │ │ │ -
290 return multiIndexResolver(c);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
300 template <
class C,
class MultiIndex,
class IsFinal>
│ │ │ │ -
301 constexpr decltype (
auto ) resolveDynamicMultiIndex(C&& c,
const MultiIndex& multiIndex,
const IsFinal& isFinal)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
305 return Hybrid::ifElse(isFinal(c), [&, c =
forwardCapture (std::forward<C>(c))](
auto ) ->
decltype (
auto ) {
│ │ │ │ -
306 assert(multiIndex.size() == 0);
│ │ │ │ -
│ │ │ │ -
308 }, [&](
auto ) ->
decltype (
auto ) {
│ │ │ │ -
309 auto hasDynamicAccess =
callableCheck ([](
auto && cc) -> std::void_t<
decltype (cc[0])> {});
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
312 auto i = multiIndex[0];
│ │ │ │ -
313 auto tail = multiIndex.pop();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
320 return Hybrid::ifElse(hasDynamicAccess(c), [&](
auto id ) ->
decltype (
auto ) {
│ │ │ │ -
321 return Imp::resolveDynamicMultiIndex(
id (c)[i], tail, isFinal);
│ │ │ │ -
322 }, [&](
auto id) ->
decltype (
auto ) {
│ │ │ │ -
│ │ │ │ -
324 auto indexRange =
typename decltype (range(Hybrid::size(
id (c))))::integer_sequence();
│ │ │ │ -
325 return Hybrid::switchCases(indexRange, i, [&](
auto static_i) ->
decltype (
auto ){
│ │ │ │ -
│ │ │ │ -
327 return Imp::resolveDynamicMultiIndex(
id (c)[static_i], tail, isFinal);
│ │ │ │ -
328 }, [&]() ->
decltype (
auto ){
│ │ │ │ -
│ │ │ │ -
330 return Imp::resolveDynamicMultiIndex(
id (c)[Dune::Indices::_0], tail, isFinal);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
336 template <
class C,
class MultiIndex>
│ │ │ │ -
337 constexpr decltype (
auto ) resolveStaticMultiIndex(C&& c,
const MultiIndex& multiIndex)
│ │ │ │ -
│ │ │ │ -
339 auto isExhausted = Hybrid::equal_to(Hybrid::size(multiIndex), Dune::Indices::_0);
│ │ │ │ -
340 return Hybrid::ifElse(isExhausted, [&, c =
forwardCapture (std::forward<C>(c))](
auto ) ->
decltype (
auto ) {
│ │ │ │ -
│ │ │ │ -
342 }, [&](
auto id) ->
decltype (
auto ) {
│ │ │ │ -
343 auto head = multiIndex[Dune::Indices::_0];
│ │ │ │ -
344 auto tail = multiIndex.pop();
│ │ │ │ -
│ │ │ │ -
346 return Imp::resolveStaticMultiIndex(
id (c)[head], tail);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
264 requireConcept<LocalFunction<LocalSignature, LocalContext>>(localFunction(f)),
│ │ │ │ +
265 requireConcept<Concept::EntitySet, EntitySet>(),
│ │ │ │ +
266 requireConvertible<EntitySet>(f.entitySet()),
│ │ │ │ +
267 requireConvertible<typename EntitySet::GlobalCoordinate, Domain>()
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
272 template <
class F,
class Signature,
class EntitySet>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
274 {
return models<Concept::GridFunction<Signature, EntitySet>, F>(); }
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
293 template <
class Range,
class Domain,
class EntitySet,
template <
class >
class DerivativeTraits>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
296 Dune::Functions::Concept::DifferentiableFunction<Range(Domain), DerivativeTraits>,
│ │ │ │ +
297 Dune::Functions::Concept::GridFunction<Range(Domain),EntitySet>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
308 requireConcept<DifferentiableLocalFunction<LocalSignature, LocalContext, LocalDerivativeTraits>>(localFunction(f))
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
313 template <
class F,
class Signature,
class EntitySet,
template <
class >
class DerivativeTraits =
DefaultDerivativeTraits >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
315 {
return models<Concept::DifferentiableGridFunction<Signature, EntitySet, DerivativeTraits>, F>(); }
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
320 template <
class Signature,
class Gr
id View>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
335 template <
class Range,
class Domain,
class Gr
id View>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
337 Refines<Dune::Functions::Concept::GridFunction<Range(Domain), GridViewEntitySet<GridView,0>>>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
346 template <
class F,
class Signature,
class Gr
id View>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
348 {
return models<Concept::GridViewFunction<Signature, GridView>, F>(); }
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
376 template <
class C,
class MultiIndex,
class IsFinal>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
379 return Imp::resolveDynamicMultiIndex(std::forward<C>(c), Imp::shiftedDynamicMultiIndex<0>(multiIndex), isFinal);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
398 template <
class C,
class MultiIndex>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
402 return Imp::resolveDynamicMultiIndex(std::forward<C>(c), Imp::shiftedDynamicMultiIndex<0>(multiIndex), hasNoIndexAccess);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
420 template <
class C,
class MultiIndex>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
423 return Imp::resolveStaticMultiIndex(std::forward<C>(c), Imp::shiftedStaticMultiIndex<0>(multiIndex));
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
auto hybridIndexAccess(C &&c, const I &i, F &&f) -> decltype(f(c[i]))
Provide operator[] index-access for containers.
Definition indexaccess.hh:67
│ │ │ │ -
constexpr decltype(auto) resolveStaticMultiIndex(C &&c, const MultiIndex &multiIndex)
Provide multi-index access by chaining operator[].
Definition indexaccess.hh:421
│ │ │ │ -
auto callableCheck(Expression f)
Create a predicate for checking validity of expressions.
Definition utility.hh:283
│ │ │ │ -
constexpr decltype(auto) resolveDynamicMultiIndex(C &&c, const MultiIndex &multiIndex, const IsFinal &isFinal)
Provide multi-index access by chaining operator[].
Definition indexaccess.hh:377
│ │ │ │ -
Result hybridMultiIndexAccess(C &&c, const MultiIndex &index)
Provide multi-index access by chaining operator[].
Definition indexaccess.hh:286
│ │ │ │ -
auto negatePredicate(Check check)
Negate given predicate.
Definition utility.hh:308
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
368 template <
class Range,
class Domain,
class Gr
id View,
template <
class >
class DerivativeTraits>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
370 Refines<Dune::Functions::Concept::DifferentiableGridFunction<Range(Domain), GridViewEntitySet<GridView,0>, DerivativeTraits>>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
379 template <
class F,
class Signature,
class Gr
id View,
template <
class >
class DerivativeTraits =
DefaultDerivativeTraits >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
381 {
return models<Concept::DifferentiableGridViewFunction<Signature, GridView, DerivativeTraits>, F>(); }
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
static constexpr bool isGridFunction()
Check if F models the GridFunction concept with given signature and entity set.
Definition functionconcepts.hh:273
│ │ │ │ +
static constexpr bool isDifferentiableLocalFunction()
Check if F models the DifferentiableLocalFunction concept with given signature and local context.
Definition functionconcepts.hh:208
│ │ │ │ +
static constexpr bool isFunction()
Check if F models the Function concept with given signature.
Definition functionconcepts.hh:92
│ │ │ │ +
static constexpr bool isDifferentiableGridViewFunction()
Check if F models the DifferentiableGridViewFunction concept with given signature.
Definition functionconcepts.hh:380
│ │ │ │ +
static constexpr bool isDifferentiableFunction()
Check if F models the DifferentiableFunction concept with given signature.
Definition functionconcepts.hh:131
│ │ │ │ +
static constexpr bool isGridViewFunction()
Check if F models the GridViewFunction concept with given signature.
Definition functionconcepts.hh:347
│ │ │ │ +
static constexpr bool isEntitySet()
Check if F models the GridFunction concept with given signature and entity set.
Definition functionconcepts.hh:235
│ │ │ │ +
static constexpr bool isDifferentiableGridFunction()
Check if F models the DifferentiableGridFunction concept with given signature and entity set.
Definition functionconcepts.hh:314
│ │ │ │ +
static constexpr bool isLocalFunction()
Check if F models the LocalFunction concept with given signature and local context.
Definition functionconcepts.hh:170
│ │ │ │ +
TrigonometricFunction< K, -cosFactor, sinFactor > derivative(const TrigonometricFunction< K, sinFactor, cosFactor > &f)
Obtain derivative of TrigonometricFunction function.
Definition trigonometricfunction.hh:43
│ │ │ │ +
static constexpr auto isCallable()
Check if f is callable with given argument list.
Definition functionconcepts.hh:51
│ │ │ │
Definition polynomial.hh:17
│ │ │ │ -
auto forwardCapture(T &&t)
Create a capture object for perfect forwarding.
Definition utility.hh:376
│ │ │ │ +
Default implementation for derivative traits.
Definition defaultderivativetraits.hh:41
│ │ │ │ +
Concept objects that can be called with given argument list.
Definition functionconcepts.hh:37
│ │ │ │ +
auto require(F &&f) -> decltype(f(std::declval< Args >()...))
│ │ │ │ +
Definition functionconcepts.hh:70
│ │ │ │ +
auto require(F &&f) -> decltype(requireConvertible< Range >(f(std::declval< Domain >())))
│ │ │ │ +
Definition functionconcepts.hh:104
│ │ │ │ +
typename SignatureTraits< Range(Domain)>::template DerivativeSignature< DerivativeTraits > DerivativeSignature
Definition functionconcepts.hh:120
│ │ │ │ +
auto require(F &&f) -> decltype(derivative(f), requireConcept< Function< DerivativeSignature > >(derivative(f)))
│ │ │ │ +
Definition functionconcepts.hh:143
│ │ │ │ +
auto require(F &&f) -> decltype(f.bind(std::declval< LocalContext >()), f.unbind(), requireConvertible< bool >(f.bound()), f.localContext(), requireConvertible< LocalContext >(f.localContext()))
│ │ │ │ +
Definition functionconcepts.hh:176
│ │ │ │ +
auto require(F &&f) -> decltype(f.bind(std::declval< LocalContext >()), f.unbind(), f.localContext(), requireConvertible< LocalContext >(f.localContext()))
│ │ │ │ +
Concept for an entity set for a Concept::GridFunction<Range(Domain), EntitySet, DerivativeTraits>
Definition functionconcepts.hh:224
│ │ │ │ +
auto require(E &&f) -> decltype(requireType< typename E::Element >(), requireType< typename E::LocalCoordinate >(), requireType< typename E::GlobalCoordinate >())
│ │ │ │ +
Definition functionconcepts.hh:242
│ │ │ │ +
typename EntitySet::Element LocalContext
Definition functionconcepts.hh:258
│ │ │ │ +
Range(typename EntitySet::LocalCoordinate) LocalSignature
Definition functionconcepts.hh:257
│ │ │ │ +
auto require(F &&f) -> decltype(localFunction(f), f.entitySet(), requireConcept< LocalFunction< LocalSignature, LocalContext > >(localFunction(f)), requireConcept< Concept::EntitySet, EntitySet >(), requireConvertible< EntitySet >(f.entitySet()), requireConvertible< typename EntitySet::GlobalCoordinate, Domain >())
│ │ │ │ +
Definition functionconcepts.hh:279
│ │ │ │ +
typename Dune::Functions::LocalDerivativeTraits< EntitySet, DerivativeTraits >::template Traits< R > LocalDerivativeTraits
Definition functionconcepts.hh:304
│ │ │ │ +
auto require(F &&f) -> decltype(requireConcept< DifferentiableLocalFunction< LocalSignature, LocalContext, LocalDerivativeTraits > >(localFunction(f)))
│ │ │ │ +
Range(typename EntitySet::LocalCoordinate) LocalSignature
Definition functionconcepts.hh:300
│ │ │ │ +
typename EntitySet::Element LocalContext
Definition functionconcepts.hh:301
│ │ │ │ +
Definition functionconcepts.hh:321
│ │ │ │ +
auto require(F &&f) -> decltype(0)
│ │ │ │ +
Definition functionconcepts.hh:353
│ │ │ │ +
auto require(F &&f) -> decltype(0)
│ │ │ │ +
Helper class to deduce the signature of a callable.
Definition signature.hh:60
│ │ │ │ +
Definition signature.hh:106
│ │ │ │ +
Derivative traits for local functions.
Definition localderivativetraits.hh:32
│ │ │ │
1.9.8
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,92 +1,30 @@
│ │ │ │ │ dune-functions 2.10
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _f_u_n_c_t_i_o_n_s
│ │ │ │ │ - * _c_o_m_m_o_n
│ │ │ │ │ -_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s | _T_y_p_e_d_e_f_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ -utility.hh File Reference
│ │ │ │ │ -#include