tensor.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 1998 - 2025 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
 
#ifndef dealii_tensor_h
#define dealii_tensor_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/exceptions.h>
#include <deal.II/base/kokkos.h>
#include <deal.II/base/numbers.h>
#include <deal.II/base/table_indices.h>
#include <deal.II/base/template_constraints.h>
#include <deal.II/base/tensor_accessors.h>
 
#include <Kokkos_Array.hpp>
 
#ifdef DEAL_II_WITH_ADOLC
#  include <adolc/adouble.h> // Taped double
#endif
 
#include <cmath>
#include <complex>
#include <ostream>
#include <type_traits>
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declarations:
#ifndef DOXYGEN
template <typename ElementType, typename MemorySpace>
class ArrayView;
 
template <int dim, typename Number>
DEAL_II_CXX20_REQUIRES(dim >= 0)
class Point;
 
template <int rank_, int dim, typename Number = double>
class Tensor;
template <typename Number>
class Vector;
template <typename number>
class FullMatrix;
namespace Differentiation
{
  namespace SD
  {
    class Expression;
  }
} // namespace Differentiation
#endif
 

template <int dim, typename Number>
class Tensor<0, dim, Number>
{
public:
  static_assert(dim >= 0,
                "Tensors must have a dimension greater than or equal to one.");

  static constexpr unsigned int dimension = dim;

  static constexpr unsigned int rank = 0;

  static constexpr unsigned int n_independent_components = 1;

  using real_type = typename numbers::NumberTraits<Number>::real_type;

  using value_type = Number;

  using array_type = Number;

  constexpr DEAL_II_HOST_DEVICE
  Tensor();

  template <typename OtherNumber>
  constexpr DEAL_II_HOST_DEVICE
  Tensor(const Tensor<0, dim, OtherNumber> &initializer);

  template <typename OtherNumber>
  constexpr DEAL_II_HOST_DEVICE
  Tensor(const OtherNumber &initializer);
 
#ifdef DEAL_II_DELETED_MOVE_CONSTRUCTOR_BUG
  constexpr DEAL_II_HOST_DEVICE
  Tensor(const Tensor<0, dim, Number> &other);

  constexpr DEAL_II_HOST_DEVICE
  Tensor(Tensor<0, dim, Number> &&other) noexcept;
#endif

  constexpr DEAL_II_HOST_DEVICE
  operator Number &();

  constexpr DEAL_II_HOST_DEVICE operator const Number &() const;

  template <typename OtherNumber>
  constexpr DEAL_II_HOST_DEVICE Tensor &
  operator=(const Tensor<0, dim, OtherNumber> &rhs);
 
#if defined(__INTEL_COMPILER) || defined(DEAL_II_DELETED_MOVE_CONSTRUCTOR_BUG)
  constexpr DEAL_II_HOST_DEVICE Tensor &
  operator=(const Tensor<0, dim, Number> &rhs);
#endif
 
#ifdef DEAL_II_DELETED_MOVE_CONSTRUCTOR_BUG
  constexpr DEAL_II_HOST_DEVICE Tensor<0, dim, Number> &
  operator=(Tensor<0, dim, Number> &&other) noexcept;
#endif

  template <typename OtherNumber>
  constexpr DEAL_II_HOST_DEVICE Tensor &
  operator=(const OtherNumber &d) &;

  template <typename OtherNumber>
  constexpr DEAL_II_HOST_DEVICE Tensor &
  operator=(const OtherNumber &d) && = delete;

  template <typename OtherNumber>
  constexpr bool
  operator==(const Tensor<0, dim, OtherNumber> &rhs) const;

  template <typename OtherNumber>
  constexpr bool
  operator!=(const Tensor<0, dim, OtherNumber> &rhs) const;

  template <typename OtherNumber>
  constexpr DEAL_II_HOST_DEVICE Tensor &
  operator+=(const Tensor<0, dim, OtherNumber> &rhs);

  template <typename OtherNumber>
  constexpr DEAL_II_HOST_DEVICE Tensor &
  operator-=(const Tensor<0, dim, OtherNumber> &rhs);

  template <typename OtherNumber>
  constexpr DEAL_II_HOST_DEVICE Tensor &
  operator*=(const OtherNumber &factor);

  template <typename OtherNumber>
  constexpr DEAL_II_HOST_DEVICE Tensor &
  operator/=(const OtherNumber &factor);

  constexpr DEAL_II_HOST_DEVICE Tensor
  operator-() const;

  constexpr void
  clear();

  real_type
  norm() const;

  constexpr DEAL_II_HOST_DEVICE real_type
  norm_square() const;

  template <class Iterator>
  void
  unroll(const Iterator begin, const Iterator end) const;

  template <class Archive>
  void
  serialize(Archive &ar, const unsigned int version);

  using tensor_type = Number;
 
private:
  Number value;
 
  // Allow an arbitrary Tensor to access the underlying values.
  template <int, int, typename>
  friend class Tensor;
};
 
 

template <int rank_, int dim, typename Number>
class Tensor
{
public:
  static_assert(rank_ >= 1,
                "Tensors must have a rank greater than or equal to one.");
  static_assert(dim >= 0,
                "Tensors must have a dimension greater than or equal to zero.");
  static constexpr unsigned int dimension = dim;

  static constexpr unsigned int rank = rank_;

  static constexpr unsigned int n_independent_components =
    Tensor<rank_ - 1, dim>::n_independent_components * dim;

  using value_type =
    std::conditional_t<rank_ == 1, Number, Tensor<rank_ - 1, dim, Number>>;

  using array_type = std::conditional_t<
    rank_ == 1,
    Number[(dim != 0) ? dim : 1],
    typename Tensor<rank_ - 1, dim, Number>::array_type[(dim != 0) ? dim : 1]>;

  constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE
  Tensor();

  constexpr DEAL_II_HOST_DEVICE explicit Tensor(const array_type &initializer);

  template <typename ElementType, typename MemorySpace>
  constexpr DEAL_II_HOST_DEVICE explicit Tensor(
    const ArrayView<ElementType, MemorySpace> &initializer);

  template <typename OtherNumber>
  constexpr DEAL_II_HOST_DEVICE
  Tensor(const Tensor<rank_, dim, OtherNumber> &initializer);

  template <typename OtherNumber>
  constexpr Tensor(
    const Tensor<1, dim, Tensor<rank_ - 1, dim, OtherNumber>> &initializer);

  template <typename OtherNumber>
  constexpr
  operator Tensor<1, dim, Tensor<rank_ - 1, dim, OtherNumber>>() const;
 
#ifdef DEAL_II_DELETED_MOVE_CONSTRUCTOR_BUG
  constexpr Tensor(const Tensor<rank_, dim, Number> &);

  constexpr Tensor(Tensor<rank_, dim, Number> &&) noexcept;
#endif

  constexpr DEAL_II_HOST_DEVICE value_type &
  operator[](const unsigned int i);

  constexpr DEAL_II_HOST_DEVICE const value_type &
  operator[](const unsigned int i) const;

  constexpr const Number &
  operator[](const TableIndices<rank_> &indices) const;

  constexpr Number &
  operator[](const TableIndices<rank_> &indices);

  DEAL_II_DEPRECATED
  Number *
  begin_raw();

  DEAL_II_DEPRECATED
  const Number *
  begin_raw() const;

  DEAL_II_DEPRECATED
  Number *
  end_raw();

  DEAL_II_DEPRECATED
  const Number *
  end_raw() const;

  template <typename OtherNumber>
  constexpr DEAL_II_HOST_DEVICE Tensor &
  operator=(const Tensor<rank_, dim, OtherNumber> &rhs);

  constexpr DEAL_II_HOST_DEVICE Tensor &
  operator=(const Number &d) &;

  constexpr DEAL_II_HOST_DEVICE Tensor &
  operator=(const Number &d) && = delete;
 
#ifdef DEAL_II_DELETED_MOVE_CONSTRUCTOR_BUG
  constexpr Tensor<rank_, dim, Number> &
  operator=(const Tensor<rank_, dim, Number> &);

  constexpr Tensor<rank_, dim, Number> &
  operator=(Tensor<rank_, dim, Number> &&) noexcept;
#endif

  template <typename OtherNumber>
  constexpr bool
  operator==(const Tensor<rank_, dim, OtherNumber> &) const;

  template <typename OtherNumber>
  constexpr bool
  operator!=(const Tensor<rank_, dim, OtherNumber> &) const;

  template <typename OtherNumber>
  constexpr DEAL_II_HOST_DEVICE Tensor &
  operator+=(const Tensor<rank_, dim, OtherNumber> &);

  template <typename OtherNumber>
  constexpr DEAL_II_HOST_DEVICE Tensor &
  operator-=(const Tensor<rank_, dim, OtherNumber> &);

  template <typename OtherNumber>
  constexpr DEAL_II_HOST_DEVICE Tensor &
  operator*=(const OtherNumber &factor);

  template <typename OtherNumber>
  constexpr DEAL_II_HOST_DEVICE Tensor &
  operator/=(const OtherNumber &factor);

  constexpr DEAL_II_HOST_DEVICE Tensor
  operator-() const;

  constexpr void
  clear();

  DEAL_II_HOST_DEVICE
  typename numbers::NumberTraits<Number>::real_type
  norm() const;

  constexpr DEAL_II_HOST_DEVICE
    typename numbers::NumberTraits<Number>::real_type
    norm_square() const;

  template <class Iterator>
  void
  unroll(const Iterator begin, const Iterator end) const;

  static constexpr DEAL_II_HOST_DEVICE unsigned int
  component_to_unrolled_index(const TableIndices<rank_> &indices);

  static constexpr DEAL_II_HOST_DEVICE TableIndices<rank_>
  unrolled_to_component_indices(const unsigned int i);

  static constexpr std::size_t
  memory_consumption();

  template <class Archive>
  void
  serialize(Archive &ar, const unsigned int version);

  using tensor_type = Tensor<rank_, dim, Number>;
 
private:
#if DEAL_II_KOKKOS_VERSION_GTE(3, 7, 0)
  std::conditional_t<rank_ == 1,
                     Kokkos::Array<Number, dim>,
                     Kokkos::Array<Tensor<rank_ - 1, dim, Number>, dim>>
#else
  std::conditional_t<rank_ == 1,
                     std::array<Number, dim>,
                     std::array<Tensor<rank_ - 1, dim, Number>, dim>>
#endif
    values;

  template <typename ArrayLike, std::size_t... Indices>
  constexpr DEAL_II_HOST_DEVICE
  Tensor(const ArrayLike &initializer, std::index_sequence<Indices...>);
 
  // Allow an arbitrary Tensor to access the underlying values.
  template <int, int, typename>
  friend class Tensor;
 
  // Point is allowed access to the coordinates. This is supposed to improve
  // speed.
  friend class Point<dim, Number>;
};
 
 
#ifndef DOXYGEN
namespace internal
{
  // Workaround: The following 4 overloads are necessary to be able to
  // compile the library with Apple Clang 8 and older. We should remove
  // these overloads again when we bump the minimal required version to
  // something later than clang-3.6 / Apple Clang 6.3.
  template <int rank, int dim, typename T, typename U>
  struct ProductTypeImpl<Tensor<rank, dim, T>, std::complex<U>>
  {
    using type =
      Tensor<rank, dim, std::complex<typename ProductType<T, U>::type>>;
  };
 
  template <int rank, int dim, typename T, typename U>
  struct ProductTypeImpl<Tensor<rank, dim, std::complex<T>>, std::complex<U>>
  {
    using type =
      Tensor<rank, dim, std::complex<typename ProductType<T, U>::type>>;
  };
 
  template <typename T, int rank, int dim, typename U>
  struct ProductTypeImpl<std::complex<T>, Tensor<rank, dim, U>>
  {
    using type =
      Tensor<rank, dim, std::complex<typename ProductType<T, U>::type>>;
  };
 
  template <int rank, int dim, typename T, typename U>
  struct ProductTypeImpl<std::complex<T>, Tensor<rank, dim, std::complex<U>>>
  {
    using type =
      Tensor<rank, dim, std::complex<typename ProductType<T, U>::type>>;
  };
  // end workaround

  template <int rank, int dim, typename T>
  struct NumberType<Tensor<rank, dim, T>>
  {
    static constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE const
      Tensor<rank, dim, T> &
      value(const Tensor<rank, dim, T> &t)
    {
      return t;
    }
 
    static constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE Tensor<rank, dim, T>
                                                       value(const T &t)
    {
      Tensor<rank, dim, T> tmp;
      tmp = t;
      return tmp;
    }
  };
} // namespace internal
 
 
/*---------------------- Inline functions: Tensor<0,dim> ---------------------*/
 
 
template <int dim, typename Number>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE
Tensor<0, dim, Number>::Tensor()
  // Some auto-differentiable numbers need explicit
  // zero initialization such as adtl::adouble.
  : Tensor{0.0}
{}
 
 
 
template <int dim, typename Number>
template <typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE
Tensor<0, dim, Number>::Tensor(const OtherNumber &initializer)
  : value(internal::NumberType<Number>::value(initializer))
{}
 
 
 
template <int dim, typename Number>
template <typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE
Tensor<0, dim, Number>::Tensor(const Tensor<0, dim, OtherNumber> &p)
  : Tensor{p.value}
{}
 
 
#  ifdef DEAL_II_DELETED_MOVE_CONSTRUCTOR_BUG
template <int dim, typename Number>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE
Tensor<0, dim, Number>::Tensor(const Tensor<0, dim, Number> &other)
  : value{other.value}
{}
 
 
 
template <int dim, typename Number>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE
Tensor<0, dim, Number>::Tensor(Tensor<0, dim, Number> &&other) noexcept
  : value{std::move(other.value)}
{}
#  endif
 
 
 
template <int dim, typename Number>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE
Tensor<0, dim, Number>::operator Number &()
{
  Assert(dim != 0,
         ExcMessage("Cannot access an object of type Tensor<0,0,Number>"));
  return value;
}
 
 
template <int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE
  DEAL_II_HOST_DEVICE Tensor<0, dim, Number>::operator const Number &() const
{
  Assert(dim != 0,
         ExcMessage("Cannot access an object of type Tensor<0,0,Number>"));
  return value;
}
 
 
 
template <int dim, typename Number>
template <typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE Tensor<0, dim, Number> &
Tensor<0, dim, Number>::operator=(const Tensor<0, dim, OtherNumber> &p)
{
  value = internal::NumberType<Number>::value(p.value);
  return *this;
}
 
 
#  if defined(__INTEL_COMPILER) || defined(DEAL_II_DELETED_MOVE_CONSTRUCTOR_BUG)
template <int dim, typename Number>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE Tensor<0, dim, Number> &
Tensor<0, dim, Number>::operator=(const Tensor<0, dim, Number> &p)
{
  value = p.value;
  return *this;
}
#  endif
 
#  ifdef DEAL_II_DELETED_MOVE_CONSTRUCTOR_BUG
template <int dim, typename Number>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE Tensor<0, dim, Number> &
Tensor<0, dim, Number>::operator=(Tensor<0, dim, Number> &&other) noexcept
{
  value = std::move(other.value);
  return *this;
}
#  endif
 
 
 
template <int dim, typename Number>
template <typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE Tensor<0, dim, Number> &
Tensor<0, dim, Number>::operator=(const OtherNumber &d) &
{
  value = internal::NumberType<Number>::value(d);
  return *this;
}
 
 
template <int dim, typename Number>
template <typename OtherNumber>
constexpr inline bool
Tensor<0, dim, Number>::operator==(const Tensor<0, dim, OtherNumber> &p) const
{
#  ifdef DEAL_II_ADOLC_WITH_ADVANCED_BRANCHING
  Assert(!(std::is_same_v<Number, adouble> ||
           std::is_same_v<OtherNumber, adouble>),
         ExcMessage(
           "The Tensor equality operator for ADOL-C taped numbers has not yet "
           "been extended to support advanced branching."));
#  endif
 
  return numbers::values_are_equal(value, p.value);
}
 
 
template <int dim, typename Number>
template <typename OtherNumber>
constexpr bool
Tensor<0, dim, Number>::operator!=(const Tensor<0, dim, OtherNumber> &p) const
{
  return !((*this) == p);
}
 
 
template <int dim, typename Number>
template <typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE Tensor<0, dim, Number> &
Tensor<0, dim, Number>::operator+=(const Tensor<0, dim, OtherNumber> &p)
{
  value += p.value;
  return *this;
}
 
 
template <int dim, typename Number>
template <typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE Tensor<0, dim, Number> &
Tensor<0, dim, Number>::operator-=(const Tensor<0, dim, OtherNumber> &p)
{
  value -= p.value;
  return *this;
}
 
 
 
namespace internal
{
  namespace ComplexWorkaround
  {
    template <typename Number, typename OtherNumber>
    constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE void
    multiply_assign_scalar(Number &val, const OtherNumber &s)
    {
      val *= s;
    }
 
    template <typename Number, typename OtherNumber>
    constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE void
    multiply_assign_scalar(std::complex<Number> &val, const OtherNumber &s)
    {
#  if DEAL_II_KOKKOS_VERSION_GTE(3, 6, 0)
      KOKKOS_IF_ON_HOST((val *= s;))
      KOKKOS_IF_ON_DEVICE(({
        (void)val;
        (void)s;
        Kokkos::abort(
          "This function is not implemented for std::complex<Number>!\n");
      }))
#  else
#    ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
      val *= s;
#    else
      (void)val;
      (void)s;
      Kokkos::abort(
        "This function is not implemented for std::complex<Number>!\n");
#    endif
#  endif
    }
  } // namespace ComplexWorkaround
} // namespace internal
 
 
template <int dim, typename Number>
template <typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE Tensor<0, dim, Number> &
Tensor<0, dim, Number>::operator*=(const OtherNumber &s)
{
  internal::ComplexWorkaround::multiply_assign_scalar(value, s);
  return *this;
}
 
 
 
template <int dim, typename Number>
template <typename OtherNumber>
constexpr inline DEAL_II_HOST_DEVICE Tensor<0, dim, Number> &
Tensor<0, dim, Number>::operator/=(const OtherNumber &s)
{
  value /= s;
  return *this;
}
 
 
template <int dim, typename Number>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE Tensor<0, dim, Number>
Tensor<0, dim, Number>::operator-() const
{
  return -value;
}
 
 
template <int dim, typename Number>
inline DEAL_II_ALWAYS_INLINE typename Tensor<0, dim, Number>::real_type
Tensor<0, dim, Number>::norm() const
{
  Assert(dim != 0,
         ExcMessage("Cannot access an object of type Tensor<0,0,Number>"));
  return numbers::NumberTraits<Number>::abs(value);
}
 
 
template <int dim, typename Number>
constexpr DEAL_II_HOST_DEVICE inline DEAL_II_ALWAYS_INLINE
  typename Tensor<0, dim, Number>::real_type
  Tensor<0, dim, Number>::norm_square() const
{
  Assert(dim != 0,
         ExcMessage("Cannot access an object of type Tensor<0,0,Number>"));
  return numbers::NumberTraits<Number>::abs_square(value);
}
 
 
 
template <int dim, typename Number>
constexpr inline void
Tensor<0, dim, Number>::clear()
{
  // Some auto-differentiable numbers need explicit
  // zero initialization.
  value = internal::NumberType<Number>::value(0.0);
}
 
 
 
template <int dim, typename Number>
template <class Iterator>
inline void
Tensor<0, dim, Number>::unroll(const Iterator begin, const Iterator end) const
{
  AssertDimension(std::distance(begin, end), n_independent_components);
  Assert(dim != 0,
         ExcMessage("Cannot unroll an object of type Tensor<0,0,Number>"));
  Assert(std::distance(begin, end) >= 1,
         ExcMessage("The provided iterator range must contain at least one "
                    "element."));
  *begin = value;
}
 
 
 
template <int dim, typename Number>
template <class Archive>
inline void
Tensor<0, dim, Number>::serialize(Archive &ar, const unsigned int)
{
  ar &value;
}
 
 
template <int dim, typename Number>
constexpr unsigned int Tensor<0, dim, Number>::n_independent_components;
 
 
/*-------------------- Inline functions: Tensor<rank,dim> --------------------*/
 
template <int rank_, int dim, typename Number>
template <typename ArrayLike, std::size_t... indices>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE
Tensor<rank_, dim, Number>::Tensor(const ArrayLike &initializer,
                                   std::index_sequence<indices...>)
  // Extract from the 'initializer' a sequence of elements via template
  // pack evaluation. This could be as easy as
  //     values{{ (initializer[indices])... }}
  // but of course in practice it is not. The challenge is that if rank>1,
  // we want to pass the elements initializer[indices] down to the next
  // lower rank tensor for evaluation unchanged. But at the rank==1 level,
  // we need to convert to the scalar type 'Number'. This would all be
  // relatively straightforward if we could rely on automatic type
  // conversion, but for some autodifferentiation types, the conversion
  // from the AD to double (i.e., the extraction of a scalar value) is
  // not implicit, and we need to call internal::NumberType<Number>::value() --
  // but as mentioned, we can only do that for rank==1.
  //
  // We can achieve all of this by dispatching to a lambda function within
  // which we can use a 'if constexpr'.
  : values{{([&initializer]() -> value_type {
    if constexpr (rank_ == 1)
      return internal::NumberType<Number>::value(initializer[indices]);
    else
      return value_type(initializer[indices]);
  }())...}}
{
  static_assert(sizeof...(indices) == dim,
                "dim should match the number of indices");
}
 
 
#  if defined(DEAL_II_HAVE_CXX20) && !defined(__NVCC__)
 
template <int rank_, int dim, typename Number>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE
Tensor<rank_, dim, Number>::Tensor()
  : values(
      // In order to initialize the Kokkos::Array<Number,dim>, we would need a
      // brace-enclosed list of length 'dim'. There is no way in C++ to create
      // such a list in-place, but we can come up with a lambda function that
      // expands such a list via template-pack expansion, and then uses this
      // list to initialize a Kokkos::Array which it then returns.
      //
      // The trick to come up with such a lambda function is to have a function
      // that takes an argument that depends on a template-pack of integers.
      // We will call the function with an integer list of length 'dim', and
      // in the function itself expand that pack in a way that it serves as
      // a brace-enclosed list of initializers for a Kokkos::Array.
      //
      // Of course, we do not want to initialize the array with the integers,
      // but with  zeros. (Or, more correctly, a zero of the element type.)
      // The canonical way to do this would be using the comma operator:
      //     (sequence_element, 0.0)
      // returns zero, and
      //     (sequence, 0.0)...
      // returns a list of zeros of the right length. Unfortunately, some
      // compilers then warn that the left side of the comma expression has
      // no effect -- well, bummer, that was of course exactly the idea.
      // We could work around this by using
      //     (sequence_element * 0.0)
      // instead, assuming that the compiler will optimize (known) integer
      // times zero to zero, and similarly for (known) integer times times
      // default-initialized tensor.
      //
      // But, instead of relying on compiler optimizations, a better way is
      // to simply have another (nested) lambda function that takes the
      // integer sequence element as an argument and ignores it, just
      // returning a zero instead.
      []<std::size_t... I>(
        const std::index_sequence<I...> &) constexpr -> decltype(values) {
        if constexpr (dim == 0)
          {
            return {};
          }
        else if constexpr (rank_ == 1)
          {
            auto get_zero_and_ignore_argument = [](int) {
              return internal::NumberType<Number>::value(0.0);
            };
            return {{(get_zero_and_ignore_argument(I))...}};
          }
        else
          {
            auto get_zero_and_ignore_argument = [](int) {
              return Tensor<rank_ - 1, dim, Number>();
            };
            return {{(get_zero_and_ignore_argument(I))...}};
          }
      }(std::make_index_sequence<dim>()))
{}
 
#  else
 
// The C++17 case works in essence the same, except that we can't use a
// lambda function with explicit template parameters, i.e., we can't do
//   []<std::size_t... I>(const std::index_sequence<I...> &)
// as above because that's a C++20 feature. Lambda functions in C++17 can
// have template packs as arguments, but we need the ability to *name*
// that template pack (the 'I' above) and that's not possible in C++17.
//
// We work around this by moving the lambda function to a global function
// and using the traditional template syntax on it.
namespace internal
{
  namespace TensorInitialization
  {
    template <int rank, int dim, typename Number, std::size_t... I>
#    if DEAL_II_KOKKOS_VERSION_GTE(3, 7, 0)
    constexpr Kokkos::Array<typename Tensor<rank, dim, Number>::value_type, dim>
#    else
    constexpr std::array<typename Tensor<rank, dim, Number>::value_type, dim>
#    endif
    make_zero_array(const std::index_sequence<I...> &)
    {
      static_assert(sizeof...(I) == dim, "This is bad.");
 
      // First peel off the case dim==0. If we don't, some compilers
      // will warn below that we define these lambda functions but
      // never use them (because the expanded list has zero elements,
      // and the get_zero_and_ignore_argument() function is not used...)
      if constexpr (dim == 0)
        {
          return {};
        }
      else if constexpr (rank == 1)
        {
          auto get_zero_and_ignore_argument = [](int) {
            return internal::NumberType<Number>::value(0.0);
          };
          return {{(get_zero_and_ignore_argument(I))...}};
        }
      else
        {
          auto get_zero_and_ignore_argument = [](int) {
            return Tensor<rank - 1, dim, Number>();
          };
          return {{(get_zero_and_ignore_argument(I))...}};
        }
    }
  } // namespace TensorInitialization
} // namespace internal
 
 
template <int rank_, int dim, typename Number>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE
Tensor<rank_, dim, Number>::Tensor()
  : values(internal::TensorInitialization::make_zero_array<rank_, dim, Number>(
      std::make_index_sequence<dim>()))
{}
 
 
#  endif
 
 
template <int rank_, int dim, typename Number>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE
Tensor<rank_, dim, Number>::Tensor(const array_type &initializer)
  : Tensor(initializer, std::make_index_sequence<dim>{})
{}
 
 
 
template <int rank_, int dim, typename Number>
template <typename ElementType, typename MemorySpace>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE
Tensor<rank_, dim, Number>::Tensor(
  const ArrayView<ElementType, MemorySpace> &initializer)
{
  // make nvcc happy
  const int my_n_independent_components = n_independent_components;
  AssertDimension(initializer.size(), my_n_independent_components);
 
  for (unsigned int i = 0; i < my_n_independent_components; ++i)
    (*this)[unrolled_to_component_indices(i)] = initializer[i];
}
 
 
 
template <int rank_, int dim, typename Number>
template <typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE
Tensor<rank_, dim, Number>::Tensor(
  const Tensor<rank_, dim, OtherNumber> &initializer)
  : Tensor(initializer, std::make_index_sequence<dim>{})
{}
 
 
 
template <int rank_, int dim, typename Number>
template <typename OtherNumber>
constexpr DEAL_II_ALWAYS_INLINE
Tensor<rank_, dim, Number>::Tensor(
  const Tensor<1, dim, Tensor<rank_ - 1, dim, OtherNumber>> &initializer)
  : Tensor(initializer, std::make_index_sequence<dim>{})
{}
 
 
 
template <int rank_, int dim, typename Number>
template <typename OtherNumber>
constexpr DEAL_II_ALWAYS_INLINE Tensor<rank_, dim, Number>::
operator Tensor<1, dim, Tensor<rank_ - 1, dim, OtherNumber>>() const
{
  Tensor<1, dim, Tensor<rank_ - 1, dim, OtherNumber>> x;
  std::copy(values.data(), values.data() + values.size(), x.values.data());
  return x;
}
 
 
#  ifdef DEAL_II_DELETED_MOVE_CONSTRUCTOR_BUG
template <int rank_, int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE
Tensor<rank_, dim, Number>::Tensor(const Tensor<rank_, dim, Number> &other)
  : values(other.values)
{}
 
 
 
template <int rank_, int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE
Tensor<rank_, dim, Number>::Tensor(Tensor<rank_, dim, Number> &&other) noexcept
  : values(std::move(other.values))
{}
#  endif
 
 
 
template <int rank_, int dim, typename Number>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE
  typename Tensor<rank_, dim, Number>::value_type &
  Tensor<rank_, dim, Number>::operator[](const unsigned int i)
{
  Assert(dim != 0,
         ExcMessage("Cannot access an object of type Tensor<rank_,0,Number>"));
  AssertIndexRange(i, dim);
  DEAL_II_CXX23_ASSUME(i < dim);
 
  return values[i];
}
 
 
template <int rank_, int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE
  DEAL_II_HOST_DEVICE const typename Tensor<rank_, dim, Number>::value_type &
  Tensor<rank_, dim, Number>::operator[](const unsigned int i) const
{
  Assert(dim != 0,
         ExcMessage("Cannot access an object of type Tensor<rank_,0,Number>"));
  AssertIndexRange(i, dim);
  DEAL_II_CXX23_ASSUME(i < dim);
 
  return values[i];
}
 
 
template <int rank_, int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE const Number &
Tensor<rank_, dim, Number>::operator[](const TableIndices<rank_> &indices) const
{
  Assert(dim != 0,
         ExcMessage("Cannot access an object of type Tensor<rank_,0,Number>"));
 
  return TensorAccessors::extract<rank_>(*this, indices);
}
 
 
 
template <int rank_, int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE Number &
Tensor<rank_, dim, Number>::operator[](const TableIndices<rank_> &indices)
{
  Assert(dim != 0,
         ExcMessage("Cannot access an object of type Tensor<rank_,0,Number>"));
 
  return TensorAccessors::extract<rank_>(*this, indices);
}
 
 
 
template <int rank_, int dim, typename Number>
inline Number *
Tensor<rank_, dim, Number>::begin_raw()
{
  static_assert(rank_ == 1,
                "This function is only available for rank-1 tensors "
                "because higher-rank tensors may not store their elements "
                "in a contiguous array.");
 
  return std::addressof(
    this->operator[](this->unrolled_to_component_indices(0)));
}
 
 
 
template <int rank_, int dim, typename Number>
inline const Number *
Tensor<rank_, dim, Number>::begin_raw() const
{
  static_assert(rank_ == 1,
                "This function is only available for rank-1 tensors "
                "because higher-rank tensors may not store their elements "
                "in a contiguous array.");
 
  return std::addressof(
    this->operator[](this->unrolled_to_component_indices(0)));
}
 
 
 
template <int rank_, int dim, typename Number>
inline Number *
Tensor<rank_, dim, Number>::end_raw()
{
  static_assert(rank_ == 1,
                "This function is only available for rank-1 tensors "
                "because higher-rank tensors may not store their elements "
                "in a contiguous array.");
 
  return begin_raw() + n_independent_components;
}
 
 
 
template <int rank_, int dim, typename Number>
inline const Number *
Tensor<rank_, dim, Number>::end_raw() const
{
  static_assert(rank_ == 1,
                "This function is only available for rank-1 tensors "
                "because higher-rank tensors may not store their elements "
                "in a contiguous array.");
 
  return begin_raw() + n_independent_components;
}
 
 
 
template <int rank_, int dim, typename Number>
template <typename OtherNumber>
constexpr inline DEAL_II_ALWAYS_INLINE Tensor<rank_, dim, Number> &
Tensor<rank_, dim, Number>::operator=(const Tensor<rank_, dim, OtherNumber> &t)
{
  // The following loop could be written more concisely using std::copy, but
  // that function is only constexpr from C++20 on.
  for (unsigned int i = 0; i < dim; ++i)
    values[i] = t.values[i];
  return *this;
}
 
 
 
template <int rank_, int dim, typename Number>
constexpr DEAL_II_HOST_DEVICE inline DEAL_II_ALWAYS_INLINE
  Tensor<rank_, dim, Number> &
  Tensor<rank_, dim, Number>::operator=(const Number &d) &
{
  Assert(numbers::value_is_zero(d), ExcScalarAssignmentOnlyForZeroValue());
 
  for (unsigned int i = 0; i < dim; ++i)
    values[i] = internal::NumberType<Number>::value(0.0);
  return *this;
}
 
 
#  ifdef DEAL_II_DELETED_MOVE_CONSTRUCTOR_BUG
template <int rank_, int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE Tensor<rank_, dim, Number> &
Tensor<rank_, dim, Number>::operator=(const Tensor<rank_, dim, Number> &other)
{
  for (unsigned int i = 0; i < dim; ++i)
    values[i] = other.values[i];
  return *this;
}
 
 
 
template <int rank_, int dim, typename Number>
constexpr DEAL_II_ALWAYS_INLINE Tensor<rank_, dim, Number>                                 &
Tensor<rank_, dim, Number>::operator=(
  Tensor<rank_, dim, Number> &&other) noexcept
{
  for (unsigned int i = 0; i < dim; ++i)
    values[i] = other.values[i];
  return *this;
}
#  endif
 
 
template <int rank_, int dim, typename Number>
template <typename OtherNumber>
constexpr inline bool
Tensor<rank_, dim, Number>::operator==(
  const Tensor<rank_, dim, OtherNumber> &p) const
{
#  ifdef DEAL_II_ADOLC_WITH_ADVANCED_BRANCHING
  Assert(!(std::is_same_v<Number, adouble> ||
           std::is_same_v<OtherNumber, adouble>),
         ExcMessage(
           "The Tensor equality operator for ADOL-C taped numbers has not yet "
           "been extended to support advanced branching."));
#  endif
 
  for (unsigned int i = 0; i < dim; ++i)
    if (numbers::values_are_not_equal(values[i], p.values[i]))
      return false;
  return true;
}
 
 
// At some places in the library, we have Point<0> for formal reasons
// (e.g., we sometimes have Quadrature<dim-1> for faces, so we have
// Quadrature<0> for dim=1, and then we have Point<0>). To avoid warnings
// in the above function that the loop end check always fails, we
// implement this function here
template <>
template <>
constexpr inline bool
Tensor<1, 0, double>::operator==(const Tensor<1, 0, double> &) const
{
  return true;
}
 
 
template <int rank_, int dim, typename Number>
template <typename OtherNumber>
constexpr bool
Tensor<rank_, dim, Number>::operator!=(
  const Tensor<rank_, dim, OtherNumber> &p) const
{
  return !((*this) == p);
}
 
 
template <int rank_, int dim, typename Number>
template <typename OtherNumber>
constexpr inline DEAL_II_ALWAYS_INLINE
  DEAL_II_HOST_DEVICE Tensor<rank_, dim, Number>                     &
  Tensor<rank_, dim, Number>::operator+=(
    const Tensor<rank_, dim, OtherNumber> &p)
{
  for (unsigned int i = 0; i < dim; ++i)
    values[i] += p.values[i];
  return *this;
}
 
 
template <int rank_, int dim, typename Number>
template <typename OtherNumber>
constexpr inline DEAL_II_ALWAYS_INLINE
  DEAL_II_HOST_DEVICE Tensor<rank_, dim, Number>                     &
  Tensor<rank_, dim, Number>::operator-=(
    const Tensor<rank_, dim, OtherNumber> &p)
{
  for (unsigned int i = 0; i < dim; ++i)
    values[i] -= p.values[i];
  return *this;
}
 
 
template <int rank_, int dim, typename Number>
template <typename OtherNumber>
constexpr inline DEAL_II_ALWAYS_INLINE
  DEAL_II_HOST_DEVICE Tensor<rank_, dim, Number> &
  Tensor<rank_, dim, Number>::operator*=(const OtherNumber &s)
{
  for (unsigned int i = 0; i < dim; ++i)
    values[i] *= s;
  return *this;
}
 
 
 
template <int rank_, int dim, typename Number>
template <typename OtherNumber>
constexpr inline DEAL_II_ALWAYS_INLINE
  DEAL_II_HOST_DEVICE Tensor<rank_, dim, Number> &
  Tensor<rank_, dim, Number>::operator/=(const OtherNumber &s)
{
  if constexpr (std::is_integral_v<
                  typename ProductType<Number, OtherNumber>::type> ||
                std::is_same_v<Number, Differentiation::SD::Expression>)
    {
      // recurse over the base objects
      for (unsigned int d = 0; d < dim; ++d)
        values[d] /= s;
    }
  else
    {
      // If we can, avoid division by multiplying by the inverse of the given
      // factor:
      const Number inverse_factor = Number(1.) / s;
      for (unsigned int d = 0; d < dim; ++d)
        values[d] *= inverse_factor;
    }
 
  return *this;
}
 
 
template <int rank_, int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE
  DEAL_II_HOST_DEVICE Tensor<rank_, dim, Number>
                      Tensor<rank_, dim, Number>::operator-() const
{
  Tensor<rank_, dim, Number> tmp;
 
  for (unsigned int i = 0; i < dim; ++i)
    tmp.values[i] = -values[i];
 
  return tmp;
}
 
 
template <int rank_, int dim, typename Number>
inline DEAL_II_HOST_DEVICE typename numbers::NumberTraits<Number>::real_type
Tensor<rank_, dim, Number>::norm() const
{
  // Handle cases of a tensor consisting of just one number more
  // efficiently:
  if constexpr ((rank_ == 1) && (dim == 1) && std::is_arithmetic_v<Number>)
    {
      return std::abs(values[0]);
    }
  else if constexpr ((rank_ == 2) && (dim == 1) && std::is_arithmetic_v<Number>)
    {
      return std::abs(values[0][0]);
    }
  else
    {
      // Otherwise fall back to the naive algorithm of taking the square root of
      // the sum of squares.
 
      // Make things work with AD types by letting the compiler look up
      // the symbol sqrt in namespace std and in the type-associated
      // namespaces
      using std::sqrt;
      return sqrt(norm_square());
    }
}
 
 
template <int rank_, int dim, typename Number>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE
  typename numbers::NumberTraits<Number>::real_type
  Tensor<rank_, dim, Number>::norm_square() const
{
  if constexpr (dim == 0)
    return internal::NumberType<
      typename numbers::NumberTraits<Number>::real_type>::value(0.0);
  else if constexpr (rank_ == 1)
    {
      // For rank-1 tensors, the square of the norm is simply the sum of
      // squares of the elements:
      typename numbers::NumberTraits<Number>::real_type s =
        numbers::NumberTraits<Number>::abs_square(values[0]);
      for (unsigned int i = 1; i < dim; ++i)
        s += numbers::NumberTraits<Number>::abs_square(values[i]);
 
      return s;
    }
  else
    {
      // For higher-rank tensors, the square of the norm is the sum
      // of squares of sub-tensors
      typename numbers::NumberTraits<Number>::real_type s =
        values[0].norm_square();
      for (unsigned int i = 1; i < dim; ++i)
        s += values[i].norm_square();
 
      return s;
    }
}
 
 
 
template <int rank_, int dim, typename Number>
template <class Iterator>
inline void
Tensor<rank_, dim, Number>::unroll(const Iterator begin,
                                   const Iterator end) const
{
  if constexpr (rank_ > 1)
    {
      // For higher-rank tensors, we recurse to the sub-tensors:
      Iterator next = begin;
      for (unsigned int i = 0; i < dim; ++i)
        {
          values[i].unroll(next, end);
          std::advance(
            next, Tensor<rank_ - 1, dim, Number>::n_independent_components);
        }
    }
  else
    {
      // For rank-1 tensors, we can simply copy the current elements from
      // our linear array into the output range:
      Assert(std::distance(begin, end) >= dim,
             ExcMessage(
               "The provided iterator range must contain at least 'dim' "
               "elements."));
      std::copy(values.data(), values.data() + values.size(), begin);
    }
}
 
 
 
template <int rank_, int dim, typename Number>
constexpr inline unsigned int
Tensor<rank_, dim, Number>::component_to_unrolled_index(
  const TableIndices<rank_> &indices)
{
  unsigned int index = 0;
  for (int r = 0; r < rank_; ++r)
    index = index * dim + indices[r];
 
  return index;
}
 
 
 
template <int rank_, int dim, typename Number>
constexpr inline TableIndices<rank_>
Tensor<rank_, dim, Number>::unrolled_to_component_indices(const unsigned int i)
{
  // Work-around nvcc warning
  unsigned int dummy = n_independent_components;
  AssertIndexRange(i, dummy);
 
  if constexpr (dim == 0)
    {
      Assert(false,
             ExcMessage(
               "A tensor with dimension 0 does not store any elements. "
               "There is no indexing that can address its elements."));
      return {};
    }
  else
    {
      TableIndices<rank_> indices;
 
      unsigned int remainder = i;
      for (int r = rank_ - 1; r >= 0; --r)
        {
          indices[r] = remainder % dim;
          remainder  = remainder / dim;
        }
      Assert(remainder == 0, ExcInternalError());
 
      return indices;
    }
}
 
 
template <int rank_, int dim, typename Number>
constexpr inline void
Tensor<rank_, dim, Number>::clear()
{
  for (unsigned int i = 0; i < dim; ++i)
    values[i] = internal::NumberType<Number>::value(0.0);
}
 
 
template <int rank_, int dim, typename Number>
constexpr std::size_t
Tensor<rank_, dim, Number>::memory_consumption()
{
  return sizeof(Tensor<rank_, dim, Number>);
}
 
 
template <int rank_, int dim, typename Number>
template <class Archive>
inline void
Tensor<rank_, dim, Number>::serialize(Archive &ar, const unsigned int)
{
  for (int i = 0; i < dim; ++i)
    {
      ar &values[i];
    }
}
 
 
template <int rank_, int dim, typename Number>
constexpr unsigned int Tensor<rank_, dim, Number>::n_independent_components;
 
#endif // DOXYGEN
 
/* ----------------- Non-member functions operating on tensors. ------------ */


template <int rank_, int dim, typename Number>
inline std::ostream &
operator<<(std::ostream &out, const Tensor<rank_, dim, Number> &p)
{
  for (unsigned int i = 0; i < dim; ++i)
    {
      out << p[i];
      if (i != dim - 1)
        for (unsigned int j = 0; j < rank_; ++j)
          out << ' ';
    }
 
  return out;
}
 

template <int dim, typename Number>
inline std::ostream &
operator<<(std::ostream &out, const Tensor<0, dim, Number> &p)
{
  out << static_cast<const Number &>(p);
  return out;
}
 


template <int dim, typename Number, typename Other>
constexpr DEAL_II_HOST_DEVICE inline DEAL_II_ALWAYS_INLINE
  typename ProductType<Other, Number>::type
  operator*(const Other &object, const Tensor<0, dim, Number> &t)
{
  return object * static_cast<const Number &>(t);
}
 
 

template <int dim, typename Number, typename Other>
constexpr DEAL_II_HOST_DEVICE inline DEAL_II_ALWAYS_INLINE
  typename ProductType<Number, Other>::type
  operator*(const Tensor<0, dim, Number> &t, const Other &object)
{
  return static_cast<const Number &>(t) * object;
}
 

template <int dim, typename Number, typename OtherNumber>
DEAL_II_HOST_DEVICE constexpr DEAL_II_ALWAYS_INLINE
  typename ProductType<Number, OtherNumber>::type
  operator*(const Tensor<0, dim, Number>      &src1,
            const Tensor<0, dim, OtherNumber> &src2)
{
  return static_cast<const Number &>(src1) *
         static_cast<const OtherNumber &>(src2);
}
 

template <int dim, typename Number, typename OtherNumber>
DEAL_II_HOST_DEVICE constexpr DEAL_II_ALWAYS_INLINE
  Tensor<0,
         dim,
         typename ProductType<Number,
                              typename EnableIfScalar<OtherNumber>::type>::type>
  operator/(const Tensor<0, dim, Number> &t, const OtherNumber &factor)
{
  return static_cast<const Number &>(t) / factor;
}
 

template <int dim, typename Number, typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE
  Tensor<0, dim, typename ProductType<Number, OtherNumber>::type>
  operator+(const Tensor<0, dim, Number>      &p,
            const Tensor<0, dim, OtherNumber> &q)
{
  return static_cast<const Number &>(p) + static_cast<const OtherNumber &>(q);
}
 

template <int dim, typename Number, typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE
  Tensor<0, dim, typename ProductType<Number, OtherNumber>::type>
  operator-(const Tensor<0, dim, Number>      &p,
            const Tensor<0, dim, OtherNumber> &q)
{
  return static_cast<const Number &>(p) - static_cast<const OtherNumber &>(q);
}
 

template <int rank, int dim, typename Number, typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE inline DEAL_II_ALWAYS_INLINE
  Tensor<rank,
         dim,
         typename ProductType<Number,
                              typename EnableIfScalar<OtherNumber>::type>::type>
  operator*(const Tensor<rank, dim, Number> &t, const OtherNumber &factor)
{
  Tensor<rank, dim, typename ProductType<Number, OtherNumber>::type> tt(t);
  tt *= factor;
  return tt;
}
 

template <int rank, int dim, typename Number, typename OtherNumber>
DEAL_II_HOST_DEVICE constexpr inline DEAL_II_ALWAYS_INLINE
  Tensor<rank,
         dim,
         typename ProductType<typename EnableIfScalar<Number>::type,
                              OtherNumber>::type>
  operator*(const Number &factor, const Tensor<rank, dim, OtherNumber> &t)
{
  // simply forward to the operator above
  return t * factor;
}
 
 

template <int rank, int dim, typename Number, typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE inline DEAL_II_ALWAYS_INLINE
  Tensor<rank,
         dim,
         typename ProductType<Number,
                              typename EnableIfScalar<OtherNumber>::type>::type>
  operator/(const Tensor<rank, dim, Number> &t, const OtherNumber &factor)
{
  Tensor<rank, dim, typename ProductType<Number, OtherNumber>::type> tt(t);
  tt /= factor;
  return tt;
}
 

template <int rank, int dim, typename Number, typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE inline DEAL_II_ALWAYS_INLINE
  Tensor<rank, dim, typename ProductType<Number, OtherNumber>::type>
  operator+(const Tensor<rank, dim, Number>      &p,
            const Tensor<rank, dim, OtherNumber> &q)
{
  Tensor<rank, dim, typename ProductType<Number, OtherNumber>::type> tmp(p);
  tmp += q;
  return tmp;
}
 

template <int rank, int dim, typename Number, typename OtherNumber>
constexpr DEAL_II_HOST_DEVICE inline DEAL_II_ALWAYS_INLINE
  Tensor<rank, dim, typename ProductType<Number, OtherNumber>::type>
  operator-(const Tensor<rank, dim, Number>      &p,
            const Tensor<rank, dim, OtherNumber> &q)
{
  Tensor<rank, dim, typename ProductType<Number, OtherNumber>::type> tmp(p);
  tmp -= q;
  return tmp;
}

template <int dim, typename Number, typename OtherNumber>
inline constexpr DEAL_II_ALWAYS_INLINE
  Tensor<0, dim, typename ProductType<Number, OtherNumber>::type>
  schur_product(const Tensor<0, dim, Number>      &src1,
                const Tensor<0, dim, OtherNumber> &src2)
{
  Tensor<0, dim, typename ProductType<Number, OtherNumber>::type> tmp(src1);
 
  tmp *= src2;
 
  return tmp;
}

template <int rank, int dim, typename Number, typename OtherNumber>
inline constexpr DEAL_II_ALWAYS_INLINE
  Tensor<rank, dim, typename ProductType<Number, OtherNumber>::type>
  schur_product(const Tensor<rank, dim, Number>      &src1,
                const Tensor<rank, dim, OtherNumber> &src2)
{
  Tensor<rank, dim, typename ProductType<Number, OtherNumber>::type> tmp;
 
  for (unsigned int i = 0; i < dim; ++i)
    tmp[i] = schur_product(Tensor<rank - 1, dim, Number>(src1[i]),
                           Tensor<rank - 1, dim, OtherNumber>(src2[i]));
 
  return tmp;
}


template <int rank_1,
          int rank_2,
          int dim,
          typename Number,
          typename OtherNumber,
          typename = std::enable_if_t<rank_1 >= 1 && rank_2 >= 1>>
constexpr inline DEAL_II_ALWAYS_INLINE
  typename Tensor<rank_1 + rank_2 - 2,
                  dim,
                  typename ProductType<Number, OtherNumber>::type>::tensor_type
  operator*(const Tensor<rank_1, dim, Number>      &src1,
            const Tensor<rank_2, dim, OtherNumber> &src2)
{
  // Treat some common cases separately. Specifically, these are the dot
  // product between two rank-1 tensors, and the product between a
  // rank-2 tensor and a rank-1 tensor. Both of these lead to a linear
  // loop over adjacent memory and can be dealt with efficiently; in the
  // latter case (rank-2 times rank-1), we implement things by deferring
  // to rank-1 times rank-1 dot products.
  if constexpr ((rank_1 == 1) && (rank_2 == 1))
    {
      // This is a dot product between two rank-1 tensors. Write it out as
      // a linear loop:
      static_assert(dim > 0, "Tensors cannot have dimension zero.");
      typename ProductType<Number, OtherNumber>::type sum = src1[0] * src2[0];
      for (unsigned int i = 1; i < dim; ++i)
        sum += src1[i] * src2[i];
 
      return sum;
    }
  else if constexpr ((rank_1 == 2) && (rank_2 == 1))
    {
      // This is a product between a rank-2 and a rank-1 tensor. This
      // corresponds to taking dot products between the rows of the former
      // and the latter.
      typename Tensor<
        rank_1 + rank_2 - 2,
        dim,
        typename ProductType<Number, OtherNumber>::type>::tensor_type result;
      for (unsigned int i = 0; i < dim; ++i)
        result[i] += src1[i] * src2;
 
      return result;
    }
  else
    {
      // Treat all of the other cases using the more general contraction
      // machinery.
      typename Tensor<
        rank_1 + rank_2 - 2,
        dim,
        typename ProductType<Number, OtherNumber>::type>::tensor_type result{};
 
      TensorAccessors::internal::
        ReorderedIndexView<0, rank_2, const Tensor<rank_2, dim, OtherNumber>>
          reordered = TensorAccessors::reordered_index_view<0, rank_2>(src2);
      TensorAccessors::contract<1, rank_1, rank_2, dim>(result,
                                                        src1,
                                                        reordered);
 
      return result;
    }
}
 

template <int index_1,
          int index_2,
          int rank_1,
          int rank_2,
          int dim,
          typename Number,
          typename OtherNumber>
constexpr inline DEAL_II_ALWAYS_INLINE
  typename Tensor<rank_1 + rank_2 - 2,
                  dim,
                  typename ProductType<Number, OtherNumber>::type>::tensor_type
  contract(const Tensor<rank_1, dim, Number>      &src1,
           const Tensor<rank_2, dim, OtherNumber> &src2)
{
  Assert(0 <= index_1 && index_1 < rank_1,
         ExcMessage(
           "The specified index_1 must lie within the range [0,rank_1)"));
  Assert(0 <= index_2 && index_2 < rank_2,
         ExcMessage(
           "The specified index_2 must lie within the range [0,rank_2)"));
 
  using namespace TensorAccessors;
  using namespace TensorAccessors::internal;
 
  // Reorder index_1 to the end of src1:
  const ReorderedIndexView<index_1, rank_1, const Tensor<rank_1, dim, Number>>
    reord_01 = reordered_index_view<index_1, rank_1>(src1);
 
  // Reorder index_2 to the end of src2:
  const ReorderedIndexView<index_2,
                           rank_2,
                           const Tensor<rank_2, dim, OtherNumber>>
    reord_02 = reordered_index_view<index_2, rank_2>(src2);
 
  typename Tensor<rank_1 + rank_2 - 2,
                  dim,
                  typename ProductType<Number, OtherNumber>::type>::tensor_type
    result{};
  TensorAccessors::contract<1, rank_1, rank_2, dim>(result, reord_01, reord_02);
  return result;
}
 

template <int index_1,
          int index_2,
          int index_3,
          int index_4,
          int rank_1,
          int rank_2,
          int dim,
          typename Number,
          typename OtherNumber>
constexpr inline
  typename Tensor<rank_1 + rank_2 - 4,
                  dim,
                  typename ProductType<Number, OtherNumber>::type>::tensor_type
  double_contract(const Tensor<rank_1, dim, Number>      &src1,
                  const Tensor<rank_2, dim, OtherNumber> &src2)
{
  Assert(0 <= index_1 && index_1 < rank_1,
         ExcMessage(
           "The specified index_1 must lie within the range [0,rank_1)"));
  Assert(0 <= index_3 && index_3 < rank_1,
         ExcMessage(
           "The specified index_3 must lie within the range [0,rank_1)"));
  Assert(index_1 != index_3,
         ExcMessage("index_1 and index_3 must not be the same"));
  Assert(0 <= index_2 && index_2 < rank_2,
         ExcMessage(
           "The specified index_2 must lie within the range [0,rank_2)"));
  Assert(0 <= index_4 && index_4 < rank_2,
         ExcMessage(
           "The specified index_4 must lie within the range [0,rank_2)"));
  Assert(index_2 != index_4,
         ExcMessage("index_2 and index_4 must not be the same"));
 
  using namespace TensorAccessors;
  using namespace TensorAccessors::internal;
 
  // Reorder index_1 to the end of src1:
  ReorderedIndexView<index_1, rank_1, const Tensor<rank_1, dim, Number>>
    reord_1 = TensorAccessors::reordered_index_view<index_1, rank_1>(src1);
 
  // Reorder index_2 to the end of src2:
  ReorderedIndexView<index_2, rank_2, const Tensor<rank_2, dim, OtherNumber>>
    reord_2 = TensorAccessors::reordered_index_view<index_2, rank_2>(src2);
 
  // Now, reorder index_3 to the end of src1. We have to make sure to
  // preserve the original ordering: index_1 has been removed. If
  // index_3 > index_1, we have to use (index_3 - 1) instead:
  ReorderedIndexView<
    (index_3 < index_1 ? index_3 : index_3 - 1),
    rank_1,
    ReorderedIndexView<index_1, rank_1, const Tensor<rank_1, dim, Number>>>
    reord_3 =
      TensorAccessors::reordered_index_view < index_3 < index_1 ? index_3 :
                                                                  index_3 - 1,
    rank_1 > (reord_1);
 
  // Now, reorder index_4 to the end of src2. We have to make sure to
  // preserve the original ordering: index_2 has been removed. If
  // index_4 > index_2, we have to use (index_4 - 1) instead:
  ReorderedIndexView<
    (index_4 < index_2 ? index_4 : index_4 - 1),
    rank_2,
    ReorderedIndexView<index_2, rank_2, const Tensor<rank_2, dim, OtherNumber>>>
    reord_4 =
      TensorAccessors::reordered_index_view < index_4 < index_2 ? index_4 :
                                                                  index_4 - 1,
    rank_2 > (reord_2);
 
  typename Tensor<rank_1 + rank_2 - 4,
                  dim,
                  typename ProductType<Number, OtherNumber>::type>::tensor_type
    result{};
  TensorAccessors::contract<2, rank_1, rank_2, dim>(result, reord_3, reord_4);
  return result;
}
 

template <int rank, int dim, typename Number, typename OtherNumber>
constexpr inline DEAL_II_ALWAYS_INLINE
  typename ProductType<Number, OtherNumber>::type
  scalar_product(const Tensor<rank, dim, Number>      &left,
                 const Tensor<rank, dim, OtherNumber> &right)
{
  typename ProductType<Number, OtherNumber>::type result{};
  TensorAccessors::contract<rank, rank, rank, dim>(result, left, right);
  return result;
}
 

template <template <int, int, typename> class TensorT1,
          template <int, int, typename>
          class TensorT2,
          template <int, int, typename>
          class TensorT3,
          int rank_1,
          int rank_2,
          int dim,
          typename T1,
          typename T2,
          typename T3>
constexpr inline DEAL_II_ALWAYS_INLINE
  typename ProductType<T1, typename ProductType<T2, T3>::type>::type
  contract3(const TensorT1<rank_1, dim, T1>          &left,
            const TensorT2<rank_1 + rank_2, dim, T2> &middle,
            const TensorT3<rank_2, dim, T3>          &right)
{
  using return_type =
    typename ProductType<T1, typename ProductType<T2, T3>::type>::type;
  return TensorAccessors::contract3<rank_1, rank_2, dim, return_type>(left,
                                                                      middle,
                                                                      right);
}
 

template <int rank_1,
          int rank_2,
          int dim,
          typename Number,
          typename OtherNumber>
constexpr inline DEAL_II_ALWAYS_INLINE
  Tensor<rank_1 + rank_2, dim, typename ProductType<Number, OtherNumber>::type>
  outer_product(const Tensor<rank_1, dim, Number>      &src1,
                const Tensor<rank_2, dim, OtherNumber> &src2)
{
  typename Tensor<rank_1 + rank_2,
                  dim,
                  typename ProductType<Number, OtherNumber>::type>::tensor_type
    result{};
  TensorAccessors::contract<0, rank_1, rank_2, dim>(result, src1, src2);
  return result;
}
 


template <int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE Tensor<1, dim, Number>
cross_product_2d(const Tensor<1, dim, Number> &src)
{
  Assert(dim == 2, ExcInternalError());
 
  Tensor<1, dim, Number> result;
 
  result[0] = src[1];
  result[1] = -src[0];
 
  return result;
}
 

template <int dim, typename Number1, typename Number2>
constexpr inline DEAL_II_ALWAYS_INLINE
  Tensor<1, dim, typename ProductType<Number1, Number2>::type>
  cross_product_3d(const Tensor<1, dim, Number1> &src1,
                   const Tensor<1, dim, Number2> &src2)
{
  Assert(dim == 3, ExcInternalError());
 
  Tensor<1, dim, typename ProductType<Number1, Number2>::type> result;
 
  if constexpr (dim == 3)
    {
      result[0] = src1[1] * src2[2] - src1[2] * src2[1];
      result[1] = src1[2] * src2[0] - src1[0] * src2[2];
      result[2] = src1[0] * src2[1] - src1[1] * src2[0];
    }
 
  return result;
}
 


template <int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE Number
determinant(const Tensor<2, dim, Number> &t)
{
  // Compute the determinant using the Laplace expansion of the
  // determinant. We expand along the last row.
  Number det = internal::NumberType<Number>::value(0.0);
 
  for (unsigned int k = 0; k < dim; ++k)
    {
      Tensor<2, dim - 1, Number> minor;
      for (unsigned int i = 0; i < dim - 1; ++i)
        for (unsigned int j = 0; j < dim - 1; ++j)
          minor[i][j] = t[i][j < k ? j : j + 1];
 
      const Number cofactor = ((k % 2 == 0) ? -1. : 1.) * determinant(minor);
 
      det += t[dim - 1][k] * cofactor;
    }
 
  return ((dim % 2 == 0) ? 1. : -1.) * det;
}

template <typename Number>
constexpr DEAL_II_ALWAYS_INLINE Number
determinant(const Tensor<2, 1, Number> &t)
{
  return t[0][0];
}

template <typename Number>
constexpr DEAL_II_ALWAYS_INLINE Number
determinant(const Tensor<2, 2, Number> &t)
{
  // hard-coded for efficiency reasons
  return t[0][0] * t[1][1] - t[1][0] * t[0][1];
}

template <typename Number>
constexpr DEAL_II_ALWAYS_INLINE Number
determinant(const Tensor<2, 3, Number> &t)
{
  // hard-coded for efficiency reasons
  const Number C0 = internal::NumberType<Number>::value(t[1][1] * t[2][2]) -
                    internal::NumberType<Number>::value(t[1][2] * t[2][1]);
  const Number C1 = internal::NumberType<Number>::value(t[1][2] * t[2][0]) -
                    internal::NumberType<Number>::value(t[1][0] * t[2][2]);
  const Number C2 = internal::NumberType<Number>::value(t[1][0] * t[2][1]) -
                    internal::NumberType<Number>::value(t[1][1] * t[2][0]);
  return t[0][0] * C0 + t[0][1] * C1 + t[0][2] * C2;
}
 

template <int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE Number
trace(const Tensor<2, dim, Number> &d)
{
  Number t = d[0][0];
  for (unsigned int i = 1; i < dim; ++i)
    t += d[i][i];
  return t;
}
 

template <int dim, typename Number>
constexpr inline Tensor<2, dim, Number>
invert(const Tensor<2, dim, Number> &)
{
  Number return_tensor[dim][dim];
 
  // if desired, take over the
  // inversion of a 4x4 tensor
  // from the FullMatrix
  AssertThrow(false, ExcNotImplemented());
 
  return Tensor<2, dim, Number>(return_tensor);
}
 
 
#ifndef DOXYGEN
 
template <typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE Tensor<2, 1, Number>
                                       invert(const Tensor<2, 1, Number> &t)
{
  Tensor<2, 1, Number> return_tensor;
 
  return_tensor[0][0] = internal::NumberType<Number>::value(1.0 / t[0][0]);
 
  return return_tensor;
}
 
 
template <typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE Tensor<2, 2, Number>
                                       invert(const Tensor<2, 2, Number> &t)
{
  Tensor<2, 2, Number> return_tensor;
 
  const Number inv_det_t = internal::NumberType<Number>::value(
    1.0 / (t[0][0] * t[1][1] - t[1][0] * t[0][1]));
  return_tensor[0][0] = t[1][1];
  return_tensor[0][1] = -t[0][1];
  return_tensor[1][0] = -t[1][0];
  return_tensor[1][1] = t[0][0];
  return_tensor *= inv_det_t;
 
  return return_tensor;
}
 
template <typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE Tensor<2, 3, Number>
                                       invert(const Tensor<2, 3, Number> &t)
{
  Tensor<2, 3, Number> return_tensor;
 
  const auto value = [](const auto &t) {
    return internal::NumberType<Number>::value(t);
  };
 
  return_tensor[0][0] = value(t[1][1] * t[2][2]) - value(t[1][2] * t[2][1]);
  return_tensor[0][1] = value(t[0][2] * t[2][1]) - value(t[0][1] * t[2][2]);
  return_tensor[0][2] = value(t[0][1] * t[1][2]) - value(t[0][2] * t[1][1]);
  return_tensor[1][0] = value(t[1][2] * t[2][0]) - value(t[1][0] * t[2][2]);
  return_tensor[1][1] = value(t[0][0] * t[2][2]) - value(t[0][2] * t[2][0]);
  return_tensor[1][2] = value(t[0][2] * t[1][0]) - value(t[0][0] * t[1][2]);
  return_tensor[2][0] = value(t[1][0] * t[2][1]) - value(t[1][1] * t[2][0]);
  return_tensor[2][1] = value(t[0][1] * t[2][0]) - value(t[0][0] * t[2][1]);
  return_tensor[2][2] = value(t[0][0] * t[1][1]) - value(t[0][1] * t[1][0]);
 
  const Number inv_det_t =
    value(1.0 / (t[0][0] * return_tensor[0][0] + t[0][1] * return_tensor[1][0] +
                 t[0][2] * return_tensor[2][0]));
  return_tensor *= inv_det_t;
 
  return return_tensor;
}
 
#endif /* DOXYGEN */
 

template <int dim, typename Number>
constexpr inline DEAL_II_ALWAYS_INLINE Tensor<2, dim, Number>
transpose(const Tensor<2, dim, Number> &t)
{
  Tensor<2, dim, Number> tt;
  for (unsigned int i = 0; i < dim; ++i)
    {
      tt[i][i] = t[i][i];
      for (unsigned int j = i + 1; j < dim; ++j)
        {
          tt[i][j] = t[j][i];
          tt[j][i] = t[i][j];
        };
    }
  return tt;
}
 

template <int dim, typename Number>
constexpr Tensor<2, dim, Number>
adjugate(const Tensor<2, dim, Number> &t)
{
  return determinant(t) * invert(t);
}
 

template <int dim, typename Number>
constexpr Tensor<2, dim, Number>
cofactor(const Tensor<2, dim, Number> &t)
{
  return transpose(adjugate(t));
}
 

template <int dim, typename Number>
Tensor<2, dim, Number>
project_onto_orthogonal_tensors(const Tensor<2, dim, Number> &A);
 

template <int dim, typename Number>
inline Number
l1_norm(const Tensor<2, dim, Number> &t)
{
  Number max = internal::NumberType<Number>::value(0.0);
  for (unsigned int j = 0; j < dim; ++j)
    {
      Number sum = internal::NumberType<Number>::value(0.0);
      for (unsigned int i = 0; i < dim; ++i)
        sum += numbers::NumberTraits<Number>::abs(t[i][j]);
 
      if (sum > max)
        max = sum;
    }
 
  return max;
}
 

template <int dim, typename Number>
inline Number
linfty_norm(const Tensor<2, dim, Number> &t)
{
  Number max = internal::NumberType<Number>::value(0.0);
  for (unsigned int i = 0; i < dim; ++i)
    {
      Number sum = internal::NumberType<Number>::value(0.0);
      for (unsigned int j = 0; j < dim; ++j)
        sum += numbers::NumberTraits<Number>::abs(t[i][j]);
 
      if (sum > max)
        max = sum;
    }
 
  return max;
}

 
 
#ifndef DOXYGEN
 
 
#  ifdef DEAL_II_ADOLC_WITH_ADVANCED_BRANCHING
 
// Specialization of functions for ADOL-C number types when
// the advanced branching feature is used
template <int dim>
inline adouble
l1_norm(const Tensor<2, dim, adouble> &t)
{
  adouble max = internal::NumberType<adouble>::value(0.0);
  for (unsigned int j = 0; j < dim; ++j)
    {
      adouble sum = internal::NumberType<adouble>::value(0.0);
      for (unsigned int i = 0; i < dim; ++i)
        sum += fabs(t[i][j]);
 
      condassign(max, (sum > max), sum, max);
    }
 
  return max;
}
 
 
template <int dim>
inline adouble
linfty_norm(const Tensor<2, dim, adouble> &t)
{
  adouble max = internal::NumberType<adouble>::value(0.0);
  for (unsigned int i = 0; i < dim; ++i)
    {
      adouble sum = internal::NumberType<adouble>::value(0.0);
      for (unsigned int j = 0; j < dim; ++j)
        sum += fabs(t[i][j]);
 
      condassign(max, (sum > max), sum, max);
    }
 
  return max;
}
 
#  endif // DEAL_II_ADOLC_WITH_ADVANCED_BRANCHING
 
 
#endif // DOXYGEN
 
DEAL_II_NAMESPACE_CLOSE
 
#endif