Manually fix up some std::is_same<...> places.

include/deal.II/base/array_view.h

@@ -704,12 +704,12 @@ ArrayView<typename std::remove_reference<
 make_array_view(const Iterator begin, const Iterator end)
 {
   static_assert(
-    std::is_same<typename std::iterator_traits<Iterator>::iterator_category,
-                 typename std::random_access_iterator_tag>::value
+    std::is_same_v<typename std::iterator_traits<Iterator>::iterator_category,
+                   typename std::random_access_iterator_tag>
 #ifdef DEAL_II_HAVE_CXX20
       ||
-      std::is_same<typename std::iterator_traits<Iterator>::iterator_category,
-                   typename std::contiguous_iterator_tag>::value
+      std::is_same_v<typename std::iterator_traits<Iterator>::iterator_category,
+                     typename std::contiguous_iterator_tag>
 #endif
     ,
     "The provided iterator needs to be a random access iterator.");

include/deal.II/base/hdf5.h

@@ -1211,8 +1211,7 @@ namespace HDF5
      */
     template <typename Container>
     std::enable_if_t<
-      std::is_same<Container,
-                   std::vector<typename Container::value_type>>::value,
+      std::is_same_v<Container, std::vector<typename Container::value_type>>,
       Container>
     initialize_container(const std::vector<hsize_t> &dimensions);
 
@@ -1230,8 +1229,7 @@ namespace HDF5
      */
     template <typename Container>
     std::enable_if_t<
-      std::is_same<Container,
-                   FullMatrix<typename Container::value_type>>::value,
+      std::is_same_v<Container, FullMatrix<typename Container::value_type>>,
       Container>
     initialize_container(const std::vector<hsize_t> &dimensions);
 
@@ -1419,8 +1417,7 @@ namespace HDF5
 
     template <typename Container>
     std::enable_if_t<
-      std::is_same<Container,
-                   std::vector<typename Container::value_type>>::value,
+      std::is_same_v<Container, std::vector<typename Container::value_type>>,
       Container>
     initialize_container(const std::vector<hsize_t> &dimensions)
     {
@@ -1444,8 +1441,7 @@ namespace HDF5
 
     template <typename Container>
     std::enable_if_t<
-      std::is_same<Container,
-                   FullMatrix<typename Container::value_type>>::value,
+      std::is_same_v<Container, FullMatrix<typename Container::value_type>>,
       Container>
     initialize_container(const std::vector<hsize_t> &dimensions)
     {

include/deal.II/base/mpi.templates.h

@@ -157,8 +157,8 @@ namespace Utilities
     void
     sum(const T &values, const MPI_Comm mpi_communicator, U &sums)
     {
-      static_assert(std::is_same<typename std::decay<T>::type,
-                                 typename std::decay<U>::type>::value,
+      static_assert(std::is_same_v<typename std::decay<T>::type,
+                                   typename std::decay<U>::type>,
                     "Input and output arguments must have the same type!");
       const auto array_view_values = make_array_view(values);
       using const_type =
@@ -272,8 +272,8 @@ namespace Utilities
     void
     max(const T &values, const MPI_Comm mpi_communicator, U &maxima)
     {
-      static_assert(std::is_same<typename std::decay<T>::type,
-                                 typename std::decay<U>::type>::value,
+      static_assert(std::is_same_v<typename std::decay<T>::type,
+                                   typename std::decay<U>::type>,
                     "Input and output arguments must have the same type!");
       const auto array_view_values = make_array_view(values);
       using const_type =
@@ -314,8 +314,8 @@ namespace Utilities
     void
     min(const T &values, const MPI_Comm mpi_communicator, U &minima)
     {
-      static_assert(std::is_same<typename std::decay<T>::type,
-                                 typename std::decay<U>::type>::value,
+      static_assert(std::is_same_v<typename std::decay<T>::type,
+                                   typename std::decay<U>::type>,
                     "Input and output arguments must have the same type!");
       const auto array_view_values = make_array_view(values);
       using const_type =
@@ -359,8 +359,8 @@ namespace Utilities
     void
     logical_or(const T &values, const MPI_Comm mpi_communicator, U &results)
     {
-      static_assert(std::is_same<typename std::decay<T>::type,
-                                 typename std::decay<U>::type>::value,
+      static_assert(std::is_same_v<typename std::decay<T>::type,
+                                   typename std::decay<U>::type>,
                     "Input and output arguments must have the same type!");
 
       static_assert(std::is_integral<typename T::value_type>::value,

include/deal.II/base/numbers.h

@@ -715,8 +715,8 @@ namespace internal
     template <typename F>
     static constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE T
     value(const F &f,
-          std::enable_if_t<!std::is_same<typename std::decay<T>::type,
-                                         typename std::decay<F>::type>::value &&
+          std::enable_if_t<!std::is_same_v<typename std::decay<T>::type,
+                                           typename std::decay<F>::type> &&
                            std::is_constructible<T, F>::value> * = nullptr)
     {
       return T(f);
@@ -726,8 +726,8 @@ namespace internal
     template <typename F>
     static constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE T
     value(const F &f,
-          std::enable_if_t<!std::is_same<typename std::decay<T>::type,
-                                         typename std::decay<F>::type>::value &&
+          std::enable_if_t<!std::is_same_v<typename std::decay<T>::type,
+                                           typename std::decay<F>::type> &&
                            !std::is_constructible<T, F>::value &&
                            is_explicitly_convertible<const F, T>::value> * =
             nullptr)
@@ -743,8 +743,8 @@ namespace internal
     static T
     value(
       const F &f,
-      std::enable_if_t<!std::is_same<typename std::decay<T>::type,
-                                     typename std::decay<F>::type>::value &&
+      std::enable_if_t<!std::is_same_v<typename std::decay<T>::type,
+                                       typename std::decay<F>::type> &&
                        !std::is_constructible<T, F>::value &&
                        !is_explicitly_convertible<const F, T>::value &&
                        Differentiation::AD::is_ad_number<F>::value> * = nullptr)

include/deal.II/base/partitioner.templates.h

@@ -119,8 +119,7 @@ namespace Utilities
       for (unsigned int i = 0; i < n_import_targets; ++i)
         {
 #    if defined(DEAL_II_MPI_WITH_DEVICE_SUPPORT)
-          if constexpr (std::is_same<MemorySpaceType,
-                                     MemorySpace::Default>::value)
+          if constexpr (std::is_same_v<MemorySpaceType, MemorySpace::Default>)
             {
               const auto chunk_size = import_indices_plain_dev[i].size();
               using IndexType       = decltype(chunk_size);
@@ -218,8 +217,8 @@ namespace Utilities
                 {
                   const unsigned int chunk_size =
                     ghost_range.second - ghost_range.first;
-                  if constexpr (std::is_same<MemorySpaceType,
-                                             MemorySpace::Host>::value)
+                  if constexpr (std::is_same_v<MemorySpaceType,
+                                               MemorySpace::Host>)
                     {
                       // If source and destination are overlapping, we must be
                       // careful to use an appropriate copy function.
@@ -390,8 +389,8 @@ namespace Utilities
                   if (ghost_array_ptr + offset !=
                       ghost_array.data() + my_ghosts->first)
                     {
-                      if constexpr (std::is_same<MemorySpaceType,
-                                                 MemorySpace::Host>::value)
+                      if constexpr (std::is_same_v<MemorySpaceType,
+                                                   MemorySpace::Host>)
                         {
                           if (offset > my_ghosts->first)
                             std::copy_backward(ghost_array.data() +
@@ -596,8 +595,7 @@ namespace Utilities
 
           const Number *read_position = temporary_storage.data();
 #    if defined(DEAL_II_MPI_WITH_DEVICE_SUPPORT)
-          if constexpr (std::is_same<MemorySpaceType,
-                                     MemorySpace::Default>::value)
+          if constexpr (std::is_same_v<MemorySpaceType, MemorySpace::Default>)
             {
               if (vector_operation == VectorOperation::add)
                 {
@@ -775,8 +773,7 @@ namespace Utilities
           Assert(ghost_array.begin() != nullptr, ExcInternalError());
 
 #    if defined(DEAL_II_MPI_WITH_DEVICE_SUPPORT)
-          if constexpr (std::is_same<MemorySpaceType,
-                                     MemorySpace::Default>::value)
+          if constexpr (std::is_same_v<MemorySpaceType, MemorySpace::Default>)
             {
               Kokkos::deep_copy(
                 Kokkos::View<Number *, MemorySpace::Default::kokkos_space>(

include/deal.II/base/vectorization.h

@@ -780,9 +780,9 @@ inline DEAL_II_ALWAYS_INLINE VectorizedArrayType
 make_vectorized_array(const typename VectorizedArrayType::value_type &u)
 {
   static_assert(
-    std::is_same<VectorizedArrayType,
-                 VectorizedArray<typename VectorizedArrayType::value_type,
-                                 VectorizedArrayType::size()>>::value,
+    std::is_same_v<VectorizedArrayType,
+                   VectorizedArray<typename VectorizedArrayType::value_type,
+                                   VectorizedArrayType::size()>>,
     "VectorizedArrayType is not a VectorizedArray.");
 
   VectorizedArrayType result = u;

include/deal.II/differentiation/ad/sacado_number_types.h

@@ -143,9 +143,9 @@ namespace Differentiation
       template <typename SacadoNumber>
       struct SacadoNumberInfo<
         SacadoNumber,
-        std::enable_if_t<std::is_same<
-          SacadoNumber,
-          Sacado::Fad::DFad<typename SacadoNumber::value_type>>::value>>
+        std::enable_if_t<
+          std::is_same_v<SacadoNumber,
+                         Sacado::Fad::DFad<typename SacadoNumber::value_type>>>>
       {
         using ad_type         = SacadoNumber;
         using scalar_type     = typename ad_type::scalar_type;
@@ -163,9 +163,9 @@ namespace Differentiation
       template <typename SacadoNumber>
       struct SacadoNumberInfo<
         SacadoNumber,
-        std::enable_if_t<std::is_same<
+        std::enable_if_t<std::is_same_v<
           SacadoNumber,
-          Sacado::Rad::ADvar<typename SacadoNumber::value_type>>::value>>
+          Sacado::Rad::ADvar<typename SacadoNumber::value_type>>>>
       {
         using ad_type         = SacadoNumber;
         using scalar_type     = typename ad_type::ADVari::scalar_type;
@@ -477,9 +477,9 @@ namespace Differentiation
     template <typename ADNumberType>
     struct ADNumberTraits<
       ADNumberType,
-      std::enable_if_t<std::is_same<
-        ADNumberType,
-        Sacado::Fad::DFad<typename ADNumberType::scalar_type>>::value>>
+      std::enable_if_t<
+        std::is_same_v<ADNumberType,
+                       Sacado::Fad::DFad<typename ADNumberType::scalar_type>>>>
       : NumberTraits<typename ADNumberType::scalar_type,
                      NumberTypes::sacado_dfad>
     {};
@@ -494,10 +494,10 @@ namespace Differentiation
     template <typename ADNumberType>
     struct ADNumberTraits<
       ADNumberType,
-      std::enable_if_t<std::is_same<
-        ADNumberType,
-        std::complex<Sacado::Fad::DFad<
-          typename ADNumberType::value_type::scalar_type>>>::value>>
+      std::enable_if_t<
+        std::is_same_v<ADNumberType,
+                       std::complex<Sacado::Fad::DFad<
+                         typename ADNumberType::value_type::scalar_type>>>>>
       : NumberTraits<
           std::complex<typename ADNumberType::value_type::scalar_type>,
           NumberTypes::sacado_dfad>
@@ -566,9 +566,9 @@ namespace Differentiation
     template <typename ADNumberType>
     struct ADNumberTraits<
       ADNumberType,
-      std::enable_if_t<std::is_same<
+      std::enable_if_t<std::is_same_v<
         ADNumberType,
-        Sacado::Rad::ADvar<typename ADNumberType::ADVari::scalar_type>>::value>>
+        Sacado::Rad::ADvar<typename ADNumberType::ADVari::scalar_type>>>>
       : NumberTraits<typename ADNumberType::ADVari::scalar_type,
                      NumberTypes::sacado_rad>
     {};
@@ -610,10 +610,10 @@ namespace Differentiation
     template <typename ADNumberType>
     struct ADNumberTraits<
       ADNumberType,
-      std::enable_if_t<std::is_same<
+      std::enable_if_t<std::is_same_v<
         ADNumberType,
         std::complex<Sacado::Rad::ADvar<
-          typename ADNumberType::value_type::ADVari::scalar_type>>>::value>>
+          typename ADNumberType::value_type::ADVari::scalar_type>>>>>
       : NumberTraits<
           std::complex<typename ADNumberType::value_type::ADVari::scalar_type>,
           NumberTypes::sacado_rad>
@@ -659,11 +659,11 @@ namespace Differentiation
      * a floating point type.
      */
     template <typename ADNumberType>
-    struct ADNumberTraits<ADNumberType,
-                          std::enable_if_t<std::is_same<
-                            ADNumberType,
-                            Sacado::Fad::DFad<Sacado::Fad::DFad<
-                              typename ADNumberType::scalar_type>>>::value>>
+    struct ADNumberTraits<
+      ADNumberType,
+      std::enable_if_t<std::is_same_v<ADNumberType,
+                                      Sacado::Fad::DFad<Sacado::Fad::DFad<
+                                        typename ADNumberType::scalar_type>>>>>
       : NumberTraits<typename ADNumberType::scalar_type,
                      NumberTypes::sacado_dfad_dfad>
     {};
@@ -679,10 +679,10 @@ namespace Differentiation
     template <typename ADNumberType>
     struct ADNumberTraits<
       ADNumberType,
-      std::enable_if_t<std::is_same<
-        ADNumberType,
-        std::complex<Sacado::Fad::DFad<Sacado::Fad::DFad<
-          typename ADNumberType::value_type::scalar_type>>>>::value>>
+      std::enable_if_t<
+        std::is_same_v<ADNumberType,
+                       std::complex<Sacado::Fad::DFad<Sacado::Fad::DFad<
+                         typename ADNumberType::value_type::scalar_type>>>>>>
       : NumberTraits<
           std::complex<typename ADNumberType::value_type::scalar_type>,
           NumberTypes::sacado_dfad_dfad>
@@ -753,12 +753,11 @@ namespace Differentiation
      * a floating point type.
      */
     template <typename ADNumberType>
-    struct ADNumberTraits<
-      ADNumberType,
-      std::enable_if_t<
-        std::is_same<ADNumberType,
-                     Sacado::Rad::ADvar<Sacado::Fad::DFad<
-                       typename ADNumberType::ADVari::scalar_type>>>::value>>
+    struct ADNumberTraits<ADNumberType,
+                          std::enable_if_t<std::is_same_v<
+                            ADNumberType,
+                            Sacado::Rad::ADvar<Sacado::Fad::DFad<
+                              typename ADNumberType::ADVari::scalar_type>>>>>
       : NumberTraits<typename ADNumberType::ADVari::scalar_type,
                      NumberTypes::sacado_rad_dfad>
     {};
@@ -803,10 +802,10 @@ namespace Differentiation
     template <typename ADNumberType>
     struct ADNumberTraits<
       ADNumberType,
-      std::enable_if_t<std::is_same<
+      std::enable_if_t<std::is_same_v<
         ADNumberType,
         std::complex<Sacado::Rad::ADvar<Sacado::Fad::DFad<
-          typename ADNumberType::value_type::ADVari::scalar_type>>>>::value>>
+          typename ADNumberType::value_type::ADVari::scalar_type>>>>>>
       : NumberTraits<
           std::complex<typename ADNumberType::value_type::ADVari::scalar_type>,
           NumberTypes::sacado_rad_dfad>
@@ -861,9 +860,9 @@ namespace Differentiation
     template <typename NumberType>
     struct is_sacado_dfad_number<
       NumberType,
-      std::enable_if_t<std::is_same<
-        NumberType,
-        Sacado::Fad::Expr<typename NumberType::value_type>>::value>>
+      std::enable_if_t<
+        std::is_same_v<NumberType,
+                       Sacado::Fad::Expr<typename NumberType::value_type>>>>
       : std::true_type
     {};
 
@@ -883,9 +882,9 @@ namespace Differentiation
     struct is_sacado_rad_number<
       NumberType,
       std::enable_if_t<
-        std::is_same<NumberType,
-                     Sacado::Rad::ADvari<Sacado::Fad::DFad<
-                       typename NumberType::ADVari::scalar_type>>>::value>>
+        std::is_same_v<NumberType,
+                       Sacado::Rad::ADvari<Sacado::Fad::DFad<
+                         typename NumberType::ADVari::scalar_type>>>>>
       : std::true_type
     {};
 

include/deal.II/differentiation/sd/symengine_tensor_operations.h

@@ -1020,18 +1020,19 @@ namespace Differentiation
                   out[indices_out] *= 0.5;
 
                 // TODO: Implement for SymmetricTensor<4,dim,...>
-                if (std::is_same<TensorType_1<rank_1, dim, ValueType>,
-                                 SymmetricTensor<2, dim, ValueType>>::
-                      value) // Symmetric function
+                if (std::is_same_v<
+                      TensorType_1<rank_1, dim, ValueType>,
+                      SymmetricTensor<2, dim, ValueType>>) // Symmetric function
                   {
                     const TableIndices<rank_1 + rank_2> indices_out_t =
                       concatenate_indices(transpose_indices(indices_i),
                                           indices_j);
                     out[indices_out_t] = out[indices_out];
                   }
-                else if (std::is_same<TensorType_2<rank_2, dim, ValueType>,
-                                      SymmetricTensor<2, dim, ValueType>>::
-                           value) // Symmetric operator
+                else if (std::is_same_v<
+                           TensorType_2<rank_2, dim, ValueType>,
+                           SymmetricTensor<2, dim, ValueType>>) // Symmetric
+                                                                // operator
                   {
                     const TableIndices<rank_1 + rank_2> indices_out_t =
                       concatenate_indices(indices_i,