differentiablefunction.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2021-2025 The Ikarus Developers mueller@ibb.uni-stuttgart.de
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
#include <tuple>
#include <type_traits>
 
#include <dune/common/hybridutilities.hh>
#include <dune/functions/common/differentiablefunctionfromcallables.hh>
 
#include <ikarus/utils/derivativetraits.hh>
#include <ikarus/utils/traits.hh>
 
namespace Ikarus {
 
namespace Impl {
 
  template <typename... Args>
  struct Functions
  {
    std::tuple<Args...> args;
  };
} // namespace Impl
 
template <typename... Args>
auto functions(Args&&... args) {
  return Impl::Functions<std::remove_cvref_t<Args>...>{std::forward_as_tuple(std::forward<Args>(args)...)};
}
 
#ifndef DOXYGEN
template <class Signature, template <class> class DerivativeTraits, class... F>
class DifferentiableFunction;
#endif
 
template <class Range, class D, template <class> class DerivativeTraits, class F, class... FF>
class DifferentiableFunction<Range(D), DerivativeTraits, F, FF...>
    : private Dune::Functions::DifferentiableFunctionFromCallables<Range(D), DerivativeTraits, F, FF...>
{
  using Base = Dune::Functions::DifferentiableFunctionFromCallables<Range(D), DerivativeTraits, F, FF...>;
 
public:
  using Domain                       = std::remove_cvref_t<D>;
  static constexpr auto nDerivatives = sizeof...(FF);
 
  template <class... FFF>
  DifferentiableFunction(FFF&&... f)
      : Base(std::forward<FFF>(f)...) {}
  using Traits = DerivativeTraitsFromCallables<Impl::Functions<F, FF...>, D>;
 
  using Derivative = DifferentiableFunction<typename Traits::template Range<1>(D), DerivativeTraits, FF...>;
 
  Range operator()(const D& x) const { return Base::operator()(x); }
 
  friend Derivative derivative(const DifferentiableFunction& t) {
    auto df = derivative(static_cast<const Base&>(t));
    return Derivative(df);
  }
};
 
template <typename... F, typename Arg>
auto makeDifferentiableFunction(const Impl::Functions<F...>& derivativesFunctions, const Arg& parameter) {
  DerivativeTraitsFromCallables t(derivativesFunctions, parameter);
  using DerivTraits = decltype(t);
  auto la           = []<typename... FF>(FF&&... f) {
    return Ikarus::DifferentiableFunction<typename DerivTraits::template Range<0>(typename DerivTraits::Domain),
                                                    DerivTraits::template DerivativeTraits, std::remove_cvref_t<FF>...>(
        std::forward<FF>(f)...);
  };
  return std::apply(la, derivativesFunctions.args);
}
 
} // namespace Ikarus