CompileTimeDerivativesMaterialInternal.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include <cstddef>
 
namespace CompileTimeDerivativesMaterialInternal
{
namespace details
{
 
template <std::size_t first, std::size_t second, std::size_t... tail>
constexpr bool
is_sorted()
{
  if constexpr (first <= second)
  {
    if constexpr (sizeof...(tail) == 0)
      return true;
    else
      return is_sorted<second, tail...>();
  }
  else
    return false;
}
 
template <std::size_t N>
constexpr std::size_t
factorial()
{
  if constexpr (N == 0)
    return 1;
  else if constexpr (N == 1)
    return 1;
  else
    return N * factorial<N - 1>();
}
 
template <std::size_t N, std::size_t M>
constexpr std::size_t
num_derivatives()
{
  return factorial<N + M - 1>() / (factorial<N>() * factorial<M - 1>());
}
 
template <std::size_t... first, std::size_t... second>
constexpr auto
merge(std::index_sequence<first...>, std::index_sequence<second...>)
{
  return std::index_sequence<first..., second...>{};
}
 
template <std::size_t Nmax, std::size_t first, std::size_t... tail>
constexpr auto
increment(std::index_sequence<first, tail...>)
{
  if constexpr (first + 1 == Nmax)
  {
    if constexpr (sizeof...(tail) == 0)
      return std::index_sequence<>{};
    else
      return merge(std::index_sequence<0>{}, increment<Nmax>(std::index_sequence<tail...>{}));
  }
  else
    return std::index_sequence<first + 1, tail...>{};
}
 
template <std::size_t M, std::size_t... N>
constexpr std::size_t
total_derivatives(std::index_sequence<N...>)
{
  return (num_derivatives<N, M>() + ...);
}
 
template <std::size_t... Ns>
constexpr auto
zeroes(std::index_sequence<Ns...>)
{
  return std::index_sequence<(void(Ns), 0)...>{};
}
 
} // namespace details
 
template <std::size_t first, std::size_t second, std::size_t... tail>
constexpr bool
is_sorted(std::index_sequence<first, second, tail...>)
{
  return details::is_sorted<first, second, tail...>();
}
 
template <std::size_t first>
constexpr bool
is_sorted(std::index_sequence<first>)
{
  return true;
}
 
template <std::size_t N, std::size_t M>
constexpr std::size_t
total_derivatives()
{
  // we compute derivatives of orders 0 up to and including N, and subtract 1 for
  // the 0th order derivative (underived original function)
  return details::total_derivatives<M>(std::make_index_sequence<N + 1>{}) - 1;
}
 
// shim for C++20 std::type_identity
template <class T>
struct type_identity
{
  using type = T;
};
 
template <typename T, std::size_t... Ns>
constexpr auto
make_tuple_array(std::index_sequence<Ns...>)
{
  // we cannot default construct the tuple, so we wrap it in the type_identity template
  return type_identity<std::tuple<CompileTimeDerivatives::CTArrayRef<Ns, T, unsigned int>...>>{};
}
 
template <std::size_t N>
constexpr auto
zeroes()
{
  return details::zeroes(std::make_index_sequence<N>{});
}
 
template <typename T, std::size_t first, std::size_t... tags>
auto
take_derivatives(const T & expression, std::index_sequence<first, tags...>)
{
  if constexpr (sizeof...(tags) == 0)
    return expression.template D<static_cast<CompileTimeDerivatives::CTTag>(first)>();
  else
    return take_derivatives(
        expression.template D<static_cast<CompileTimeDerivatives::CTTag>(first)>(),
        std::index_sequence<tags...>{});
}
 
} // namespace CompileTimeDerivativesMaterialInternal