]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Deprecate n_array_elements and replace its usage 9688/head
authorPeter Munch <peterrmuench@gmail.com>
Fri, 20 Mar 2020 08:54:37 +0000 (09:54 +0100)
committerPeter Munch <peterrmuench@gmail.com>
Fri, 20 Mar 2020 21:14:26 +0000 (22:14 +0100)
74 files changed:
doc/news/changes/incompatibilities/20200320PeterMunch [new file with mode: 0644]
include/deal.II/base/vectorization.h
include/deal.II/lac/tensor_product_matrix.h
include/deal.II/lac/vector_operations_internal.h
include/deal.II/matrix_free/dof_info.h
include/deal.II/matrix_free/evaluation_kernels.h
include/deal.II/matrix_free/fe_evaluation.h
include/deal.II/matrix_free/mapping_info.h
include/deal.II/matrix_free/mapping_info.templates.h
include/deal.II/matrix_free/matrix_free.h
include/deal.II/matrix_free/matrix_free.templates.h
include/deal.II/matrix_free/operators.h
include/deal.II/matrix_free/vector_access_internal.h
source/fe/mapping_q_generic.cc
source/multigrid/mg_transfer_matrix_free.cc
tests/base/point_03.cc
tests/base/utilities_02b.cc
tests/base/vectorization_01.cc
tests/base/vectorization_02.cc
tests/base/vectorization_03.cc
tests/base/vectorization_04.cc
tests/base/vectorization_05.cc
tests/base/vectorization_06.cc
tests/base/vectorization_09.cc
tests/base/vectorization_10.cc
tests/base/vectorization_11.cc
tests/base/vectorization_12.cc
tests/base/vectorization_13.cc
tests/base/vectorization_14.cc
tests/base/vectorization_15.cc
tests/base/vectorization_iterator_02.cc
tests/lac/tensor_product_matrix_vectorized_01.cc
tests/lac/tensor_product_matrix_vectorized_02.cc
tests/lac/tensor_product_matrix_vectorized_03.cc
tests/lac/tensor_product_matrix_vectorized_04.cc
tests/mappings/mapping_q_eulerian_08.cc
tests/matrix_free/advect_1d_vectorization_mask.cc
tests/matrix_free/assemble_matrix_01.cc
tests/matrix_free/assemble_matrix_02.cc
tests/matrix_free/assemble_matrix_03.cc
tests/matrix_free/cell_level_and_index.cc
tests/matrix_free/compare_faces_by_cells.cc
tests/matrix_free/dg_pbc_02.cc
tests/matrix_free/dof_info_01.cc
tests/matrix_free/dof_info_02.cc
tests/matrix_free/estimate_condition_number_mass.cc
tests/matrix_free/evaluate_1d_shape_07.cc
tests/matrix_free/evaluate_1d_shape_08.cc
tests/matrix_free/evaluate_1d_shape_09.cc
tests/matrix_free/faces_value_optimization.cc
tests/matrix_free/faces_value_optimization_02.cc
tests/matrix_free/get_functions_variants.cc
tests/matrix_free/get_functions_variants_gl.cc
tests/matrix_free/get_values_plain.cc
tests/matrix_free/interpolate_functions_common.h
tests/matrix_free/laplace_operator_02.cc
tests/matrix_free/matrix_vector_12.cc
tests/matrix_free/matrix_vector_13.cc
tests/matrix_free/matrix_vector_20.cc
tests/matrix_free/matrix_vector_21.cc
tests/matrix_free/matrix_vector_22.cc
tests/matrix_free/matrix_vector_23.cc
tests/matrix_free/matrix_vector_faces_common.h
tests/matrix_free/multigrid_dg_sip_02.cc
tests/matrix_free/no_index_initialize.cc
tests/matrix_free/read_cell_data_01.cc
tests/matrix_free/read_cell_data_02.cc
tests/matrix_free/step-48b.cc
tests/matrix_free/stokes_computation.cc
tests/numerics/project_parallel_qp_common.h
tests/numerics/project_parallel_qpmf_common.h
tests/physics/elasticity-kinematics_02.cc
tests/tensors/symmetric_tensor_38.cc
tests/tensors/symmetric_tensor_39.cc

diff --git a/doc/news/changes/incompatibilities/20200320PeterMunch b/doc/news/changes/incompatibilities/20200320PeterMunch
new file mode 100644 (file)
index 0000000..e66621d
--- /dev/null
@@ -0,0 +1,4 @@
+Chaned: VectorizedArray::n_array_elements has been deprecated. 
+Please use the method VectorizedArray::size() to access the same information.
+<br>
+(Peter Munch, 2020/03/20)
index 26bc11e0a5421f0cb03ad5fae29ff27a492dfe26..32ffb2996dbd78ed0d2c8a9453776e07c570a9f7 100644 (file)
@@ -245,18 +245,17 @@ private:
  *
  * @author Peter Munch, 2019
  */
-template <typename T>
+template <typename T, std::size_t width>
 class VectorizedArrayBase
 {
 public:
   /**
-   * Return the number of elements in the array stored in the variable
-   * n_array_elements of VectorizedArray.
+   * Return the number of elements in the array.
    */
   static constexpr std::size_t
   size()
   {
-    return T::n_array_elements;
+    return width;
   }
 
   /**
@@ -284,8 +283,7 @@ public:
   VectorizedArrayIterator<T>
   end()
   {
-    return VectorizedArrayIterator<T>(static_cast<T &>(*this),
-                                      T::n_array_elements);
+    return VectorizedArrayIterator<T>(static_cast<T &>(*this), width);
   }
 
   /**
@@ -296,7 +294,7 @@ public:
   end() const
   {
     return VectorizedArrayIterator<const T>(static_cast<const T &>(*this),
-                                            T::n_array_elements);
+                                            width);
   }
 };
 
@@ -390,7 +388,7 @@ public:
  */
 template <typename Number, std::size_t width>
 class VectorizedArray
-  : public VectorizedArrayBase<VectorizedArray<Number, width>>
+  : public VectorizedArrayBase<VectorizedArray<Number, width>, 1>
 {
 public:
   /**
@@ -403,9 +401,9 @@ public:
    * case, there is only one element. Specializations use SIMD intrinsics and
    * can work on multiple elements at the same time.
    */
-  static const unsigned int n_array_elements = 1;
+  DEAL_II_DEPRECATED static const unsigned int n_array_elements = 1;
 
-  static_assert(width == n_array_elements,
+  static_assert(width == 1,
                 "You specified an illegal width that is not supported.");
 
   /**
@@ -502,7 +500,7 @@ public:
   }
 
   /**
-   * Load @p n_array_elements from memory into the calling class, starting at
+   * Load size() data items from memory into the calling class, starting at
    * the given address. The pointer `ptr` needs not be aligned by the amount
    * of bytes in the vectorized array, as opposed to casting a double address
    * to VectorizedArray<double>*.
@@ -515,8 +513,8 @@ public:
   }
 
   /**
-   * Write the content of the calling class into memory in form of @p
-   * n_array_elements to the given address. The pointer `ptr` needs not be
+   * Write the content of the calling class into memory in form of
+   * size() data items to the given address. The pointer `ptr` needs not be
    * aligned by the amount of bytes in the vectorized array, as opposed to
    * casting a double address to VectorizedArray<double>*.
    */
@@ -529,7 +527,7 @@ public:
 
   /**
    * Write the content of the calling class into memory in form of
-   * @p n_array_elements to the given address using non-temporal stores that
+   * size() data items to the given address using non-temporal stores that
    * bypass the processor's caches, using @p _mm_stream_pd store intrinsics on
    * supported CPUs. The destination of the store @p ptr must be aligned by
    * the amount of bytes in the vectorized array.
@@ -581,14 +579,14 @@ public:
   }
 
   /**
-   * Load @p n_array_elements from memory into the calling class, starting at
+   * Load size() data items from memory into the calling class, starting at
    * the given address and with given offsets, each entry from the offset
    * providing one element of the vectorized array.
    *
    * This operation corresponds to the following code (but uses a more
    * efficient implementation in case the hardware allows for that):
    * @code
-   * for (unsigned int v=0; v<VectorizedArray<Number>::n_array_elements; ++v)
+   * for (unsigned int v=0; v<VectorizedArray<Number>::size(); ++v)
    *   this->operator[](v) = base_ptr[offsets[v]];
    * @endcode
    */
@@ -600,14 +598,14 @@ public:
   }
 
   /**
-   * Write the content of the calling class into memory in form of @p
-   * n_array_elements to the given address and the given offsets, filling the
+   * Write the content of the calling class into memory in form of
+   * size() data items to the given address and the given offsets, filling the
    * elements of the vectorized array into each offset.
    *
    * This operation corresponds to the following code (but uses a more
    * efficient implementation in case the hardware allows for that):
    * @code
-   * for (unsigned int v=0; v<VectorizedArray<Number>::n_array_elements; ++v)
+   * for (unsigned int v=0; v<VectorizedArray<Number>::size(); ++v)
    *   base_ptr[offsets[v]] = this->operator[](v);
    * @endcode
    */
@@ -740,7 +738,7 @@ inline DEAL_II_ALWAYS_INLINE VectorizedArrayType
   static_assert(
     std::is_same<VectorizedArrayType,
                  VectorizedArray<typename VectorizedArrayType::value_type,
-                                 VectorizedArrayType::n_array_elements>>::value,
+                                 VectorizedArrayType::size()>>::value,
     "VectorizedArrayType is not a VectorizedArray.");
 
   VectorizedArrayType result = u;
@@ -750,13 +748,13 @@ inline DEAL_II_ALWAYS_INLINE VectorizedArrayType
 
 
 /**
- * Load @p n_array_elements from memory into the the VectorizedArray @p out,
+ * Load size() data items from memory into the the VectorizedArray @p out,
  * starting at the given addresses and with given offset, each entry from the
  * offset providing one element of the vectorized array.
  *
  * This operation corresponds to the following code:
  * @code
- * for (unsigned int v=0; v<VectorizedArray<Number>::n_array_elements; ++v)
+ * for (unsigned int v=0; v<VectorizedArray<Number>::size(); ++v)
  *   out.data[v] = ptrs[v][offset];
  * @endcode
  */
@@ -773,7 +771,7 @@ gather(VectorizedArray<Number, width> &   out,
 
 
 /**
- * This method loads VectorizedArray::n_array_elements data streams from the
+ * This method loads VectorizedArray::size() data streams from the
  * given array @p in. The offsets to the input array are given by the array @p
  * offsets. From each stream, n_entries are read. The data is then transposed
  * and stored it into an array of VectorizedArray type. The output array @p
@@ -787,7 +785,7 @@ gather(VectorizedArray<Number, width> &   out,
  *
  * @code
  * for (unsigned int i=0; i<n_entries; ++i)
- *   for (unsigned int v=0; v<VectorizedArray<Number>::n_array_elements; ++v)
+ *   for (unsigned int v=0; v<VectorizedArray<Number>::size(); ++v)
  *     out[i][v] = in[offsets[v]+i];
  * @endcode
  *
@@ -805,9 +803,7 @@ vectorized_load_and_transpose(const unsigned int              n_entries,
                               VectorizedArray<Number, width> *out)
 {
   for (unsigned int i = 0; i < n_entries; ++i)
-    for (unsigned int v = 0;
-         v < VectorizedArray<Number, width>::n_array_elements;
-         ++v)
+    for (unsigned int v = 0; v < VectorizedArray<Number, width>::size(); ++v)
       out[i][v] = in[offsets[v] + i];
 }
 
@@ -830,9 +826,7 @@ vectorized_load_and_transpose(const unsigned int                 n_entries,
                               VectorizedArray<Number, width> *   out)
 {
   for (unsigned int i = 0; i < n_entries; ++i)
-    for (unsigned int v = 0;
-         v < VectorizedArray<Number, width>::n_array_elements;
-         ++v)
+    for (unsigned int v = 0; v < VectorizedArray<Number, width>::size(); ++v)
       out[i][v] = in[v][i];
 }
 
@@ -858,7 +852,7 @@ vectorized_load_and_transpose(const unsigned int                 n_entries,
  *
  * @code
  * for (unsigned int i=0; i<n_entries; ++i)
- *   for (unsigned int v=0; v<VectorizedArray<Number>::n_array_elements; ++v)
+ *   for (unsigned int v=0; v<VectorizedArray<Number>::size(); ++v)
  *     out[offsets[v]+i] = in[i][v];
  * @endcode
  *
@@ -866,7 +860,7 @@ vectorized_load_and_transpose(const unsigned int                 n_entries,
  * action:
  * @code
  * for (unsigned int i=0; i<n_entries; ++i)
- *   for (unsigned int v=0; v<VectorizedArray<Number>::n_array_elements; ++v)
+ *   for (unsigned int v=0; v<VectorizedArray<Number>::size(); ++v)
  *     out[offsets[v]+i] += in[i][v];
  * @endcode
  *
@@ -886,15 +880,11 @@ vectorized_transpose_and_store(const bool                            add_into,
 {
   if (add_into)
     for (unsigned int i = 0; i < n_entries; ++i)
-      for (unsigned int v = 0;
-           v < VectorizedArray<Number, width>::n_array_elements;
-           ++v)
+      for (unsigned int v = 0; v < VectorizedArray<Number, width>::size(); ++v)
         out[offsets[v] + i] += in[i][v];
   else
     for (unsigned int i = 0; i < n_entries; ++i)
-      for (unsigned int v = 0;
-           v < VectorizedArray<Number, width>::n_array_elements;
-           ++v)
+      for (unsigned int v = 0; v < VectorizedArray<Number, width>::size(); ++v)
         out[offsets[v] + i] = in[i][v];
 }
 
@@ -919,15 +909,11 @@ vectorized_transpose_and_store(const bool                            add_into,
 {
   if (add_into)
     for (unsigned int i = 0; i < n_entries; ++i)
-      for (unsigned int v = 0;
-           v < VectorizedArray<Number, width>::n_array_elements;
-           ++v)
+      for (unsigned int v = 0; v < VectorizedArray<Number, width>::size(); ++v)
         out[v][i] += in[i][v];
   else
     for (unsigned int i = 0; i < n_entries; ++i)
-      for (unsigned int v = 0;
-           v < VectorizedArray<Number, width>::n_array_elements;
-           ++v)
+      for (unsigned int v = 0; v < VectorizedArray<Number, width>::size(); ++v)
         out[v][i] = in[i][v];
 }
 
@@ -946,7 +932,7 @@ vectorized_transpose_and_store(const bool                            add_into,
  */
 template <>
 class VectorizedArray<double, 8>
-  : public VectorizedArrayBase<VectorizedArray<double, 8>>
+  : public VectorizedArrayBase<VectorizedArray<double, 8>, 8>
 {
 public:
   /**
@@ -957,7 +943,7 @@ public:
   /**
    * This gives the number of vectors collected in this class.
    */
-  static const unsigned int n_array_elements = 8;
+  DEAL_II_DEPRECATED static const unsigned int n_array_elements = 8;
 
   /**
    * Default empty constructor, leaving the data in an uninitialized state
@@ -1069,7 +1055,7 @@ public:
   }
 
   /**
-   * Load @p n_array_elements from memory into the calling class, starting at
+   * Load size() data items from memory into the calling class, starting at
    * the given address. The memory need not be aligned by 64 bytes, as opposed
    * to casting a double address to VectorizedArray<double>*.
    */
@@ -1082,7 +1068,7 @@ public:
 
   /**
    * Write the content of the calling class into memory in form of @p
-   * n_array_elements to the given address. The memory need not be aligned by
+   * size() to the given address. The memory need not be aligned by
    * 64 bytes, as opposed to casting a double address to
    * VectorizedArray<double>*.
    */
@@ -1106,14 +1092,14 @@ public:
   }
 
   /**
-   * Load @p n_array_elements from memory into the calling class, starting at
+   * Load @p size() from memory into the calling class, starting at
    * the given address and with given offsets, each entry from the offset
    * providing one element of the vectorized array.
    *
    * This operation corresponds to the following code (but uses a more
    * efficient implementation in case the hardware allows for that):
    * @code
-   * for (unsigned int v=0; v<VectorizedArray<Number>::n_array_elements; ++v)
+   * for (unsigned int v=0; v<VectorizedArray<Number>::size(); ++v)
    *   this->operator[](v) = base_ptr[offsets[v]];
    * @endcode
    */
@@ -1132,13 +1118,13 @@ public:
 
   /**
    * Write the content of the calling class into memory in form of @p
-   * n_array_elements to the given address and the given offsets, filling the
+   * size() to the given address and the given offsets, filling the
    * elements of the vectorized array into each offset.
    *
    * This operation corresponds to the following code (but uses a more
    * efficient implementation in case the hardware allows for that):
    * @code
-   * for (unsigned int v=0; v<VectorizedArray<Number>::n_array_elements; ++v)
+   * for (unsigned int v=0; v<VectorizedArray<Number>::size(); ++v)
    *   base_ptr[offsets[v]] = this->operator[](v);
    * @endcode
    */
@@ -1498,7 +1484,7 @@ vectorized_transpose_and_store(const bool                        add_into,
  */
 template <>
 class VectorizedArray<float, 16>
-  : public VectorizedArrayBase<VectorizedArray<float, 16>>
+  : public VectorizedArrayBase<VectorizedArray<float, 16>, 16>
 {
 public:
   /**
@@ -1509,7 +1495,7 @@ public:
   /**
    * This gives the number of vectors collected in this class.
    */
-  static const unsigned int n_array_elements = 16;
+  DEAL_II_DEPRECATED static const unsigned int n_array_elements = 16;
 
   /**
    * Default empty constructor, leaving the data in an uninitialized state
@@ -1621,7 +1607,7 @@ public:
   }
 
   /**
-   * Load @p n_array_elements from memory into the calling class, starting at
+   * Load @p size() from memory into the calling class, starting at
    * the given address. The memory need not be aligned by 64 bytes, as opposed
    * to casting a float address to VectorizedArray<float>*.
    */
@@ -1634,7 +1620,7 @@ public:
 
   /**
    * Write the content of the calling class into memory in form of @p
-   * n_array_elements to the given address. The memory need not be aligned by
+   * size() to the given address. The memory need not be aligned by
    * 64 bytes, as opposed to casting a float address to
    * VectorizedArray<float>*.
    */
@@ -1658,14 +1644,14 @@ public:
   }
 
   /**
-   * Load @p n_array_elements from memory into the calling class, starting at
+   * Load @p size() from memory into the calling class, starting at
    * the given address and with given offsets, each entry from the offset
    * providing one element of the vectorized array.
    *
    * This operation corresponds to the following code (but uses a more
    * efficient implementation in case the hardware allows for that):
    * @code
-   * for (unsigned int v=0; v<VectorizedArray<Number>::n_array_elements; ++v)
+   * for (unsigned int v=0; v<VectorizedArray<Number>::size(); ++v)
    *   this->operator[](v) = base_ptr[offsets[v]];
    * @endcode
    */
@@ -1684,13 +1670,13 @@ public:
 
   /**
    * Write the content of the calling class into memory in form of @p
-   * n_array_elements to the given address and the given offsets, filling the
+   * size() to the given address and the given offsets, filling the
    * elements of the vectorized array into each offset.
    *
    * This operation corresponds to the following code (but uses a more
    * efficient implementation in case the hardware allows for that):
    * @code
-   * for (unsigned int v=0; v<VectorizedArray<Number>::n_array_elements; ++v)
+   * for (unsigned int v=0; v<VectorizedArray<Number>::size(); ++v)
    *   base_ptr[offsets[v]] = this->operator[](v);
    * @endcode
    */
@@ -2146,7 +2132,7 @@ vectorized_transpose_and_store(const bool                        add_into,
  */
 template <>
 class VectorizedArray<double, 4>
-  : public VectorizedArrayBase<VectorizedArray<double, 4>>
+  : public VectorizedArrayBase<VectorizedArray<double, 4>, 4>
 {
 public:
   /**
@@ -2157,7 +2143,7 @@ public:
   /**
    * This gives the number of vectors collected in this class.
    */
-  static const unsigned int n_array_elements = 4;
+  DEAL_II_DEPRECATED static const unsigned int n_array_elements = 4;
 
   /**
    * Default empty constructor, leaving the data in an uninitialized state
@@ -2269,7 +2255,7 @@ public:
   }
 
   /**
-   * Load @p n_array_elements from memory into the calling class, starting at
+   * Load @p size() from memory into the calling class, starting at
    * the given address. The memory need not be aligned by 32 bytes, as opposed
    * to casting a double address to VectorizedArray<double>*.
    */
@@ -2282,7 +2268,7 @@ public:
 
   /**
    * Write the content of the calling class into memory in form of @p
-   * n_array_elements to the given address. The memory need not be aligned by
+   * size() to the given address. The memory need not be aligned by
    * 32 bytes, as opposed to casting a double address to
    * VectorizedArray<double>*.
    */
@@ -2306,14 +2292,14 @@ public:
   }
 
   /**
-   * Load @p n_array_elements from memory into the calling class, starting at
+   * Load @p size() from memory into the calling class, starting at
    * the given address and with given offsets, each entry from the offset
    * providing one element of the vectorized array.
    *
    * This operation corresponds to the following code (but uses a more
    * efficient implementation in case the hardware allows for that):
    * @code
-   * for (unsigned int v=0; v<VectorizedArray<Number>::n_array_elements; ++v)
+   * for (unsigned int v=0; v<VectorizedArray<Number>::size(); ++v)
    *   this->operator[](v) = base_ptr[offsets[v]];
    * @endcode
    */
@@ -2337,13 +2323,13 @@ public:
 
   /**
    * Write the content of the calling class into memory in form of @p
-   * n_array_elements to the given address and the given offsets, filling the
+   * size() to the given address and the given offsets, filling the
    * elements of the vectorized array into each offset.
    *
    * This operation corresponds to the following code (but uses a more
    * efficient implementation in case the hardware allows for that):
    * @code
-   * for (unsigned int v=0; v<VectorizedArray<Number>::n_array_elements; ++v)
+   * for (unsigned int v=0; v<VectorizedArray<Number>::size(); ++v)
    *   base_ptr[offsets[v]] = this->operator[](v);
    * @endcode
    */
@@ -2657,7 +2643,7 @@ vectorized_transpose_and_store(const bool                        add_into,
  */
 template <>
 class VectorizedArray<float, 8>
-  : public VectorizedArrayBase<VectorizedArray<float, 8>>
+  : public VectorizedArrayBase<VectorizedArray<float, 8>, 8>
 {
 public:
   /**
@@ -2668,7 +2654,7 @@ public:
   /**
    * This gives the number of vectors collected in this class.
    */
-  static const unsigned int n_array_elements = 8;
+  DEAL_II_DEPRECATED static const unsigned int n_array_elements = 8;
 
   /**
    * Default empty constructor, leaving the data in an uninitialized state
@@ -2780,7 +2766,7 @@ public:
   }
 
   /**
-   * Load @p n_array_elements from memory into the calling class, starting at
+   * Load @p size() from memory into the calling class, starting at
    * the given address. The memory need not be aligned by 32 bytes, as opposed
    * to casting a float address to VectorizedArray<float>*.
    */
@@ -2793,7 +2779,7 @@ public:
 
   /**
    * Write the content of the calling class into memory in form of @p
-   * n_array_elements to the given address. The memory need not be aligned by
+   * size() to the given address. The memory need not be aligned by
    * 32 bytes, as opposed to casting a float address to
    * VectorizedArray<float>*.
    */
@@ -2817,14 +2803,14 @@ public:
   }
 
   /**
-   * Load @p n_array_elements from memory into the calling class, starting at
+   * Load @p size() from memory into the calling class, starting at
    * the given address and with given offsets, each entry from the offset
    * providing one element of the vectorized array.
    *
    * This operation corresponds to the following code (but uses a more
    * efficient implementation in case the hardware allows for that):
    * @code
-   * for (unsigned int v=0; v<VectorizedArray<Number>::n_array_elements; ++v)
+   * for (unsigned int v=0; v<VectorizedArray<Number>::size(); ++v)
    *   this->operator[](v) = base_ptr[offsets[v]];
    * @endcode
    */
@@ -2848,13 +2834,13 @@ public:
 
   /**
    * Write the content of the calling class into memory in form of @p
-   * n_array_elements to the given address and the given offsets, filling the
+   * size() to the given address and the given offsets, filling the
    * elements of the vectorized array into each offset.
    *
    * This operation corresponds to the following code (but uses a more
    * efficient implementation in case the hardware allows for that):
    * @code
-   * for (unsigned int v=0; v<VectorizedArray<Number>::n_array_elements; ++v)
+   * for (unsigned int v=0; v<VectorizedArray<Number>::size(); ++v)
    *   base_ptr[offsets[v]] = this->operator[](v);
    * @endcode
    */
@@ -3202,7 +3188,7 @@ vectorized_transpose_and_store(const bool                       add_into,
  */
 template <>
 class VectorizedArray<double, 2>
-  : public VectorizedArrayBase<VectorizedArray<double, 2>>
+  : public VectorizedArrayBase<VectorizedArray<double, 2>, 2>
 {
 public:
   /**
@@ -3213,7 +3199,7 @@ public:
   /**
    * This gives the number of vectors collected in this class.
    */
-  static const unsigned int n_array_elements = 2;
+  DEAL_II_DEPRECATED static const unsigned int n_array_elements = 2;
 
   /**
    * Default empty constructor, leaving the data in an uninitialized state
@@ -3321,7 +3307,7 @@ public:
   }
 
   /**
-   * Load @p n_array_elements from memory into the calling class, starting at
+   * Load @p size() from memory into the calling class, starting at
    * the given address. The memory need not be aligned by 16 bytes, as opposed
    * to casting a double address to VectorizedArray<double>*.
    */
@@ -3334,7 +3320,7 @@ public:
 
   /**
    * Write the content of the calling class into memory in form of @p
-   * n_array_elements to the given address. The memory need not be aligned by
+   * size() to the given address. The memory need not be aligned by
    * 16 bytes, as opposed to casting a double address to
    * VectorizedArray<double>*.
    */
@@ -3358,14 +3344,14 @@ public:
   }
 
   /**
-   * Load @p n_array_elements from memory into the calling class, starting at
+   * Load @p size() from memory into the calling class, starting at
    * the given address and with given offsets, each entry from the offset
    * providing one element of the vectorized array.
    *
    * This operation corresponds to the following code (but uses a more
    * efficient implementation in case the hardware allows for that):
    * @code
-   * for (unsigned int v=0; v<VectorizedArray<Number>::n_array_elements; ++v)
+   * for (unsigned int v=0; v<VectorizedArray<Number>::size(); ++v)
    *   this->operator[](v) = base_ptr[offsets[v]];
    * @endcode
    */
@@ -3379,13 +3365,13 @@ public:
 
   /**
    * Write the content of the calling class into memory in form of @p
-   * n_array_elements to the given address and the given offsets, filling the
+   * size() to the given address and the given offsets, filling the
    * elements of the vectorized array into each offset.
    *
    * This operation corresponds to the following code (but uses a more
    * efficient implementation in case the hardware allows for that):
    * @code
-   * for (unsigned int v=0; v<VectorizedArray<Number>::n_array_elements; ++v)
+   * for (unsigned int v=0; v<VectorizedArray<Number>::size(); ++v)
    *   base_ptr[offsets[v]] = this->operator[](v);
    * @endcode
    */
@@ -3643,7 +3629,7 @@ vectorized_transpose_and_store(const bool                        add_into,
  */
 template <>
 class VectorizedArray<float, 4>
-  : public VectorizedArrayBase<VectorizedArray<float, 4>>
+  : public VectorizedArrayBase<VectorizedArray<float, 4>, 4>
 {
 public:
   /**
@@ -3654,7 +3640,7 @@ public:
   /**
    * This gives the number of vectors collected in this class.
    */
-  static const unsigned int n_array_elements = 4;
+  DEAL_II_DEPRECATED static const unsigned int n_array_elements = 4;
 
   /**
    * This function can be used to set all data fields to a given scalar.
@@ -3763,7 +3749,7 @@ public:
   }
 
   /**
-   * Load @p n_array_elements from memory into the calling class, starting at
+   * Load @p size() from memory into the calling class, starting at
    * the given address. The memory need not be aligned by 16 bytes, as opposed
    * to casting a float address to VectorizedArray<float>*.
    */
@@ -3776,7 +3762,7 @@ public:
 
   /**
    * Write the content of the calling class into memory in form of @p
-   * n_array_elements to the given address. The memory need not be aligned by
+   * size() to the given address. The memory need not be aligned by
    * 16 bytes, as opposed to casting a float address to
    * VectorizedArray<float>*.
    */
@@ -3800,14 +3786,14 @@ public:
   }
 
   /**
-   * Load @p n_array_elements from memory into the calling class, starting at
+   * Load @p size() from memory into the calling class, starting at
    * the given address and with given offsets, each entry from the offset
    * providing one element of the vectorized array.
    *
    * This operation corresponds to the following code (but uses a more
    * efficient implementation in case the hardware allows for that):
    * @code
-   * for (unsigned int v=0; v<VectorizedArray<Number>::n_array_elements; ++v)
+   * for (unsigned int v=0; v<VectorizedArray<Number>::size(); ++v)
    *   this->operator[](v) = base_ptr[offsets[v]];
    * @endcode
    */
@@ -3821,13 +3807,13 @@ public:
 
   /**
    * Write the content of the calling class into memory in form of @p
-   * n_array_elements to the given address and the given offsets, filling the
+   * size() to the given address and the given offsets, filling the
    * elements of the vectorized array into each offset.
    *
    * This operation corresponds to the following code (but uses a more
    * efficient implementation in case the hardware allows for that):
    * @code
-   * for (unsigned int v=0; v<VectorizedArray<Number>::n_array_elements; ++v)
+   * for (unsigned int v=0; v<VectorizedArray<Number>::size(); ++v)
    *   base_ptr[offsets[v]] = this->operator[](v);
    * @endcode
    */
@@ -4122,7 +4108,7 @@ vectorized_transpose_and_store(const bool                       add_into,
 
 template <>
 class VectorizedArray<double, 2>
-  : public VectorizedArrayBase<VectorizedArray<double, 2>>
+  : public VectorizedArrayBase<VectorizedArray<double, 2>, 2>
 {
 public:
   /**
@@ -4133,7 +4119,7 @@ public:
   /**
    * This gives the number of vectors collected in this class.
    */
-  static const unsigned int n_array_elements = 2;
+  DEAL_II_DEPRECATED static const unsigned int n_array_elements = 2;
 
   /**
    * Default empty constructor, leaving the data in an uninitialized state
@@ -4230,7 +4216,7 @@ public:
   }
 
   /**
-   * Load @p n_array_elements from memory into the calling class, starting at
+   * Load @p size() from memory into the calling class, starting at
    * the given address.
    */
   DEAL_II_ALWAYS_INLINE
@@ -4242,7 +4228,7 @@ public:
 
   /**
    * Write the content of the calling class into memory in form of @p
-   * n_array_elements to the given address.
+   * size() to the given address.
    */
   DEAL_II_ALWAYS_INLINE
   void
@@ -4361,7 +4347,7 @@ private:
 
 template <>
 class VectorizedArray<float, 4>
-  : public VectorizedArrayBase<VectorizedArray<float, 4>>
+  : public VectorizedArrayBase<VectorizedArray<float, 4>, 4>
 {
 public:
   /**
@@ -4372,7 +4358,7 @@ public:
   /**
    * This gives the number of vectors collected in this class.
    */
-  static const unsigned int n_array_elements = 4;
+  DEAL_II_DEPRECATED static const unsigned int n_array_elements = 4;
 
   /**
    * Default empty constructor, leaving the data in an uninitialized state
@@ -4469,7 +4455,7 @@ public:
   }
 
   /**
-   * Load @p n_array_elements from memory into the calling class, starting at
+   * Load @p size() from memory into the calling class, starting at
    * the given address.
    */
   DEAL_II_ALWAYS_INLINE
@@ -4481,7 +4467,7 @@ public:
 
   /**
    * Write the content of the calling class into memory in form of @p
-   * n_array_elements to the given address.
+   * size() to the given address.
    */
   DEAL_II_ALWAYS_INLINE
   void
@@ -4617,8 +4603,7 @@ inline DEAL_II_ALWAYS_INLINE bool
 operator==(const VectorizedArray<Number, width> &lhs,
            const VectorizedArray<Number, width> &rhs)
 {
-  for (unsigned int i = 0; i < VectorizedArray<Number, width>::n_array_elements;
-       ++i)
+  for (unsigned int i = 0; i < VectorizedArray<Number, width>::size(); ++i)
     if (lhs[i] != rhs[i])
       return false;
 
@@ -4684,7 +4669,7 @@ inline DEAL_II_ALWAYS_INLINE VectorizedArray<Number, width>
 
 /**
  * Addition of a scalar (expanded to a vectorized array with @p
- * n_array_elements equal entries) and a vectorized array.
+ * size() equal entries) and a vectorized array.
  *
  * @relatesalso VectorizedArray
  */
@@ -4698,7 +4683,7 @@ inline DEAL_II_ALWAYS_INLINE VectorizedArray<Number, width>
 
 /**
  * Addition of a scalar (expanded to a vectorized array with @p
- * n_array_elements equal entries) and a vectorized array in case the scalar
+ * size() equal entries) and a vectorized array in case the scalar
  * is a double (needed in order to be able to write simple code with constants
  * that are usually double numbers).
  *
@@ -4714,7 +4699,7 @@ inline DEAL_II_ALWAYS_INLINE VectorizedArray<float, width>
 
 /**
  * Addition of a vectorized array and a scalar (expanded to a vectorized array
- * with @p n_array_elements equal entries).
+ * with @p size() equal entries).
  *
  * @relatesalso VectorizedArray
  */
@@ -4727,7 +4712,7 @@ inline DEAL_II_ALWAYS_INLINE VectorizedArray<Number, width>
 
 /**
  * Addition of a vectorized array and a scalar (expanded to a vectorized array
- * with @p n_array_elements equal entries) in case the scalar is a double
+ * with @p size() equal entries) in case the scalar is a double
  * (needed in order to be able to write simple code with constants that are
  * usually double numbers).
  *
@@ -4742,7 +4727,7 @@ inline DEAL_II_ALWAYS_INLINE VectorizedArray<float, width>
 
 /**
  * Subtraction of a vectorized array from a scalar (expanded to a vectorized
- * array with @p n_array_elements equal entries).
+ * array with @p size() equal entries).
  *
  * @relatesalso VectorizedArray
  */
@@ -4756,7 +4741,7 @@ inline DEAL_II_ALWAYS_INLINE VectorizedArray<Number, width>
 
 /**
  * Subtraction of a vectorized array from a scalar (expanded to a vectorized
- * array with @p n_array_elements equal entries) in case the scalar is a
+ * array with @p size() equal entries) in case the scalar is a
  * double (needed in order to be able to write simple code with constants that
  * are usually double numbers).
  *
@@ -4772,7 +4757,7 @@ inline DEAL_II_ALWAYS_INLINE VectorizedArray<float, width>
 
 /**
  * Subtraction of a scalar (expanded to a vectorized array with @p
- * n_array_elements equal entries) from a vectorized array.
+ * size() equal entries) from a vectorized array.
  *
  * @relatesalso VectorizedArray
  */
@@ -4786,7 +4771,7 @@ inline DEAL_II_ALWAYS_INLINE VectorizedArray<Number, width>
 
 /**
  * Subtraction of a scalar (expanded to a vectorized array with @p
- * n_array_elements equal entries) from a vectorized array in case the scalar
+ * size() equal entries) from a vectorized array in case the scalar
  * is a double (needed in order to be able to write simple code with constants
  * that are usually double numbers).
  *
@@ -4802,7 +4787,7 @@ inline DEAL_II_ALWAYS_INLINE VectorizedArray<float, width>
 
 /**
  * Multiplication of a scalar (expanded to a vectorized array with @p
- * n_array_elements equal entries) and a vectorized array.
+ * size() equal entries) and a vectorized array.
  *
  * @relatesalso VectorizedArray
  */
@@ -4816,7 +4801,7 @@ inline DEAL_II_ALWAYS_INLINE VectorizedArray<Number, width>
 
 /**
  * Multiplication of a scalar (expanded to a vectorized array with @p
- * n_array_elements equal entries) and a vectorized array in case the scalar
+ * size() equal entries) and a vectorized array in case the scalar
  * is a double (needed in order to be able to write simple code with constants
  * that are usually double numbers).
  *
@@ -4832,7 +4817,7 @@ inline DEAL_II_ALWAYS_INLINE VectorizedArray<float, width>
 
 /**
  * Multiplication of a vectorized array and a scalar (expanded to a vectorized
- * array with @p n_array_elements equal entries).
+ * array with @p size() equal entries).
  *
  * @relatesalso VectorizedArray
  */
@@ -4845,7 +4830,7 @@ inline DEAL_II_ALWAYS_INLINE VectorizedArray<Number, width>
 
 /**
  * Multiplication of a vectorized array and a scalar (expanded to a vectorized
- * array with @p n_array_elements equal entries) in case the scalar is a
+ * array with @p size() equal entries) in case the scalar is a
  * double (needed in order to be able to write simple code with constants that
  * are usually double numbers).
  *
@@ -4860,7 +4845,7 @@ inline DEAL_II_ALWAYS_INLINE VectorizedArray<float, width>
 
 /**
  * Quotient between a scalar (expanded to a vectorized array with @p
- * n_array_elements equal entries) and a vectorized array.
+ * size() equal entries) and a vectorized array.
  *
  * @relatesalso VectorizedArray
  */
@@ -4874,7 +4859,7 @@ inline DEAL_II_ALWAYS_INLINE VectorizedArray<Number, width>
 
 /**
  * Quotient between a scalar (expanded to a vectorized array with @p
- * n_array_elements equal entries) and a vectorized array in case the scalar
+ * size() equal entries) and a vectorized array in case the scalar
  * is a double (needed in order to be able to write simple code with constants
  * that are usually double numbers).
  *
@@ -4890,7 +4875,7 @@ inline DEAL_II_ALWAYS_INLINE VectorizedArray<float, width>
 
 /**
  * Quotient between a vectorized array and a scalar (expanded to a vectorized
- * array with @p n_array_elements equal entries).
+ * array with @p size() equal entries).
  *
  * @relatesalso VectorizedArray
  */
@@ -4904,7 +4889,7 @@ inline DEAL_II_ALWAYS_INLINE VectorizedArray<Number, width>
 
 /**
  * Quotient between a vectorized array and a scalar (expanded to a vectorized
- * array with @p n_array_elements equal entries) in case the scalar is a
+ * array with @p size() equal entries) in case the scalar is a
  * double (needed in order to be able to write simple code with constants that
  * are usually double numbers).
  *
@@ -4953,7 +4938,7 @@ template <typename Number, std::size_t width>
 inline std::ostream &
 operator<<(std::ostream &out, const VectorizedArray<Number, width> &p)
 {
-  constexpr unsigned int n = VectorizedArray<Number, width>::n_array_elements;
+  constexpr unsigned int n = VectorizedArray<Number, width>::size();
   for (unsigned int i = 0; i < n - 1; ++i)
     out << p[i] << ' ';
   out << p[n - 1];
@@ -5280,7 +5265,7 @@ namespace std
   /**
    * Compute the sine of a vectorized data field. The result is returned as
    * vectorized array in the form <tt>{sin(x[0]), sin(x[1]), ...,
-   * sin(x[n_array_elements-1])}</tt>.
+   * sin(x[VectorizedArray::size()-1])}</tt>.
    *
    * @relatesalso VectorizedArray
    */
@@ -5293,9 +5278,8 @@ namespace std
     // setting the individual elements and also circumvents a compiler
     // optimization bug in gcc-4.6 with SSE2 (see also deal.II developers list
     // from April 2014, topic "matrix_free/step-48 Test").
-    Number values[::dealii::VectorizedArray<Number, width>::n_array_elements];
-    for (unsigned int i = 0;
-         i < dealii::VectorizedArray<Number, width>::n_array_elements;
+    Number values[::dealii::VectorizedArray<Number, width>::size()];
+    for (unsigned int i = 0; i < dealii::VectorizedArray<Number, width>::size();
          ++i)
       values[i] = std::sin(x[i]);
     ::dealii::VectorizedArray<Number, width> out;
@@ -5308,7 +5292,7 @@ namespace std
   /**
    * Compute the cosine of a vectorized data field. The result is returned as
    * vectorized array in the form <tt>{cos(x[0]), cos(x[1]), ...,
-   * cos(x[n_array_elements-1])}</tt>.
+   * cos(x[size()-1])}</tt>.
    *
    * @relatesalso VectorizedArray
    */
@@ -5316,9 +5300,8 @@ namespace std
   inline ::dealii::VectorizedArray<Number, width>
   cos(const ::dealii::VectorizedArray<Number, width> &x)
   {
-    Number values[::dealii::VectorizedArray<Number, width>::n_array_elements];
-    for (unsigned int i = 0;
-         i < dealii::VectorizedArray<Number, width>::n_array_elements;
+    Number values[::dealii::VectorizedArray<Number, width>::size()];
+    for (unsigned int i = 0; i < dealii::VectorizedArray<Number, width>::size();
          ++i)
       values[i] = std::cos(x[i]);
     ::dealii::VectorizedArray<Number, width> out;
@@ -5331,7 +5314,7 @@ namespace std
   /**
    * Compute the tangent of a vectorized data field. The result is returned
    * as vectorized array in the form <tt>{tan(x[0]), tan(x[1]), ...,
-   * tan(x[n_array_elements-1])}</tt>.
+   * tan(x[size()-1])}</tt>.
    *
    * @relatesalso VectorizedArray
    */
@@ -5339,9 +5322,8 @@ namespace std
   inline ::dealii::VectorizedArray<Number, width>
   tan(const ::dealii::VectorizedArray<Number, width> &x)
   {
-    Number values[::dealii::VectorizedArray<Number, width>::n_array_elements];
-    for (unsigned int i = 0;
-         i < dealii::VectorizedArray<Number, width>::n_array_elements;
+    Number values[::dealii::VectorizedArray<Number, width>::size()];
+    for (unsigned int i = 0; i < dealii::VectorizedArray<Number, width>::size();
          ++i)
       values[i] = std::tan(x[i]);
     ::dealii::VectorizedArray<Number, width> out;
@@ -5354,7 +5336,7 @@ namespace std
   /**
    * Compute the exponential of a vectorized data field. The result is
    * returned as vectorized array in the form <tt>{exp(x[0]), exp(x[1]), ...,
-   * exp(x[n_array_elements-1])}</tt>.
+   * exp(x[size()-1])}</tt>.
    *
    * @relatesalso VectorizedArray
    */
@@ -5362,9 +5344,8 @@ namespace std
   inline ::dealii::VectorizedArray<Number, width>
   exp(const ::dealii::VectorizedArray<Number, width> &x)
   {
-    Number values[::dealii::VectorizedArray<Number, width>::n_array_elements];
-    for (unsigned int i = 0;
-         i < dealii::VectorizedArray<Number, width>::n_array_elements;
+    Number values[::dealii::VectorizedArray<Number, width>::size()];
+    for (unsigned int i = 0; i < dealii::VectorizedArray<Number, width>::size();
          ++i)
       values[i] = std::exp(x[i]);
     ::dealii::VectorizedArray<Number, width> out;
@@ -5377,7 +5358,7 @@ namespace std
   /**
    * Compute the natural logarithm of a vectorized data field. The result is
    * returned as vectorized array in the form <tt>{log(x[0]), log(x[1]), ...,
-   * log(x[n_array_elements-1])}</tt>.
+   * log(x[size()-1])}</tt>.
    *
    * @relatesalso VectorizedArray
    */
@@ -5385,9 +5366,8 @@ namespace std
   inline ::dealii::VectorizedArray<Number, width>
   log(const ::dealii::VectorizedArray<Number, width> &x)
   {
-    Number values[::dealii::VectorizedArray<Number, width>::n_array_elements];
-    for (unsigned int i = 0;
-         i < dealii::VectorizedArray<Number, width>::n_array_elements;
+    Number values[::dealii::VectorizedArray<Number, width>::size()];
+    for (unsigned int i = 0; i < dealii::VectorizedArray<Number, width>::size();
          ++i)
       values[i] = std::log(x[i]);
     ::dealii::VectorizedArray<Number, width> out;
@@ -5400,7 +5380,7 @@ namespace std
   /**
    * Compute the square root of a vectorized data field. The result is
    * returned as vectorized array in the form <tt>{sqrt(x[0]), sqrt(x[1]),
-   * ..., sqrt(x[n_array_elements-1])}</tt>.
+   * ..., sqrt(x[size()-1])}</tt>.
    *
    * @relatesalso VectorizedArray
    */
@@ -5416,7 +5396,7 @@ namespace std
   /**
    * Raises the given number @p x to the power @p p for a vectorized data
    * field. The result is returned as vectorized array in the form
-   * <tt>{pow(x[0],p), pow(x[1],p), ..., pow(x[n_array_elements-1],p)}</tt>.
+   * <tt>{pow(x[0],p), pow(x[1],p), ..., pow(x[size()-1],p)}</tt>.
    *
    * @relatesalso VectorizedArray
    */
@@ -5424,9 +5404,8 @@ namespace std
   inline ::dealii::VectorizedArray<Number, width>
   pow(const ::dealii::VectorizedArray<Number, width> &x, const Number p)
   {
-    Number values[::dealii::VectorizedArray<Number, width>::n_array_elements];
-    for (unsigned int i = 0;
-         i < dealii::VectorizedArray<Number, width>::n_array_elements;
+    Number values[::dealii::VectorizedArray<Number, width>::size()];
+    for (unsigned int i = 0; i < dealii::VectorizedArray<Number, width>::size();
          ++i)
       values[i] = std::pow(x[i], p);
     ::dealii::VectorizedArray<Number, width> out;
@@ -5439,7 +5418,7 @@ namespace std
   /**
    * Compute the absolute value (modulus) of a vectorized data field. The
    * result is returned as vectorized array in the form <tt>{abs(x[0]),
-   * abs(x[1]), ..., abs(x[n_array_elements-1])}</tt>.
+   * abs(x[1]), ..., abs(x[size()-1])}</tt>.
    *
    * @relatesalso VectorizedArray
    */
index fba0b39829887cdd7524e3c0b417ecb839b36415..061ff661eebfbeda635d21f9f7a65869ccf902cf 100644 (file)
@@ -799,7 +799,7 @@ TensorProductMatrixSymmetricSum<dim, VectorizedArray<Number>, n_rows_1d>::
   this->mass_matrix        = mass_matrix;
   this->derivative_matrix  = derivative_matrix;
 
-  constexpr unsigned int macro_size = VectorizedArray<Number>::n_array_elements;
+  constexpr unsigned int macro_size = VectorizedArray<Number>::size();
   std::size_t            n_rows_max = (n_rows_1d > 0) ? n_rows_1d : 0;
   if (n_rows_1d == -1)
     for (unsigned int d = 0; d < dim; ++d)
index 21d72a733511601bd56fedbfd6aa5421b70f4906..d4c4cd6e5e8cfe5acaebd1b0a3f24101f6469f59 100644 (file)
@@ -764,9 +764,8 @@ namespace internal
     template <typename Number, typename Number2>
     struct Dot
     {
-      static const bool vectorizes =
-        std::is_same<Number, Number2>::value &&
-        (VectorizedArray<Number>::n_array_elements > 1);
+      static constexpr bool vectorizes = std::is_same<Number, Number2>::value &&
+                                         (VectorizedArray<Number>::size() > 1);
 
       Dot(const Number *const X, const Number2 *const Y)
         : X(X)
@@ -806,8 +805,7 @@ namespace internal
     template <typename Number, typename RealType>
     struct Norm2
     {
-      static const bool vectorizes =
-        VectorizedArray<Number>::n_array_elements > 1;
+      static const bool vectorizes = VectorizedArray<Number>::size() > 1;
 
       Norm2(const Number *const X)
         : X(X)
@@ -833,8 +831,7 @@ namespace internal
     template <typename Number, typename RealType>
     struct Norm1
     {
-      static const bool vectorizes =
-        VectorizedArray<Number>::n_array_elements > 1;
+      static const bool vectorizes = VectorizedArray<Number>::size() > 1;
 
       Norm1(const Number *X)
         : X(X)
@@ -860,8 +857,7 @@ namespace internal
     template <typename Number, typename RealType>
     struct NormP
     {
-      static const bool vectorizes =
-        VectorizedArray<Number>::n_array_elements > 1;
+      static const bool vectorizes = VectorizedArray<Number>::size() > 1;
 
       NormP(const Number *X, RealType p)
         : X(X)
@@ -889,8 +885,7 @@ namespace internal
     template <typename Number>
     struct MeanValue
     {
-      static const bool vectorizes =
-        VectorizedArray<Number>::n_array_elements > 1;
+      static const bool vectorizes = VectorizedArray<Number>::size() > 1;
 
       MeanValue(const Number *X)
         : X(X)
@@ -916,8 +911,7 @@ namespace internal
     template <typename Number>
     struct AddAndDot
     {
-      static const bool vectorizes =
-        VectorizedArray<Number>::n_array_elements > 1;
+      static const bool vectorizes = VectorizedArray<Number>::size() > 1;
 
       AddAndDot(Number *const       X,
                 const Number *const V,
@@ -1202,8 +1196,8 @@ namespace internal
       // First we work on (n_chunks/nvecs) chunks, where each chunk processes
       // nvecs*(4*8) elements.
 
-      const unsigned int nvecs = VectorizedArray<Number>::n_array_elements;
-      const size_type    regular_chunks = n_chunks / nvecs;
+      constexpr unsigned int nvecs          = VectorizedArray<Number>::size();
+      const size_type        regular_chunks = n_chunks / nvecs;
       for (size_type i = 0; i < regular_chunks; ++i)
         {
           VectorizedArray<Number> r0 = op.do_vectorized(index);
@@ -1221,8 +1215,7 @@ namespace internal
           r0 += r1;
           r2 += r3;
           r0 += r2;
-          r0.store(
-            &outer_results[i * VectorizedArray<Number>::n_array_elements]);
+          r0.store(&outer_results[i * nvecs]);
         }
 
       // If we are treating a case where the vector length is not divisible by
@@ -1231,9 +1224,12 @@ namespace internal
       // regular_chunks * nvecs; We do as much as possible with 2 SIMD
       // operations within each chunk. Here we assume that nvecs < 32/2 = 16 as
       // well as 16%nvecs==0.
-      AssertIndexRange(VectorizedArray<Number>::n_array_elements, 17);
+      static_assert(
+        VectorizedArray<Number>::size() <= 16 &&
+          16 % VectorizedArray<Number>::size() == 0,
+        "VectorizedArray::size() must be a power of 2 and not more than 16");
       Assert(16 % nvecs == 0, ExcInternalError());
-      if (n_chunks % VectorizedArray<Number>::n_array_elements != 0)
+      if (n_chunks % nvecs != 0)
         {
           VectorizedArray<Number> r0  = VectorizedArray<Number>(),
                                   r1  = VectorizedArray<Number>();
@@ -1248,7 +1244,7 @@ namespace internal
           r0.store(&outer_results[start_irreg]);
           // update n_chunks to denote unused element in outer_results[] from
           // which we can keep writing.
-          n_chunks = start_irreg + VectorizedArray<Number>::n_array_elements;
+          n_chunks = start_irreg + VectorizedArray<Number>::size();
         }
     }
 
index 37d684d30929cdc3448994617a611e70005e6d53..7da0f1bf1c68a5732d670ca5f599d04e44300d25 100644 (file)
@@ -381,7 +381,7 @@ namespace internal
        * cells batched together. As opposed to the other classes which are
        * templated on the number type, this class as a pure index container is
        * not templated, so we need to keep the information otherwise contained
-       * in VectorizedArrayType::n_array_elements.
+       * in VectorizedArrayType::size().
        */
       unsigned int vectorization_length;
 
index 79623b3e8ad805d799d1b50f7c884644b3de3ef6..090b9856258655588275d36b4ed669c79e8e3082 100644 (file)
@@ -1739,7 +1739,7 @@ namespace internal
   void
   do_vectorized_read(const Number2 *src_ptr, VectorizedArrayType &dst)
   {
-    for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements; ++v)
+    for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
       dst[v] = src_ptr[v];
   }
 
@@ -1763,7 +1763,7 @@ namespace internal
                        const unsigned int * indices,
                        VectorizedArrayType &dst)
   {
-    for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements; ++v)
+    for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
       dst[v] = src_ptr[indices[v]];
   }
 
@@ -1787,7 +1787,7 @@ namespace internal
   void
   do_vectorized_add(const VectorizedArrayType src, Number2 *dst_ptr)
   {
-    for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements; ++v)
+    for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
       dst_ptr[v] += src[v];
   }
 
@@ -1813,7 +1813,7 @@ namespace internal
                             const unsigned int *      indices,
                             Number2 *                 dst_ptr)
   {
-    for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements; ++v)
+    for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
       dst_ptr[indices[v]] += src[v];
   }
 
@@ -2089,13 +2089,14 @@ namespace internal
         {
           AssertDimension(
             dof_info.n_vectorization_lanes_filled[dof_access_index][cell],
-            VectorizedArrayType::n_array_elements);
+            VectorizedArrayType::size());
           const unsigned int dof_index =
-            dof_info.dof_indices_contiguous
-              [dof_access_index][cell * VectorizedArrayType::n_array_elements] +
+            dof_info
+              .dof_indices_contiguous[dof_access_index]
+                                     [cell * VectorizedArrayType::size()] +
             dof_info.component_dof_indices_offset[active_fe_index]
                                                  [first_selected_component] *
-              VectorizedArrayType::n_array_elements;
+              VectorizedArrayType::size();
 
           if (fe_degree > 1 && evaluate_gradients == true)
             {
@@ -2116,15 +2117,15 @@ namespace internal
                   AssertIndexRange(ind2, data.dofs_per_component_on_cell);
                   for (unsigned int comp = 0; comp < n_components; ++comp)
                     {
-                      do_vectorized_read(
-                        src_ptr + dof_index +
-                          (ind1 + comp * static_dofs_per_component) *
-                            VectorizedArrayType::n_array_elements,
-                        temp1[i + 2 * comp * dofs_per_face]);
+                      do_vectorized_read(src_ptr + dof_index +
+                                           (ind1 +
+                                            comp * static_dofs_per_component) *
+                                             VectorizedArrayType::size(),
+                                         temp1[i + 2 * comp * dofs_per_face]);
                       do_vectorized_read(
                         src_ptr + dof_index +
                           (ind2 + comp * static_dofs_per_component) *
-                            VectorizedArrayType::n_array_elements,
+                            VectorizedArrayType::size(),
                         temp1[dofs_per_face + i + 2 * comp * dofs_per_face]);
                       temp1[i + dofs_per_face + 2 * comp * dofs_per_face] =
                         grad_weight *
@@ -2143,11 +2144,11 @@ namespace internal
                 {
                   const unsigned int ind = index_array[i];
                   for (unsigned int comp = 0; comp < n_components; ++comp)
-                    do_vectorized_read(
-                      src_ptr + dof_index +
-                        (ind + comp * static_dofs_per_component) *
-                          VectorizedArrayType::n_array_elements,
-                      temp1[i + 2 * comp * dofs_per_face]);
+                    do_vectorized_read(src_ptr + dof_index +
+                                         (ind +
+                                          comp * static_dofs_per_component) *
+                                           VectorizedArrayType::size(),
+                                       temp1[i + 2 * comp * dofs_per_face]);
                 }
             }
         }
@@ -2164,10 +2165,11 @@ namespace internal
         {
           AssertDimension(
             dof_info.n_vectorization_lanes_filled[dof_access_index][cell],
-            VectorizedArrayType::n_array_elements);
+            VectorizedArrayType::size());
           const unsigned int *indices =
-            &dof_info.dof_indices_contiguous
-               [dof_access_index][cell * VectorizedArrayType::n_array_elements];
+            &dof_info
+               .dof_indices_contiguous[dof_access_index]
+                                      [cell * VectorizedArrayType::size()];
           if (fe_degree > 1 && evaluate_gradients == true)
             {
               // we know that the gradient weights for the Hermite case on the
@@ -2183,29 +2185,28 @@ namespace internal
               for (unsigned int i = 0; i < dofs_per_face; ++i)
                 {
                   const unsigned int ind1 =
-                    index_array[2 * i] * VectorizedArrayType::n_array_elements;
+                    index_array[2 * i] * VectorizedArrayType::size();
                   const unsigned int ind2 =
-                    index_array[2 * i + 1] *
-                    VectorizedArrayType::n_array_elements;
+                    index_array[2 * i + 1] * VectorizedArrayType::size();
                   for (unsigned int comp = 0; comp < n_components; ++comp)
                     {
                       do_vectorized_gather(
                         src_ptr + ind1 +
                           comp * static_dofs_per_component *
-                            VectorizedArrayType::n_array_elements +
+                            VectorizedArrayType::size() +
                           dof_info.component_dof_indices_offset
                               [active_fe_index][first_selected_component] *
-                            VectorizedArrayType::n_array_elements,
+                            VectorizedArrayType::size(),
                         indices,
                         temp1[i + 2 * comp * dofs_per_face]);
                       VectorizedArrayType grad;
                       do_vectorized_gather(
                         src_ptr + ind2 +
                           comp * static_dofs_per_component *
-                            VectorizedArrayType::n_array_elements +
+                            VectorizedArrayType::size() +
                           dof_info.component_dof_indices_offset
                               [active_fe_index][first_selected_component] *
-                            VectorizedArrayType::n_array_elements,
+                            VectorizedArrayType::size(),
                         indices,
                         grad);
                       temp1[i + dofs_per_face + 2 * comp * dofs_per_face] =
@@ -2223,15 +2224,15 @@ namespace internal
               for (unsigned int i = 0; i < dofs_per_face; ++i)
                 {
                   const unsigned int ind =
-                    index_array[i] * VectorizedArrayType::n_array_elements;
+                    index_array[i] * VectorizedArrayType::size();
                   for (unsigned int comp = 0; comp < n_components; ++comp)
                     do_vectorized_gather(
                       src_ptr + ind +
                         comp * static_dofs_per_component *
-                          VectorizedArrayType::n_array_elements +
+                          VectorizedArrayType::size() +
                         dof_info.component_dof_indices_offset
                             [active_fe_index][first_selected_component] *
-                          VectorizedArrayType::n_array_elements,
+                          VectorizedArrayType::size(),
                       indices,
                       temp1[i + 2 * comp * dofs_per_face]);
                 }
@@ -2250,14 +2251,12 @@ namespace internal
         {
           const unsigned int *strides =
             &dof_info.dof_indices_interleave_strides
-               [dof_access_index][cell * VectorizedArrayType::n_array_elements];
-          unsigned int indices[VectorizedArrayType::n_array_elements];
-          for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements;
-               ++v)
+               [dof_access_index][cell * VectorizedArrayType::size()];
+          unsigned int indices[VectorizedArrayType::size()];
+          for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
             indices[v] =
               dof_info.dof_indices_contiguous
-                [dof_access_index]
-                [cell * VectorizedArrayType::n_array_elements + v] +
+                [dof_access_index][cell * VectorizedArrayType::size() + v] +
               dof_info.component_dof_indices_offset[active_fe_index]
                                                    [first_selected_component] *
                 strides[v];
@@ -2276,23 +2275,21 @@ namespace internal
 
               const unsigned int *index_array =
                 &data.face_to_cell_index_hermite(face_no, 0);
-              if (nvec == VectorizedArrayType::n_array_elements)
+              if (nvec == VectorizedArrayType::size())
                 for (unsigned int comp = 0; comp < n_components; ++comp)
                   for (unsigned int i = 0; i < dofs_per_face; ++i)
                     {
-                      unsigned int ind1[VectorizedArrayType::n_array_elements];
+                      unsigned int ind1[VectorizedArrayType::size()];
                       DEAL_II_OPENMP_SIMD_PRAGMA
-                      for (unsigned int v = 0;
-                           v < VectorizedArrayType::n_array_elements;
+                      for (unsigned int v = 0; v < VectorizedArrayType::size();
                            ++v)
                         ind1[v] =
                           indices[v] + (comp * static_dofs_per_component +
                                         index_array[2 * i]) *
                                          strides[v];
-                      unsigned int ind2[VectorizedArrayType::n_array_elements];
+                      unsigned int ind2[VectorizedArrayType::size()];
                       DEAL_II_OPENMP_SIMD_PRAGMA
-                      for (unsigned int v = 0;
-                           v < VectorizedArrayType::n_array_elements;
+                      for (unsigned int v = 0; v < VectorizedArrayType::size();
                            ++v)
                         ind2[v] =
                           indices[v] + (comp * static_dofs_per_component +
@@ -2340,14 +2337,13 @@ namespace internal
                               dofs_per_face);
               const unsigned int *index_array =
                 &data.face_to_cell_index_nodal(face_no, 0);
-              if (nvec == VectorizedArrayType::n_array_elements)
+              if (nvec == VectorizedArrayType::size())
                 for (unsigned int comp = 0; comp < n_components; ++comp)
                   for (unsigned int i = 0; i < dofs_per_face; ++i)
                     {
-                      unsigned int ind[VectorizedArrayType::n_array_elements];
+                      unsigned int ind[VectorizedArrayType::size()];
                       DEAL_II_OPENMP_SIMD_PRAGMA
-                      for (unsigned int v = 0;
-                           v < VectorizedArrayType::n_array_elements;
+                      for (unsigned int v = 0; v < VectorizedArrayType::size();
                            ++v)
                         ind[v] =
                           indices[v] +
@@ -2387,11 +2383,12 @@ namespace internal
                  MatrixFreeFunctions::DoFInfo::IndexStorageVariants::
                    contiguous &&
                dof_info.n_vectorization_lanes_filled[dof_access_index][cell] ==
-                 VectorizedArrayType::n_array_elements)
+                 VectorizedArrayType::size())
         {
           const unsigned int *indices =
-            &dof_info.dof_indices_contiguous
-               [dof_access_index][cell * VectorizedArrayType::n_array_elements];
+            &dof_info
+               .dof_indices_contiguous[dof_access_index]
+                                      [cell * VectorizedArrayType::size()];
           if (evaluate_gradients == true &&
               data.element_type ==
                 MatrixFreeFunctions::tensor_symmetric_hermite)
@@ -2607,13 +2604,14 @@ namespace internal
         {
           AssertDimension(
             dof_info.n_vectorization_lanes_filled[dof_access_index][cell],
-            VectorizedArrayType::n_array_elements);
+            VectorizedArrayType::size());
           const unsigned int dof_index =
-            dof_info.dof_indices_contiguous
-              [dof_access_index][cell * VectorizedArrayType::n_array_elements] +
+            dof_info
+              .dof_indices_contiguous[dof_access_index]
+                                     [cell * VectorizedArrayType::size()] +
             dof_info.component_dof_indices_offset[active_fe_index]
                                                  [first_selected_component] *
-              VectorizedArrayType::n_array_elements;
+              VectorizedArrayType::size();
 
           if (fe_degree > 1 && integrate_gradients == true)
             {
@@ -2641,16 +2639,16 @@ namespace internal
                       VectorizedArrayType grad =
                         grad_weight *
                         temp1[i + dofs_per_face + 2 * comp * dofs_per_face];
-                      do_vectorized_add(
-                        val,
-                        dst_ptr + dof_index +
-                          (ind1 + comp * static_dofs_per_component) *
-                            VectorizedArrayType::n_array_elements);
-                      do_vectorized_add(
-                        grad,
-                        dst_ptr + dof_index +
-                          (ind2 + comp * static_dofs_per_component) *
-                            VectorizedArrayType::n_array_elements);
+                      do_vectorized_add(val,
+                                        dst_ptr + dof_index +
+                                          (ind1 +
+                                           comp * static_dofs_per_component) *
+                                            VectorizedArrayType::size());
+                      do_vectorized_add(grad,
+                                        dst_ptr + dof_index +
+                                          (ind2 +
+                                           comp * static_dofs_per_component) *
+                                            VectorizedArrayType::size());
                     }
                 }
             }
@@ -2664,11 +2662,11 @@ namespace internal
                 {
                   const unsigned int ind = index_array[i];
                   for (unsigned int comp = 0; comp < n_components; ++comp)
-                    do_vectorized_add(
-                      temp1[i + 2 * comp * dofs_per_face],
-                      dst_ptr + dof_index +
-                        (ind + comp * static_dofs_per_component) *
-                          VectorizedArrayType::n_array_elements);
+                    do_vectorized_add(temp1[i + 2 * comp * dofs_per_face],
+                                      dst_ptr + dof_index +
+                                        (ind +
+                                         comp * static_dofs_per_component) *
+                                          VectorizedArrayType::size());
                 }
             }
         }
@@ -2685,10 +2683,11 @@ namespace internal
         {
           AssertDimension(
             dof_info.n_vectorization_lanes_filled[dof_access_index][cell],
-            VectorizedArrayType::n_array_elements);
+            VectorizedArrayType::size());
           const unsigned int *indices =
-            &dof_info.dof_indices_contiguous
-               [dof_access_index][cell * VectorizedArrayType::n_array_elements];
+            &dof_info
+               .dof_indices_contiguous[dof_access_index]
+                                      [cell * VectorizedArrayType::size()];
           if (fe_degree > 1 && integrate_gradients == true)
             {
               // we know that the gradient weights for the Hermite case on the
@@ -2704,10 +2703,9 @@ namespace internal
               for (unsigned int i = 0; i < dofs_per_face; ++i)
                 {
                   const unsigned int ind1 =
-                    index_array[2 * i] * VectorizedArrayType::n_array_elements;
+                    index_array[2 * i] * VectorizedArrayType::size();
                   const unsigned int ind2 =
-                    index_array[2 * i + 1] *
-                    VectorizedArrayType::n_array_elements;
+                    index_array[2 * i + 1] * VectorizedArrayType::size();
                   for (unsigned int comp = 0; comp < n_components; ++comp)
                     {
                       VectorizedArrayType val =
@@ -2722,19 +2720,19 @@ namespace internal
                         indices,
                         dst_ptr + ind1 +
                           comp * static_dofs_per_component *
-                            VectorizedArrayType::n_array_elements +
+                            VectorizedArrayType::size() +
                           dof_info.component_dof_indices_offset
                               [active_fe_index][first_selected_component] *
-                            VectorizedArrayType::n_array_elements);
+                            VectorizedArrayType::size());
                       do_vectorized_scatter_add(
                         grad,
                         indices,
                         dst_ptr + ind2 +
                           comp * static_dofs_per_component *
-                            VectorizedArrayType::n_array_elements +
+                            VectorizedArrayType::size() +
                           dof_info.component_dof_indices_offset
                               [active_fe_index][first_selected_component] *
-                            VectorizedArrayType::n_array_elements);
+                            VectorizedArrayType::size());
                     }
                 }
             }
@@ -2747,17 +2745,17 @@ namespace internal
               for (unsigned int i = 0; i < dofs_per_face; ++i)
                 {
                   const unsigned int ind =
-                    index_array[i] * VectorizedArrayType::n_array_elements;
+                    index_array[i] * VectorizedArrayType::size();
                   for (unsigned int comp = 0; comp < n_components; ++comp)
                     do_vectorized_scatter_add(
                       temp1[i + 2 * comp * dofs_per_face],
                       indices,
                       dst_ptr + ind +
                         comp * static_dofs_per_component *
-                          VectorizedArrayType::n_array_elements +
+                          VectorizedArrayType::size() +
                         dof_info.component_dof_indices_offset
                             [active_fe_index][first_selected_component] *
-                          VectorizedArrayType::n_array_elements);
+                          VectorizedArrayType::size());
                 }
             }
         }
@@ -2774,14 +2772,12 @@ namespace internal
         {
           const unsigned int *strides =
             &dof_info.dof_indices_interleave_strides
-               [dof_access_index][cell * VectorizedArrayType::n_array_elements];
-          unsigned int indices[VectorizedArrayType::n_array_elements];
-          for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements;
-               ++v)
+               [dof_access_index][cell * VectorizedArrayType::size()];
+          unsigned int indices[VectorizedArrayType::size()];
+          for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
             indices[v] =
               dof_info.dof_indices_contiguous
-                [dof_access_index]
-                [cell * VectorizedArrayType::n_array_elements + v] +
+                [dof_access_index][cell * VectorizedArrayType::size() + v] +
               dof_info.component_dof_indices_offset[active_fe_index]
                                                    [first_selected_component] *
                 strides[v];
@@ -2800,23 +2796,21 @@ namespace internal
 
               const unsigned int *index_array =
                 &data.face_to_cell_index_hermite(face_no, 0);
-              if (nvec == VectorizedArrayType::n_array_elements)
+              if (nvec == VectorizedArrayType::size())
                 for (unsigned int comp = 0; comp < n_components; ++comp)
                   for (unsigned int i = 0; i < dofs_per_face; ++i)
                     {
-                      unsigned int ind1[VectorizedArrayType::n_array_elements];
+                      unsigned int ind1[VectorizedArrayType::size()];
                       DEAL_II_OPENMP_SIMD_PRAGMA
-                      for (unsigned int v = 0;
-                           v < VectorizedArrayType::n_array_elements;
+                      for (unsigned int v = 0; v < VectorizedArrayType::size();
                            ++v)
                         ind1[v] =
                           indices[v] + (comp * static_dofs_per_component +
                                         index_array[2 * i]) *
                                          strides[v];
-                      unsigned int ind2[VectorizedArrayType::n_array_elements];
+                      unsigned int ind2[VectorizedArrayType::size()];
                       DEAL_II_OPENMP_SIMD_PRAGMA
-                      for (unsigned int v = 0;
-                           v < VectorizedArrayType::n_array_elements;
+                      for (unsigned int v = 0; v < VectorizedArrayType::size();
                            ++v)
                         ind2[v] =
                           indices[v] + (comp * static_dofs_per_component +
@@ -2864,14 +2858,13 @@ namespace internal
                               dofs_per_face);
               const unsigned int *index_array =
                 &data.face_to_cell_index_nodal(face_no, 0);
-              if (nvec == VectorizedArrayType::n_array_elements)
+              if (nvec == VectorizedArrayType::size())
                 for (unsigned int comp = 0; comp < n_components; ++comp)
                   for (unsigned int i = 0; i < dofs_per_face; ++i)
                     {
-                      unsigned int ind[VectorizedArrayType::n_array_elements];
+                      unsigned int ind[VectorizedArrayType::size()];
                       DEAL_II_OPENMP_SIMD_PRAGMA
-                      for (unsigned int v = 0;
-                           v < VectorizedArrayType::n_array_elements;
+                      for (unsigned int v = 0; v < VectorizedArrayType::size();
                            ++v)
                         ind[v] =
                           indices[v] +
@@ -2907,11 +2900,12 @@ namespace internal
                  internal::MatrixFreeFunctions::DoFInfo::IndexStorageVariants::
                    contiguous &&
                dof_info.n_vectorization_lanes_filled[dof_access_index][cell] ==
-                 VectorizedArrayType::n_array_elements)
+                 VectorizedArrayType::size())
         {
           const unsigned int *indices =
-            &dof_info.dof_indices_contiguous
-               [dof_access_index][cell * VectorizedArrayType::n_array_elements];
+            &dof_info
+               .dof_indices_contiguous[dof_access_index]
+                                      [cell * VectorizedArrayType::size()];
 
           if (integrate_gradients == true &&
               data.element_type ==
index 8d4e14d7393a6d4b9f699b7c49876b280e42b876..35f6d577b1765c7e45fedb04c4b69a52d0a4c1db 100644 (file)
@@ -179,7 +179,7 @@ public:
    * on the given cell. This call is slower than the ones done through a
    * MatrixFree object and lead to a structure that does not effectively use
    * vectorization in the evaluate routines based on these values (instead,
-   * VectorizedArray::n_array_elements same copies are worked on).
+   * VectorizedArray::size() same copies are worked on).
    *
    * If the given vector template class is a block vector (determined through
    * the template function 'IsBlockVector<VectorType>::value', which checks
@@ -211,7 +211,7 @@ public:
    * on the given cell. This call is slower than the ones done through a
    * MatrixFree object and lead to a structure that does not effectively use
    * vectorization in the evaluate routines based on these values (instead,
-   * VectorizedArray::n_array_elements same copies are worked on).
+   * VectorizedArray::size() same copies are worked on).
    *
    * If the given vector template class is a block vector (determined through
    * the template function 'IsBlockVector<VectorType>::value', which checks
@@ -246,7 +246,7 @@ public:
    * on the given cell. This call is slower than the ones done through a
    * MatrixFree object and lead to a structure that does not effectively use
    * vectorization in the evaluate routines based on these values (instead,
-   * VectorizedArray::n_array_elements same copies are worked on).
+   * VectorizedArray::size() same copies are worked on).
    *
    * If the given vector template class is a block vector (determined through
    * the template function 'IsBlockVector<VectorType>::value', which checks
@@ -258,10 +258,10 @@ public:
   template <typename VectorType>
   void
   distribute_local_to_global(
-    VectorType &                                              dst,
-    const unsigned int                                        first_index = 0,
-    const std::bitset<VectorizedArrayType::n_array_elements> &mask =
-      std::bitset<VectorizedArrayType::n_array_elements>().flip()) const;
+    VectorType &                                    dst,
+    const unsigned int                              first_index = 0,
+    const std::bitset<VectorizedArrayType::size()> &mask =
+      std::bitset<VectorizedArrayType::size()>().flip()) const;
 
   /**
    * Takes the values stored internally on dof values of the current cell and
@@ -286,7 +286,7 @@ public:
    * on the given cell. This call is slower than the ones done through a
    * MatrixFree object and lead to a structure that does not effectively use
    * vectorization in the evaluate routines based on these values (instead,
-   * VectorizedArray::n_array_elements same copies are worked on).
+   * VectorizedArray::size() same copies are worked on).
    *
    * If the given vector template class is a block vector (determined through
    * the template function 'IsBlockVector<VectorType>::value', which checks
@@ -297,11 +297,10 @@ public:
    */
   template <typename VectorType>
   void
-  set_dof_values(
-    VectorType &                                              dst,
-    const unsigned int                                        first_index = 0,
-    const std::bitset<VectorizedArrayType::n_array_elements> &mask =
-      std::bitset<VectorizedArrayType::n_array_elements>().flip()) const;
+  set_dof_values(VectorType &       dst,
+                 const unsigned int first_index = 0,
+                 const std::bitset<VectorizedArrayType::size()> &mask =
+                   std::bitset<VectorizedArrayType::size()>().flip()) const;
 
   //@}
 
@@ -606,16 +605,15 @@ public:
    * arbitrary data type.
    */
   template <typename T>
-  std::array<T, VectorizedArrayType::n_array_elements>
-  read_cell_data(
-    const AlignedVector<std::array<T, VectorizedArrayType::n_array_elements>>
-      &array) const;
+  std::array<T, VectorizedArrayType::size()>
+  read_cell_data(const AlignedVector<std::array<T, VectorizedArrayType::size()>>
+                   &array) const;
 
   /**
    * Return the id of the cells this FEEvaluation or FEFaceEvaluation is
    * associated with.
    */
-  std::array<unsigned int, VectorizedArrayType::n_array_elements>
+  std::array<unsigned int, VectorizedArrayType::size()>
   get_cell_ids() const;
 
   //@}
@@ -838,11 +836,10 @@ protected:
    */
   template <typename VectorType, typename VectorOperation>
   void
-  read_write_operation(
-    const VectorOperation &                                   operation,
-    VectorType *                                              vectors[],
-    const std::bitset<VectorizedArrayType::n_array_elements> &mask,
-    const bool apply_constraints = true) const;
+  read_write_operation(const VectorOperation &operation,
+                       VectorType *           vectors[],
+                       const std::bitset<VectorizedArrayType::size()> &mask,
+                       const bool apply_constraints = true) const;
 
   /**
    * A unified function to read from and write into vectors based on the given
@@ -854,9 +851,9 @@ protected:
   template <typename VectorType, typename VectorOperation>
   void
   read_write_operation_contiguous(
-    const VectorOperation &                                   operation,
-    VectorType *                                              vectors[],
-    const std::bitset<VectorizedArrayType::n_array_elements> &mask) const;
+    const VectorOperation &                         operation,
+    VectorType *                                    vectors[],
+    const std::bitset<VectorizedArrayType::size()> &mask) const;
 
   /**
    * A unified function to read from and write into vectors based on the given
@@ -1757,9 +1754,7 @@ protected:
  *           phi.quadrature_point(q_index);
  *         // Need to evaluate function for each component in VectorizedArray
  *         VectorizedArray<double> f_value;
- *         for (unsigned int v=0;
- *              v<VectorizedArray<double>::n_array_elements;
- *              ++v)
+ *         for (unsigned int v=0; v<VectorizedArray<double>::size(); ++v)
  *           {
  *             Point<dim> p;
  *             for (unsigned int d=0; d<dim; ++d)
@@ -1848,12 +1843,12 @@ protected:
  *   {
  *     fe_eval.reinit(cell);
  *     for (unsigned int i=0; i<dofs_per_cell;
- *          i += VectorizedArray<double>::n_array_elements)
+ *          i += VectorizedArray<double>::size())
  *       {
  *         const unsigned int n_items =
- *           i+VectorizedArray<double>::n_array_elements > dofs_per_cell ?
+ *           i+VectorizedArray<double>::size() > dofs_per_cell ?
  *           (dofs_per_cell - i) :
- *           VectorizedArray<double>::n_array_elements;
+ *           VectorizedArray<double>::size();
  *
  *         // Set n_items unit vectors
  *         for (unsigned int j=0; j<dofs_per_cell; ++j)
@@ -3056,7 +3051,7 @@ inline FEEvaluationBase<dim,
   set_data_pointers();
   Assert(matrix_info->mapping_initialized() == true, ExcNotInitialized());
   AssertDimension(matrix_info->get_task_info().vectorization_length,
-                  VectorizedArrayType::n_array_elements);
+                  VectorizedArrayType::size());
   AssertDimension((is_face ? data->n_q_points_face : data->n_q_points),
                   n_quadrature_points);
   AssertDimension(n_quadrature_points,
@@ -3564,12 +3559,12 @@ template <int dim,
           typename Number,
           bool is_face,
           typename VectorizedArrayType>
-std::array<unsigned int, VectorizedArrayType::n_array_elements>
+std::array<unsigned int, VectorizedArrayType::size()>
 FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
   get_cell_ids() const
 {
-  const unsigned int v_len = VectorizedArrayType::n_array_elements;
-  std::array<unsigned int, VectorizedArrayType::n_array_elements> cells;
+  const unsigned int              v_len = VectorizedArrayType::size();
+  std::array<unsigned int, v_len> cells;
 
   // initialize array
   for (unsigned int i = 0; i < v_len; ++i)
@@ -3627,7 +3622,7 @@ FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
         is_interior_face ?
           &this->matrix_info->get_face_info(cell).cells_interior[0] :
           &this->matrix_info->get_face_info(cell).cells_exterior[0];
-      for (unsigned int i = 0; i < VectorizedArrayType::n_array_elements; ++i)
+      for (unsigned int i = 0; i < VectorizedArrayType::size(); ++i)
         if (cells_[i] != numbers::invalid_unsigned_int)
           cells[i] = cells_[i];
     }
@@ -3655,10 +3650,10 @@ FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
 
   // 2) actually gather values
   VectorizedArrayType out = make_vectorized_array<Number>(Number(1.));
-  for (unsigned int i = 0; i < VectorizedArrayType::n_array_elements; ++i)
+  for (unsigned int i = 0; i < VectorizedArrayType::size(); ++i)
     if (cells[i] != numbers::invalid_unsigned_int)
-      out[i] = array[cells[i] / VectorizedArrayType::n_array_elements]
-                    [cells[i] % VectorizedArrayType::n_array_elements];
+      out[i] = array[cells[i] / VectorizedArrayType::size()]
+                    [cells[i] % VectorizedArrayType::size()];
   return out;
 }
 
@@ -3670,11 +3665,10 @@ template <int dim,
           bool is_face,
           typename VectorizedArrayType>
 template <typename T>
-inline std::array<T, VectorizedArrayType::n_array_elements>
+inline std::array<T, VectorizedArrayType::size()>
 FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
-  read_cell_data(
-    const AlignedVector<std::array<T, VectorizedArrayType::n_array_elements>>
-      &array) const
+  read_cell_data(const AlignedVector<std::array<T, VectorizedArrayType::size()>>
+                   &array) const
 {
   Assert(matrix_info != nullptr, ExcNotImplemented());
   AssertDimension(array.size(),
@@ -3684,11 +3678,11 @@ FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
   const auto cells = this->get_cell_ids();
 
   // 2) actually gather values
-  std::array<T, VectorizedArrayType::n_array_elements> out;
-  for (unsigned int i = 0; i < VectorizedArrayType::n_array_elements; ++i)
+  std::array<T, VectorizedArrayType::size()> out;
+  for (unsigned int i = 0; i < VectorizedArrayType::size(); ++i)
     if (cells[i] != numbers::invalid_unsigned_int)
-      out[i] = array[cells[i] / VectorizedArrayType::n_array_elements]
-                    [cells[i] % VectorizedArrayType::n_array_elements];
+      out[i] = array[cells[i] / VectorizedArrayType::size()]
+                    [cells[i] % VectorizedArrayType::size()];
   return out;
 }
 
@@ -3780,11 +3774,10 @@ template <int dim,
 template <typename VectorType, typename VectorOperation>
 inline void
 FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
-  read_write_operation(
-    const VectorOperation &                                   operation,
-    VectorType *                                              src[],
-    const std::bitset<VectorizedArrayType::n_array_elements> &mask,
-    const bool apply_constraints) const
+  read_write_operation(const VectorOperation &operation,
+                       VectorType *           src[],
+                       const std::bitset<VectorizedArrayType::size()> &mask,
+                       const bool apply_constraints) const
 {
   // Case 1: No MatrixFree object given, simple case because we do not need to
   // process constraints and need not care about vectorization -> go to
@@ -3831,8 +3824,7 @@ FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
 
   // Case 3: standard operation with one index per degree of freedom -> go on
   // here
-  constexpr unsigned int n_vectorization =
-    VectorizedArrayType::n_array_elements;
+  constexpr unsigned int n_vectorization = VectorizedArrayType::size();
   Assert(mask.count() == n_vectorization,
          ExcNotImplemented("Masking currently not implemented for "
                            "non-contiguous DoF storage"));
@@ -3889,7 +3881,7 @@ FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
       if (dof_access_index ==
           internal::MatrixFreeFunctions::DoFInfo::dof_access_cell)
         for (unsigned int v = 0; v < n_vectorization_actual; ++v)
-          cells_copied[v] = cell * VectorizedArrayType::n_array_elements + v;
+          cells_copied[v] = cell * VectorizedArrayType::size() + v;
       cells = dof_access_index ==
                   internal::MatrixFreeFunctions::DoFInfo::dof_access_cell ?
                 &cells_copied[0] :
@@ -4209,9 +4201,9 @@ template <typename VectorType, typename VectorOperation>
 inline void
 FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
   read_write_operation_contiguous(
-    const VectorOperation &                                   operation,
-    VectorType *                                              src[],
-    const std::bitset<VectorizedArrayType::n_array_elements> &mask) const
+    const VectorOperation &                         operation,
+    VectorType *                                    src[],
+    const std::bitset<VectorizedArrayType::size()> &mask) const
 {
   // This functions processes the functions read_dof_values,
   // distribute_local_to_global, and set_dof_values with the same code for
@@ -4236,13 +4228,13 @@ FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
   if (dof_info->index_storage_variants[ind][cell] ==
         internal::MatrixFreeFunctions::DoFInfo::IndexStorageVariants::
           interleaved_contiguous &&
-      n_lanes == VectorizedArrayType::n_array_elements)
+      n_lanes == VectorizedArrayType::size())
     {
       const unsigned int dof_index =
-        dof_indices_cont[cell * VectorizedArrayType::n_array_elements] +
+        dof_indices_cont[cell * VectorizedArrayType::size()] +
         dof_info->component_dof_indices_offset[active_fe_index]
                                               [first_selected_component] *
-          VectorizedArrayType::n_array_elements;
+          VectorizedArrayType::size();
       if (n_components == 1 || n_fe_components == 1)
         for (unsigned int comp = 0; comp < n_components; ++comp)
           operation.process_dofs_vectorized(data->dofs_per_component_on_cell,
@@ -4265,24 +4257,24 @@ FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
   const unsigned int vectorization_populated =
     dof_info->n_vectorization_lanes_filled[ind][this->cell];
 
-  unsigned int dof_indices[VectorizedArrayType::n_array_elements];
+  unsigned int dof_indices[VectorizedArrayType::size()];
   for (unsigned int v = 0; v < vectorization_populated; ++v)
     dof_indices[v] =
-      dof_indices_cont[cell * VectorizedArrayType::n_array_elements + v] +
+      dof_indices_cont[cell * VectorizedArrayType::size() + v] +
       dof_info->component_dof_indices_offset[active_fe_index]
                                             [first_selected_component] *
         dof_info->dof_indices_interleave_strides
-          [ind][cell * VectorizedArrayType::n_array_elements + v];
+          [ind][cell * VectorizedArrayType::size() + v];
 
   for (unsigned int v = vectorization_populated;
-       v < VectorizedArrayType::n_array_elements;
+       v < VectorizedArrayType::size();
        ++v)
     dof_indices[v] = numbers::invalid_unsigned_int;
 
   // In the case with contiguous cell indices, we know that there are no
   // constraints and that the indices within each element are contiguous
-  if (vectorization_populated == VectorizedArrayType::n_array_elements &&
-      n_lanes == VectorizedArrayType::n_array_elements)
+  if (vectorization_populated == VectorizedArrayType::size() &&
+      n_lanes == VectorizedArrayType::size())
     {
       if (dof_info->index_storage_variants[ind][cell] ==
           internal::MatrixFreeFunctions::DoFInfo::IndexStorageVariants::
@@ -4312,12 +4304,11 @@ FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
             for (unsigned int i = 0; i < data->dofs_per_component_on_cell; ++i)
               {
                 for (unsigned int comp = 0; comp < n_components; ++comp)
-                  operation.process_dof_gather(
-                    dof_indices,
-                    *src[comp],
-                    i * VectorizedArrayType::n_array_elements,
-                    values_dofs[comp][i],
-                    vector_selector);
+                  operation.process_dof_gather(dof_indices,
+                                               *src[comp],
+                                               i * VectorizedArrayType::size(),
+                                               values_dofs[comp][i],
+                                               vector_selector);
               }
           else
             for (unsigned int comp = 0; comp < n_components; ++comp)
@@ -4328,7 +4319,7 @@ FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
                     dof_indices,
                     *src[0],
                     (comp * data->dofs_per_component_on_cell + i) *
-                      VectorizedArrayType::n_array_elements,
+                      VectorizedArrayType::size(),
                     values_dofs[comp][i],
                     vector_selector);
                 }
@@ -4341,7 +4332,7 @@ FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
                  ExcNotImplemented());
           const unsigned int *offsets =
             &dof_info->dof_indices_interleave_strides
-               [ind][VectorizedArrayType::n_array_elements * cell];
+               [ind][VectorizedArrayType::size() * cell];
           if (n_components == 1 || n_fe_components == 1)
             for (unsigned int i = 0; i < data->dofs_per_component_on_cell; ++i)
               {
@@ -4352,9 +4343,7 @@ FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
                                                values_dofs[comp][i],
                                                vector_selector);
                 DEAL_II_OPENMP_SIMD_PRAGMA
-                for (unsigned int v = 0;
-                     v < VectorizedArrayType::n_array_elements;
-                     ++v)
+                for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
                   dof_indices[v] += offsets[v];
               }
           else
@@ -4368,9 +4357,7 @@ FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
                                                values_dofs[comp][i],
                                                vector_selector);
                   DEAL_II_OPENMP_SIMD_PRAGMA
-                  for (unsigned int v = 0;
-                       v < VectorizedArrayType::n_array_elements;
-                       ++v)
+                  for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
                     dof_indices[v] += offsets[v];
                 }
         }
@@ -4413,10 +4400,9 @@ FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
           {
             const unsigned int *offsets =
               &dof_info->dof_indices_interleave_strides
-                 [ind][VectorizedArrayType::n_array_elements * cell];
+                 [ind][VectorizedArrayType::size() * cell];
             for (unsigned int v = 0; v < vectorization_populated; ++v)
-              AssertIndexRange(offsets[v],
-                               VectorizedArrayType::n_array_elements + 1);
+              AssertIndexRange(offsets[v], VectorizedArrayType::size() + 1);
             if (n_components == 1 || n_fe_components == 1)
               for (unsigned int v = 0; v < vectorization_populated; ++v)
                 {
@@ -4470,11 +4456,10 @@ FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
         get_vector_component(const_cast<VectorType &>(src), d + first_index);
 
   internal::VectorReader<Number, VectorizedArrayType> reader;
-  read_write_operation(
-    reader,
-    src_data,
-    std::bitset<VectorizedArrayType::n_array_elements>().flip(),
-    true);
+  read_write_operation(reader,
+                       src_data,
+                       std::bitset<VectorizedArrayType::size()>().flip(),
+                       true);
 
 #  ifdef DEBUG
   dof_values_initialized = true;
@@ -4505,11 +4490,10 @@ FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
         get_vector_component(const_cast<VectorType &>(src), d + first_index);
 
   internal::VectorReader<Number, VectorizedArrayType> reader;
-  read_write_operation(
-    reader,
-    src_data,
-    std::bitset<VectorizedArrayType::n_array_elements>().flip(),
-    false);
+  read_write_operation(reader,
+                       src_data,
+                       std::bitset<VectorizedArrayType::size()>().flip(),
+                       false);
 
 #  ifdef DEBUG
   dof_values_initialized = true;
@@ -4527,9 +4511,9 @@ template <typename VectorType>
 inline void
 FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
   distribute_local_to_global(
-    VectorType &                                              dst,
-    const unsigned int                                        first_index,
-    const std::bitset<VectorizedArrayType::n_array_elements> &mask) const
+    VectorType &                                    dst,
+    const unsigned int                              first_index,
+    const std::bitset<VectorizedArrayType::size()> &mask) const
 {
 #  ifdef DEBUG
   Assert(dof_values_initialized == true,
@@ -4562,10 +4546,9 @@ template <int dim,
 template <typename VectorType>
 inline void
 FEEvaluationBase<dim, n_components_, Number, is_face, VectorizedArrayType>::
-  set_dof_values(
-    VectorType &                                              dst,
-    const unsigned int                                        first_index,
-    const std::bitset<VectorizedArrayType::n_array_elements> &mask) const
+  set_dof_values(VectorType &                                    dst,
+                 const unsigned int                              first_index,
+                 const std::bitset<VectorizedArrayType::size()> &mask) const
 {
 #  ifdef DEBUG
   Assert(dof_values_initialized == true,
@@ -7090,7 +7073,7 @@ FEEvaluation<
         input_vector.begin() +
         this->dof_info->dof_indices_contiguous
           [internal::MatrixFreeFunctions::DoFInfo::dof_access_cell]
-          [this->cell * VectorizedArrayType::n_array_elements]) %
+          [this->cell * VectorizedArrayType::size()]) %
           sizeof(VectorizedArrayType) ==
         0)
     {
@@ -7099,11 +7082,11 @@ FEEvaluation<
           input_vector.begin() +
           this->dof_info->dof_indices_contiguous
             [internal::MatrixFreeFunctions::DoFInfo::dof_access_cell]
-            [this->cell * VectorizedArrayType::n_array_elements] +
+            [this->cell * VectorizedArrayType::size()] +
           this->dof_info
               ->component_dof_indices_offset[this->active_fe_index]
                                             [this->first_selected_component] *
-            VectorizedArrayType::n_array_elements);
+            VectorizedArrayType::size());
 
       evaluate(vec_values,
                evaluate_values,
@@ -7226,7 +7209,7 @@ FEEvaluation<
         destination.begin() +
         this->dof_info->dof_indices_contiguous
           [internal::MatrixFreeFunctions::DoFInfo::dof_access_cell]
-          [this->cell * VectorizedArrayType::n_array_elements]) %
+          [this->cell * VectorizedArrayType::size()]) %
           sizeof(VectorizedArrayType) ==
         0)
     {
@@ -7234,11 +7217,11 @@ FEEvaluation<
         destination.begin() +
         this->dof_info->dof_indices_contiguous
           [internal::MatrixFreeFunctions::DoFInfo::dof_access_cell]
-          [this->cell * VectorizedArrayType::n_array_elements] +
+          [this->cell * VectorizedArrayType::size()] +
         this->dof_info
             ->component_dof_indices_offset[this->active_fe_index]
                                           [this->first_selected_component] *
-          VectorizedArrayType::n_array_elements);
+          VectorizedArrayType::size());
       SelectEvaluator<dim,
                       fe_degree,
                       n_q_points_1d,
@@ -7326,7 +7309,7 @@ FEFaceEvaluation<dim,
       internal::MatrixFreeFunctions::DoFInfo::dof_access_face_interior :
       internal::MatrixFreeFunctions::DoFInfo::dof_access_face_exterior;
   Assert(this->mapping_data != nullptr, ExcNotInitialized());
-  const unsigned int n_vectors = VectorizedArrayType::n_array_elements;
+  const unsigned int n_vectors = VectorizedArrayType::size();
   const internal::MatrixFreeFunctions::FaceToCellTopology<n_vectors> &faces =
     this->matrix_info->get_face_info(face_index);
   if (face_index >=
index 6d436321949e44eb80de39def9a678078e0e4fa1..120fa1379cdc4f2d8bfad53916e650a101fd2b77 100644 (file)
@@ -327,7 +327,7 @@ namespace internal
       initialize(
         const dealii::Triangulation<dim> &                        tria,
         const std::vector<std::pair<unsigned int, unsigned int>> &cells,
-        const FaceInfo<VectorizedArrayType::n_array_elements> &   faces,
+        const FaceInfo<VectorizedArrayType::size()> &             faces,
         const std::vector<unsigned int> &              active_fe_index,
         const Mapping<dim> &                           mapping,
         const std::vector<dealii::hp::QCollection<1>> &quad,
@@ -346,7 +346,7 @@ namespace internal
       update_mapping(
         const dealii::Triangulation<dim> &                        tria,
         const std::vector<std::pair<unsigned int, unsigned int>> &cells,
-        const FaceInfo<VectorizedArrayType::n_array_elements> &   faces,
+        const FaceInfo<VectorizedArrayType::size()> &             faces,
         const std::vector<unsigned int> &active_fe_index,
         const Mapping<dim> &             mapping);
 
@@ -460,9 +460,9 @@ namespace internal
       initialize_faces(
         const dealii::Triangulation<dim> &                        tria,
         const std::vector<std::pair<unsigned int, unsigned int>> &cells,
-        const std::vector<
-          FaceToCellTopology<VectorizedArrayType::n_array_elements>> &faces,
-        const Mapping<dim> &                                          mapping);
+        const std::vector<FaceToCellTopology<VectorizedArrayType::size()>>
+          &                 faces,
+        const Mapping<dim> &mapping);
 
       /**
        * Computes the information in the given faces, called within
@@ -545,32 +545,23 @@ namespace internal
 
       bool
       operator()(
-        const Tensor<1, VectorizedArrayType::n_array_elements, Number> &t1,
-        const Tensor<1, VectorizedArrayType::n_array_elements, Number> &t2)
-        const;
+        const Tensor<1, VectorizedArrayType::size(), Number> &t1,
+        const Tensor<1, VectorizedArrayType::size(), Number> &t2) const;
 
       template <int dim>
       bool
       operator()(
-        const Tensor<1,
-                     dim,
-                     Tensor<1, VectorizedArrayType::n_array_elements, Number>>
+        const Tensor<1, dim, Tensor<1, VectorizedArrayType::size(), Number>>
           &t1,
-        const Tensor<1,
-                     dim,
-                     Tensor<1, VectorizedArrayType::n_array_elements, Number>>
+        const Tensor<1, dim, Tensor<1, VectorizedArrayType::size(), Number>>
           &t2) const;
 
       template <int dim>
       bool
       operator()(
-        const Tensor<2,
-                     dim,
-                     Tensor<1, VectorizedArrayType::n_array_elements, Number>>
+        const Tensor<2, dim, Tensor<1, VectorizedArrayType::size(), Number>>
           &t1,
-        const Tensor<2,
-                     dim,
-                     Tensor<1, VectorizedArrayType::n_array_elements, Number>>
+        const Tensor<2, dim, Tensor<1, VectorizedArrayType::size(), Number>>
           &t2) const;
 
       Number tolerance;
index 6b192976e483e2c5bfda0226b2794515f15f82bd..18882a192a3a1f3087aab3f6319ad265d1ffb65f 100644 (file)
@@ -299,7 +299,7 @@ namespace internal
     MappingInfo<dim, Number, VectorizedArrayType>::initialize(
       const dealii::Triangulation<dim> &                        tria,
       const std::vector<std::pair<unsigned int, unsigned int>> &cells,
-      const FaceInfo<VectorizedArrayType::n_array_elements> &   face_info,
+      const FaceInfo<VectorizedArrayType::size()> &             face_info,
       const std::vector<unsigned int> &                         active_fe_index,
       const Mapping<dim> &                                      mapping,
       const std::vector<dealii::hp::QCollection<1>> &           quad,
@@ -363,11 +363,11 @@ namespace internal
     MappingInfo<dim, Number, VectorizedArrayType>::update_mapping(
       const dealii::Triangulation<dim> &                        tria,
       const std::vector<std::pair<unsigned int, unsigned int>> &cells,
-      const FaceInfo<VectorizedArrayType::n_array_elements> &   face_info,
+      const FaceInfo<VectorizedArrayType::size()> &             face_info,
       const std::vector<unsigned int> &                         active_fe_index,
       const Mapping<dim> &                                      mapping)
     {
-      AssertDimension(cells.size() / VectorizedArrayType::n_array_elements,
+      AssertDimension(cells.size() / VectorizedArrayType::size(),
                       cell_type.size());
 
       for (auto &data : cell_data)
@@ -413,12 +413,9 @@ namespace internal
           : data(FPArrayComparator<Number, VectorizedArrayType>(expected_size))
         {}
 
-        std::map<
-          Tensor<2,
-                 dim,
-                 Tensor<1, VectorizedArrayType::n_array_elements, Number>>,
-          unsigned int,
-          FPArrayComparator<Number, VectorizedArrayType>>
+        std::map<Tensor<2, dim, Tensor<1, VectorizedArrayType::size(), Number>>,
+                 unsigned int,
+                 FPArrayComparator<Number, VectorizedArrayType>>
           data;
       };
 
@@ -471,14 +468,13 @@ namespace internal
        */
       template <int dim, typename Number, typename VectorizedArrayType>
       void
-      evaluate_on_cell(
-        const dealii::Triangulation<dim> &           tria,
-        const std::pair<unsigned int, unsigned int> *cells,
-        const unsigned int                           my_q,
-        GeometryType &                               cell_t_prev,
-        GeometryType (&cell_t)[VectorizedArrayType::n_array_elements],
-        dealii::FEValues<dim, dim> &                 fe_val,
-        LocalData<dim, Number, VectorizedArrayType> &cell_data)
+      evaluate_on_cell(const dealii::Triangulation<dim> &           tria,
+                       const std::pair<unsigned int, unsigned int> *cells,
+                       const unsigned int                           my_q,
+                       GeometryType &                               cell_t_prev,
+                       GeometryType (&cell_t)[VectorizedArrayType::size()],
+                       dealii::FEValues<dim, dim> &                 fe_val,
+                       LocalData<dim, Number, VectorizedArrayType> &cell_data)
       {
         const unsigned int n_q_points   = fe_val.n_quadrature_points;
         const UpdateFlags  update_flags = fe_val.get_update_flags();
@@ -489,7 +485,7 @@ namespace internal
         // not have that field here)
         const double zero_tolerance_double =
           cell_data.jac_size * std::numeric_limits<double>::epsilon() * 1024.;
-        for (unsigned int j = 0; j < VectorizedArrayType::n_array_elements; ++j)
+        for (unsigned int j = 0; j < VectorizedArrayType::size(); ++j)
           {
             typename dealii::Triangulation<dim>::cell_iterator cell_it(
               &tria, cells[j].first, cells[j].second);
@@ -651,10 +647,10 @@ namespace internal
                             jacobian_grad[d][e][f];
                   }
               }
-          } // end loop over entries of vectorization (n_array_elements cells)
+          } // end loop over entries of vectorization (size() cells)
 
         // set information for next cell
-        cell_t_prev = cell_t[VectorizedArrayType::n_array_elements - 1];
+        cell_t_prev = cell_t[VectorizedArrayType::size() - 1];
       }
 
 
@@ -695,7 +691,7 @@ namespace internal
         // encodes the cell types of the current cell. Since several cells
         // must be considered together, this variable holds the individual
         // info of the last chunk of cells
-        GeometryType cell_t[VectorizedArrayType::n_array_elements];
+        GeometryType cell_t[VectorizedArrayType::size()];
         GeometryType cell_t_prev = general;
 
         // fe_values object that is used to compute the mapping data. for
@@ -782,7 +778,7 @@ namespace internal
 
               evaluate_on_cell<dim, Number, VectorizedArrayType>(
                 tria,
-                &cells[cell * VectorizedArrayType::n_array_elements],
+                &cells[cell * VectorizedArrayType::size()],
                 my_q,
                 cell_t_prev,
                 cell_t,
@@ -799,9 +795,7 @@ namespace internal
                   // find the most general cell type (most general type is 3
                   // (general cell))
                   GeometryType most_general_type = cartesian;
-                  for (unsigned int j = 0;
-                       j < VectorizedArrayType::n_array_elements;
-                       ++j)
+                  for (unsigned int j = 0; j < VectorizedArrayType::size(); ++j)
                     if (cell_t[j] > most_general_type)
                       most_general_type = cell_t[j];
                   AssertIndexRange(most_general_type, 4U);
@@ -827,9 +821,7 @@ namespace internal
                       std::pair<
                         Tensor<2,
                                dim,
-                               Tensor<1,
-                                      VectorizedArrayType::n_array_elements,
-                                      Number>>,
+                               Tensor<1, VectorizedArrayType::size(), Number>>,
                         unsigned int>
                         new_entry;
                       // This number overlaps with the general data but we
@@ -839,7 +831,7 @@ namespace internal
                       for (unsigned int d = 0; d < dim; ++d)
                         for (unsigned int e = 0; e < dim; ++e)
                           for (unsigned int v = 0;
-                               v < VectorizedArrayType::n_array_elements;
+                               v < VectorizedArrayType::size();
                                ++v)
                             new_entry.first[d][e][v] =
                               cell_data.const_jac[d][e][v];
@@ -864,8 +856,7 @@ namespace internal
                         cell_data.general_jac[q];
                       Tensor<3, dim, VectorizedArrayType> &jacobian_grad =
                         cell_data.general_jac_grad[q];
-                      for (unsigned int j = 0;
-                           j < VectorizedArrayType::n_array_elements;
+                      for (unsigned int j = 0; j < VectorizedArrayType::size();
                            ++j)
                         if (cell_t[j] < general)
                           {
@@ -1112,9 +1103,8 @@ namespace internal
       const std::vector<unsigned int> &                         active_fe_index,
       const Mapping<dim> &                                      mapping)
     {
-      const unsigned int n_cells = cells.size();
-      const unsigned int vectorization_width =
-        VectorizedArrayType::n_array_elements;
+      const unsigned int n_cells             = cells.size();
+      const unsigned int vectorization_width = VectorizedArrayType::size();
       Assert(n_cells % vectorization_width == 0, ExcInternalError());
       const unsigned int n_macro_cells = n_cells / vectorization_width;
       cell_type.resize(n_macro_cells);
@@ -1233,8 +1223,7 @@ namespace internal
                   Tensor<2, dim, VectorizedArrayType> jac;
                   for (unsigned int d = 0; d < dim; ++d)
                     for (unsigned int e = 0; e < dim; ++e)
-                      for (unsigned int v = 0;
-                           v < VectorizedArrayType::n_array_elements;
+                      for (unsigned int v = 0; v < VectorizedArrayType::size();
                            ++v)
                         jac[d][e][v] = it.first[d][e][v];
                   AssertIndexRange(it.second, n_constant_jacobians);
@@ -1287,12 +1276,11 @@ namespace internal
         // (inner tensor). We cannot choose a VectorizedArray type directly
         // because std::map does not provide the necessary alignment upon
         // memory allocation.
-        std::map<
-          Tensor<1,
-                 2 * dim * dim + dim + 1,
-                 Tensor<1, VectorizedArrayType::n_array_elements, Number>>,
-          unsigned int,
-          FPArrayComparator<Number, VectorizedArrayType>>
+        std::map<Tensor<1,
+                        2 * dim * dim + dim + 1,
+                        Tensor<1, VectorizedArrayType::size(), Number>>,
+                 unsigned int,
+                 FPArrayComparator<Number, VectorizedArrayType>>
           data;
 
         // Store the scaling factor
@@ -1338,9 +1326,9 @@ namespace internal
         const std::pair<unsigned int, unsigned int>               face_range,
         const dealii::Triangulation<dim> &                        tria,
         const std::vector<std::pair<unsigned int, unsigned int>> &cells,
-        const std::vector<
-          FaceToCellTopology<VectorizedArrayType::n_array_elements>> &faces,
-        const Mapping<dim> &                                          mapping,
+        const std::vector<FaceToCellTopology<VectorizedArrayType::size()>>
+          &                                            faces,
+        const Mapping<dim> &                           mapping,
         MappingInfo<dim, Number, VectorizedArrayType> &mapping_info,
         std::pair<
           std::vector<
@@ -1414,9 +1402,7 @@ namespace internal
               bool normal_is_similar = true;
               bool JxW_is_similar    = true;
               bool cell_is_cartesian = true;
-              for (unsigned int v = 0;
-                   v < VectorizedArrayType::n_array_elements;
-                   ++v)
+              for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
                 {
                   Tensor<2, dim> jacobian_0;
                   double         compare_norm_jac = 1.;
@@ -1643,8 +1629,7 @@ namespace internal
                         face_data.quadrature_points[q]);
                 }
 
-              using VEC_ARRAY =
-                Tensor<1, VectorizedArrayType::n_array_elements, Number>;
+              using VEC_ARRAY = Tensor<1, VectorizedArrayType::size(), Number>;
               unsigned int insert_position = data.first[my_q].JxW_values.size();
 
               // Fill in JxW values, apply compression
@@ -1657,8 +1642,7 @@ namespace internal
                                 unsigned int>
                         new_entry;
                       new_entry.second = data.second.data.size();
-                      for (unsigned int v = 0;
-                           v < VectorizedArrayType::n_array_elements;
+                      for (unsigned int v = 0; v < VectorizedArrayType::size();
                            ++v)
                         new_entry.first[2 * dim * dim + dim][v] =
                           face_data.JxW_values[0][v] / quadrature.weight(0) /
@@ -1668,7 +1652,7 @@ namespace internal
                       for (unsigned int d = 0; d < dim; ++d)
                         for (unsigned int e = 0; e < dim; ++e)
                           for (unsigned int v = 0;
-                               v < VectorizedArrayType::n_array_elements;
+                               v < VectorizedArrayType::size();
                                ++v)
                             new_entry.first[d * dim + e][v] =
                               face_data.general_jac[0][d][e][v];
@@ -1676,7 +1660,7 @@ namespace internal
                         for (unsigned int d = 0; d < dim; ++d)
                           for (unsigned int e = 0; e < dim; ++e)
                             for (unsigned int v = 0;
-                                 v < VectorizedArrayType::n_array_elements;
+                                 v < VectorizedArrayType::size();
                                  ++v)
                               new_entry.first[dim * dim + d * dim + e][v] =
                                 face_data.general_jac[n_q_points][d][e][v];
@@ -1689,7 +1673,7 @@ namespace internal
                       // size to get the right scaling
                       for (unsigned int d = 0; d < dim; ++d)
                         for (unsigned int v = 0;
-                             v < VectorizedArrayType::n_array_elements;
+                             v < VectorizedArrayType::size();
                              ++v)
                           new_entry.first[2 * dim * dim + d][v] =
                             face_data.normal_vectors[0][d][v] /
@@ -1727,8 +1711,8 @@ namespace internal
         const unsigned int               first_face,
         const unsigned int               last_face,
         const std::vector<GeometryType> &face_type,
-        const std::vector<
-          FaceToCellTopology<VectorizedArrayType::n_array_elements>> &faces,
+        const std::vector<FaceToCellTopology<VectorizedArrayType::size()>>
+          &faces,
         MappingInfoStorage<dim - 1, dim, Number, VectorizedArrayType>
           &data_faces)
       {
@@ -1761,11 +1745,10 @@ namespace internal
     template <int dim, typename Number, typename VectorizedArrayType>
     void
     MappingInfo<dim, Number, VectorizedArrayType>::initialize_faces(
-      const dealii::Triangulation<dim> &                        tria,
-      const std::vector<std::pair<unsigned int, unsigned int>> &cells,
-      const std::vector<
-        FaceToCellTopology<VectorizedArrayType::n_array_elements>> &faces,
-      const Mapping<dim> &                                          mapping)
+      const dealii::Triangulation<dim> &                                  tria,
+      const std::vector<std::pair<unsigned int, unsigned int>> &          cells,
+      const std::vector<FaceToCellTopology<VectorizedArrayType::size()>> &faces,
+      const Mapping<dim> &mapping)
     {
       face_type.resize(faces.size(), general);
 
@@ -1899,9 +1882,7 @@ namespace internal
               for (const auto &it : data_faces_local[0].second.data)
                 {
                   // JxW values; invert previously applied scaling
-                  for (unsigned int v = 0;
-                       v < VectorizedArrayType::n_array_elements;
-                       ++v)
+                  for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
                     face_data[my_q].JxW_values[it.second][v] =
                       it.first[2 * dim * dim + dim][v] *
                       Utilities::fixed_power<dim>(jac_size);
@@ -1911,15 +1892,14 @@ namespace internal
                     for (unsigned int d = 0; d < dim; ++d)
                       for (unsigned int e = 0; e < dim; ++e)
                         for (unsigned int v = 0;
-                             v < VectorizedArrayType::n_array_elements;
+                             v < VectorizedArrayType::size();
                              ++v)
                           face_data[my_q].jacobians[i][it.second][d][e][v] =
                             it.first[i * dim * dim + d * dim + e][v];
 
                   // normal vectors; invert previously applied scaling
                   for (unsigned int d = 0; d < dim; ++d)
-                    for (unsigned int v = 0;
-                         v < VectorizedArrayType::n_array_elements;
+                    for (unsigned int v = 0; v < VectorizedArrayType::size();
                          ++v)
                       face_data[my_q].normal_vectors[it.second][d][v] =
                         it.first[2 * dim * dim + d][v] * jac_size;
@@ -1967,10 +1947,9 @@ namespace internal
       if (update_flags_faces_by_cells == update_default)
         return;
 
-      const unsigned int n_quads = face_data_by_cells.size();
-      const unsigned int vectorization_width =
-        VectorizedArrayType::n_array_elements;
-      UpdateFlags update_flags =
+      const unsigned int n_quads             = face_data_by_cells.size();
+      const unsigned int vectorization_width = VectorizedArrayType::size();
+      UpdateFlags        update_flags =
         (update_flags_faces_by_cells & update_quadrature_points ?
            update_quadrature_points :
            update_default) |
@@ -2297,11 +2276,11 @@ namespace internal
 
     template <typename Number, typename VectorizedArrayType>
     bool
-    FPArrayComparator<Number, VectorizedArrayType>::operator()(
-      const Tensor<1, VectorizedArrayType::n_array_elements, Number> &t1,
-      const Tensor<1, VectorizedArrayType::n_array_elements, Number> &t2) const
+    FPArrayComparator<Number, VectorizedArrayType>::
+    operator()(const Tensor<1, VectorizedArrayType::size(), Number> &t1,
+               const Tensor<1, VectorizedArrayType::size(), Number> &t2) const
     {
-      for (unsigned int k = 0; k < VectorizedArrayType::n_array_elements; ++k)
+      for (unsigned int k = 0; k < VectorizedArrayType::size(); ++k)
         if (t1[k] < t2[k] - tolerance)
           return true;
         else if (t1[k] > t2[k] + tolerance)
@@ -2315,17 +2294,12 @@ namespace internal
     template <int dim>
     bool
     FPArrayComparator<Number, VectorizedArrayType>::operator()(
-      const Tensor<1,
-                   dim,
-                   Tensor<1, VectorizedArrayType::n_array_elements, Number>>
-        &t1,
-      const Tensor<1,
-                   dim,
-                   Tensor<1, VectorizedArrayType::n_array_elements, Number>>
-        &t2) const
+      const Tensor<1, dim, Tensor<1, VectorizedArrayType::size(), Number>> &t1,
+      const Tensor<1, dim, Tensor<1, VectorizedArrayType::size(), Number>> &t2)
+      const
     {
       for (unsigned int d = 0; d < dim; ++d)
-        for (unsigned int k = 0; k < VectorizedArrayType::n_array_elements; ++k)
+        for (unsigned int k = 0; k < VectorizedArrayType::size(); ++k)
           if (t1[d][k] < t2[d][k] - tolerance)
             return true;
           else if (t1[d][k] > t2[d][k] + tolerance)
@@ -2339,19 +2313,13 @@ namespace internal
     template <int dim>
     bool
     FPArrayComparator<Number, VectorizedArrayType>::operator()(
-      const Tensor<2,
-                   dim,
-                   Tensor<1, VectorizedArrayType::n_array_elements, Number>>
-        &t1,
-      const Tensor<2,
-                   dim,
-                   Tensor<1, VectorizedArrayType::n_array_elements, Number>>
-        &t2) const
+      const Tensor<2, dim, Tensor<1, VectorizedArrayType::size(), Number>> &t1,
+      const Tensor<2, dim, Tensor<1, VectorizedArrayType::size(), Number>> &t2)
+      const
     {
       for (unsigned int d = 0; d < dim; ++d)
         for (unsigned int e = 0; e < dim; ++e)
-          for (unsigned int k = 0; k < VectorizedArrayType::n_array_elements;
-               ++k)
+          for (unsigned int k = 0; k < VectorizedArrayType::size(); ++k)
             if (t1[d][e][k] < t2[d][e][k] - tolerance)
               return true;
             else if (t1[d][e][k] > t2[d][e][k] + tolerance)
index 45f562a141b6f839b6610907eb949464696b359c..68efa4c5cf0882e9aa53574dddb9f9bf8ef6489a 100644 (file)
@@ -1570,7 +1570,7 @@ public:
    * general. The cell range in @p cell_loop runs from zero to n_cell_batches()
    * (exclusive), so this is the appropriate size if you want to store arrays
    * of data for all cells to be worked on. This number is approximately
-   * `n_physical_cells()/VectorizedArray::n_array_elements` (depending on how
+   * `n_physical_cells()/VectorizedArray::size()` (depending on how
    * many cell chunks that do not get filled up completely).
    */
   unsigned int
@@ -1582,7 +1582,7 @@ public:
    * general. The cell range in @p cell_loop runs from zero to
    * n_cell_batches() (exclusive), so this is the appropriate size if you want
    * to store arrays of data for all cells to be worked on. This number is
-   * approximately `n_physical_cells()/VectorizedArray::n_array_elements`
+   * approximately `n_physical_cells()/VectorizedArray::size()`
    * (depending on how many cell chunks that do not get filled up completely).
    */
   unsigned int
@@ -1638,7 +1638,7 @@ public:
    * Return the boundary ids for the faces within a cell, using the cells'
    * sorting by lanes in the VectorizedArray.
    */
-  std::array<types::boundary_id, VectorizedArrayType::n_array_elements>
+  std::array<types::boundary_id, VectorizedArrayType::size()>
   get_faces_by_cells_boundary_id(const unsigned int macro_cell,
                                  const unsigned int face_number) const;
 
@@ -1924,7 +1924,7 @@ public:
    * Return the connectivity information of a face.
    */
   const internal::MatrixFreeFunctions::FaceToCellTopology<
-    VectorizedArrayType::n_array_elements> &
+    VectorizedArrayType::size()> &
   get_face_info(const unsigned int face_batch_number) const;
 
 
@@ -2139,7 +2139,7 @@ private:
    * Vector holding face information. Only initialized if
    * build_face_info=true.
    */
-  internal::MatrixFreeFunctions::FaceInfo<VectorizedArrayType::n_array_elements>
+  internal::MatrixFreeFunctions::FaceInfo<VectorizedArrayType::size()>
     face_info;
 
   /**
@@ -2350,7 +2350,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::get_boundary_id(
 
 
 template <int dim, typename Number, typename VectorizedArrayType>
-inline std::array<types::boundary_id, VectorizedArrayType::n_array_elements>
+inline std::array<types::boundary_id, VectorizedArrayType::size()>
 MatrixFree<dim, Number, VectorizedArrayType>::get_faces_by_cells_boundary_id(
   const unsigned int macro_cell,
   const unsigned int face_number) const
@@ -2359,7 +2359,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::get_faces_by_cells_boundary_id(
   AssertIndexRange(face_number, GeometryInfo<dim>::faces_per_cell);
   Assert(face_info.cell_and_face_boundary_id.size(0) >= n_macro_cells(),
          ExcNotInitialized());
-  std::array<types::boundary_id, VectorizedArrayType::n_array_elements> result;
+  std::array<types::boundary_id, VectorizedArrayType::size()> result;
   result.fill(numbers::invalid_boundary_id);
   for (unsigned int v = 0; v < n_active_entries_per_cell_batch(macro_cell); ++v)
     result[v] = face_info.cell_and_face_boundary_id(macro_cell, face_number, v);
@@ -2461,13 +2461,9 @@ MatrixFree<dim, Number, VectorizedArrayType>::at_irregular_cell(
   const unsigned int macro_cell) const
 {
   AssertIndexRange(macro_cell, task_info.cell_partition_data.back());
-  return VectorizedArrayType::n_array_elements > 1 &&
-         cell_level_index[(macro_cell + 1) *
-                            VectorizedArrayType::n_array_elements -
-                          1] ==
-           cell_level_index[(macro_cell + 1) *
-                              VectorizedArrayType::n_array_elements -
-                            2];
+  return VectorizedArrayType::size() > 1 &&
+         cell_level_index[(macro_cell + 1) * VectorizedArrayType::size() - 1] ==
+           cell_level_index[(macro_cell + 1) * VectorizedArrayType::size() - 2];
 }
 
 
@@ -2488,16 +2484,14 @@ MatrixFree<dim, Number, VectorizedArrayType>::n_active_entries_per_cell_batch(
   const unsigned int cell_batch_number) const
 {
   AssertIndexRange(cell_batch_number, task_info.cell_partition_data.back());
-  unsigned int n_components = VectorizedArrayType::n_array_elements;
-  while (
-    n_components > 1 &&
-    cell_level_index[cell_batch_number * VectorizedArrayType::n_array_elements +
-                     n_components - 1] ==
-      cell_level_index[cell_batch_number *
-                         VectorizedArrayType::n_array_elements +
-                       n_components - 2])
+  unsigned int n_components = VectorizedArrayType::size();
+  while (n_components > 1 &&
+         cell_level_index[cell_batch_number * VectorizedArrayType::size() +
+                          n_components - 1] ==
+           cell_level_index[cell_batch_number * VectorizedArrayType::size() +
+                            n_components - 2])
     --n_components;
-  AssertIndexRange(n_components - 1, VectorizedArrayType::n_array_elements);
+  AssertIndexRange(n_components - 1, VectorizedArrayType::size());
   return n_components;
 }
 
@@ -2509,12 +2503,12 @@ MatrixFree<dim, Number, VectorizedArrayType>::n_active_entries_per_face_batch(
   const unsigned int face_batch_number) const
 {
   AssertIndexRange(face_batch_number, face_info.faces.size());
-  unsigned int n_components = VectorizedArrayType::n_array_elements;
+  unsigned int n_components = VectorizedArrayType::size();
   while (n_components > 1 &&
          face_info.faces[face_batch_number].cells_interior[n_components - 1] ==
            numbers::invalid_unsigned_int)
     --n_components;
-  AssertIndexRange(n_components - 1, VectorizedArrayType::n_array_elements);
+  AssertIndexRange(n_components - 1, VectorizedArrayType::size());
   return n_components;
 }
 
@@ -2613,7 +2607,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::get_shape_info(
 
 template <int dim, typename Number, typename VectorizedArrayType>
 inline const internal::MatrixFreeFunctions::FaceToCellTopology<
-  VectorizedArrayType::n_array_elements> &
+  VectorizedArrayType::size()> &
 MatrixFree<dim, Number, VectorizedArrayType>::get_face_info(
   const unsigned int macro_face) const
 {
@@ -2686,7 +2680,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::get_face_category(
     return std::make_pair(0U, 0U);
 
   std::pair<unsigned int, unsigned int> result;
-  for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements &&
+  for (unsigned int v = 0; v < VectorizedArrayType::size() &&
                            face_info.faces[macro_face].cells_interior[v] !=
                              numbers::invalid_unsigned_int;
        ++v)
@@ -2696,7 +2690,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::get_face_category(
         .cell_active_fe_index[face_info.faces[macro_face].cells_interior[v]]);
   if (face_info.faces[macro_face].cells_exterior[0] !=
       numbers::invalid_unsigned_int)
-    for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements &&
+    for (unsigned int v = 0; v < VectorizedArrayType::size() &&
                              face_info.faces[macro_face].cells_exterior[v] !=
                                numbers::invalid_unsigned_int;
          ++v)
index c4dad79eebb84b839f36bfc3fd6dab47ff8e7b39..c9a206fd0e1da33ee83dbcd25576cfa4cc0bdc35 100644 (file)
@@ -199,8 +199,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::get_cell_iterator(
   const unsigned int vector_number,
   const unsigned int dof_handler_index) const
 {
-  const unsigned int vectorization_length =
-    VectorizedArrayType::n_array_elements;
+  const unsigned int vectorization_length = VectorizedArrayType::size();
   AssertIndexRange(dof_handler_index, dof_handlers.n_dof_handlers);
   AssertIndexRange(macro_cell_number, task_info.cell_partition_data.back());
   AssertIndexRange(vector_number, n_components_filled(macro_cell_number));
@@ -235,8 +234,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::get_cell_level_and_index(
   const unsigned int macro_cell_number,
   const unsigned int vector_number) const
 {
-  const unsigned int vectorization_length =
-    VectorizedArrayType::n_array_elements;
+  const unsigned int vectorization_length = VectorizedArrayType::size();
   AssertIndexRange(macro_cell_number, task_info.cell_partition_data.back());
   AssertIndexRange(vector_number, n_components_filled(macro_cell_number));
 
@@ -284,7 +282,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::get_face_iterator(
     }
 
   const internal::MatrixFreeFunctions::FaceToCellTopology<
-    VectorizedArrayType::n_array_elements>
+    VectorizedArrayType::size()>
     face2cell_info = get_face_info(face_batch_number);
 
   const unsigned int cell_index =
@@ -308,8 +306,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::get_hp_cell_iterator(
   const unsigned int vector_number,
   const unsigned int dof_handler_index) const
 {
-  constexpr unsigned int vectorization_length =
-    VectorizedArrayType::n_array_elements;
+  constexpr unsigned int vectorization_length = VectorizedArrayType::size();
   AssertIndexRange(dof_handler_index, dof_handlers.n_dof_handlers);
   AssertIndexRange(macro_cell_number, task_info.cell_partition_data.back());
   AssertIndexRange(vector_number, n_components_filled(macro_cell_number));
@@ -454,7 +451,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::internal_reinit(
       std::vector<unsigned char> dummy2;
       task_info.collect_boundary_cells(cell_level_index.size(),
                                        cell_level_index.size(),
-                                       VectorizedArrayType::n_array_elements,
+                                       VectorizedArrayType::size(),
                                        dummy);
       task_info.create_blocks_serial(
         dummy, dummy, 1, dummy, false, dummy, dummy2);
@@ -480,9 +477,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::internal_reinit(
           // if indices are not initialized, the cell_level_index might not be
           // divisible by the vectorization length. But it must be for
           // mapping_info...
-          while (cell_level_index.size() %
-                   VectorizedArrayType::n_array_elements !=
-                 0)
+          while (cell_level_index.size() % VectorizedArrayType::size() != 0)
             cell_level_index.push_back(cell_level_index.back());
         }
     }
@@ -626,7 +621,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::internal_reinit(
       std::vector<unsigned char> dummy2;
       task_info.collect_boundary_cells(cell_level_index.size(),
                                        cell_level_index.size(),
-                                       VectorizedArrayType::n_array_elements,
+                                       VectorizedArrayType::size(),
                                        dummy);
       task_info.create_blocks_serial(
         dummy, dummy, 1, dummy, false, dummy, dummy2);
@@ -654,9 +649,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::internal_reinit(
           // if indices are not initialized, the cell_level_index might not be
           // divisible by the vectorization length. But it must be for
           // mapping_info...
-          while (cell_level_index.size() %
-                   VectorizedArrayType::n_array_elements !=
-                 0)
+          while (cell_level_index.size() % VectorizedArrayType::size() != 0)
             cell_level_index.push_back(cell_level_index.back());
         }
     }
@@ -781,7 +774,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::initialize_dof_handlers(
 
   dof_info.resize(dof_handlers.n_dof_handlers);
   for (unsigned int no = 0; no < dof_handlers.n_dof_handlers; ++no)
-    dof_info[no].vectorization_length = VectorizedArrayType::n_array_elements;
+    dof_info[no].vectorization_length = VectorizedArrayType::size();
 
   // Go through cells on zeroth level and then successively step down into
   // children. This gives a z-ordering of the cells, which is beneficial when
@@ -852,7 +845,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::initialize_dof_handlers(
 
   dof_info.resize(dof_handlers.n_dof_handlers);
   for (unsigned int no = 0; no < dof_handlers.n_dof_handlers; ++no)
-    dof_info[no].vectorization_length = VectorizedArrayType::n_array_elements;
+    dof_info[no].vectorization_length = VectorizedArrayType::size();
 
   // go through cells on zeroth level and then successively step down into
   // children. This gives a z-ordering of the cells, which is beneficial when
@@ -1139,8 +1132,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::initialize_indices(
         subdomain_boundary_cells.push_back(counter);
     }
 
-  const unsigned int vectorization_length =
-    VectorizedArrayType::n_array_elements;
+  const unsigned int vectorization_length = VectorizedArrayType::size();
   task_info.collect_boundary_cells(cell_level_index_end_local,
                                    n_active_cells,
                                    vectorization_length,
@@ -1518,7 +1510,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::initialize_indices(
 
       cell_level_index.resize(
         cell_level_index.size() +
-        VectorizedArrayType::n_array_elements *
+        VectorizedArrayType::size() *
           (task_info.refinement_edge_face_partition_data[1] -
            task_info.refinement_edge_face_partition_data[0]));
 
@@ -1530,48 +1522,48 @@ MatrixFree<dim, Number, VectorizedArrayType>::initialize_indices(
       face_info.cell_and_face_to_plain_faces.reinit(
         TableIndices<3>(task_info.cell_partition_data.back(),
                         GeometryInfo<dim>::faces_per_cell,
-                        VectorizedArrayType::n_array_elements),
+                        VectorizedArrayType::size()),
         true);
       face_info.cell_and_face_to_plain_faces.fill(
         numbers::invalid_unsigned_int);
       face_info.cell_and_face_boundary_id.reinit(
         TableIndices<3>(task_info.cell_partition_data.back(),
                         GeometryInfo<dim>::faces_per_cell,
-                        VectorizedArrayType::n_array_elements),
+                        VectorizedArrayType::size()),
         true);
       face_info.cell_and_face_boundary_id.fill(numbers::invalid_boundary_id);
 
       for (unsigned int f = 0; f < task_info.ghost_face_partition_data.back();
            ++f)
-        for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements &&
+        for (unsigned int v = 0; v < VectorizedArrayType::size() &&
                                  face_info.faces[f].cells_interior[v] !=
                                    numbers::invalid_unsigned_int;
              ++v)
           {
             TableIndices<3> index(face_info.faces[f].cells_interior[v] /
-                                    VectorizedArrayType::n_array_elements,
+                                    VectorizedArrayType::size(),
                                   face_info.faces[f].interior_face_no,
                                   face_info.faces[f].cells_interior[v] %
-                                    VectorizedArrayType::n_array_elements);
+                                    VectorizedArrayType::size());
 
             // Assert(cell_and_face_to_plain_faces(index) ==
             // numbers::invalid_unsigned_int,
             //       ExcInternalError("Should only visit each face once"));
             face_info.cell_and_face_to_plain_faces(index) =
-              f * VectorizedArrayType::n_array_elements + v;
+              f * VectorizedArrayType::size() + v;
             if (face_info.faces[f].cells_exterior[v] !=
                 numbers::invalid_unsigned_int)
               {
                 TableIndices<3> index(face_info.faces[f].cells_exterior[v] /
-                                        VectorizedArrayType::n_array_elements,
+                                        VectorizedArrayType::size(),
                                       face_info.faces[f].exterior_face_no,
                                       face_info.faces[f].cells_exterior[v] %
-                                        VectorizedArrayType::n_array_elements);
+                                        VectorizedArrayType::size());
                 // Assert(cell_and_face_to_plain_faces(index) ==
                 // numbers::invalid_unsigned_int,
                 //       ExcInternalError("Should only visit each face once"));
                 face_info.cell_and_face_to_plain_faces(index) =
-                  f * VectorizedArrayType::n_array_elements + v;
+                  f * VectorizedArrayType::size() + v;
               }
             else
               face_info.cell_and_face_boundary_id(index) =
@@ -1590,8 +1582,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::initialize_indices(
           std::vector<types::global_dof_index> ghost_indices;
           {
             for (unsigned int cell = 0;
-                 cell <
-                 VectorizedArrayType::n_array_elements * n_macro_cells_before;
+                 cell < VectorizedArrayType::size() * n_macro_cells_before;
                  ++cell)
               if (cell == 0 ||
                   cell_level_index[cell] != cell_level_index[cell - 1])
@@ -1654,15 +1645,14 @@ MatrixFree<dim, Number, VectorizedArrayType>::initialize_indices(
                                          const bool,
                                          const bool)> &fu) {
               for (unsigned int f = 0; f < n_inner_face_batches(); ++f)
-                for (unsigned int v = 0;
-                     v < VectorizedArrayType::n_array_elements &&
-                     face_info.faces[f].cells_interior[v] !=
-                       numbers::invalid_unsigned_int;
+                for (unsigned int v = 0; v < VectorizedArrayType::size() &&
+                                         face_info.faces[f].cells_interior[v] !=
+                                           numbers::invalid_unsigned_int;
                      ++v)
                   {
                     AssertIndexRange(face_info.faces[f].cells_interior[v],
                                      n_macro_cells_before *
-                                       VectorizedArrayType::n_array_elements);
+                                       VectorizedArrayType::size());
                     const unsigned int p = face_info.faces[f].cells_exterior[v];
                     const unsigned int face_no =
                       face_info.faces[f].exterior_face_no;
@@ -1680,17 +1670,14 @@ MatrixFree<dim, Number, VectorizedArrayType>::initialize_indices(
                                          const bool)> &fu) {
               for (unsigned int c = 0; c < n_cell_batches(); ++c)
                 for (const unsigned int d : GeometryInfo<dim>::face_indices())
-                  for (unsigned int v = 0;
-                       v < VectorizedArrayType::n_array_elements;
-                       ++v)
+                  for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
                     {
                       unsigned int f =
                         this->face_info.cell_and_face_to_plain_faces(c, d, v);
                       if (f == numbers::invalid_unsigned_int)
                         continue;
 
-                      const unsigned int v_len =
-                        VectorizedArrayType::n_array_elements;
+                      const unsigned int v_len = VectorizedArrayType::size();
                       const unsigned int cell_this = c * v_len + v;
 
                       const unsigned int cell_m = this->get_face_info(f / v_len)
@@ -1855,14 +1842,12 @@ MatrixFree<dim, Number, VectorizedArrayType>::initialize_indices(
                     // using AssertIndexRange, but that leads to an
                     // internal compiler error with GCC 7.4. Do things
                     // by hand instead.
-                    Assert(
-                      face_info.faces[f].cells_interior[v] <
-                        n_macro_cells_before *
-                          VectorizedArrayType::n_array_elements,
-                      ExcIndexRange(face_info.faces[f].cells_interior[v],
-                                    0,
-                                    n_macro_cells_before *
-                                      VectorizedArrayType::n_array_elements));
+                    Assert(face_info.faces[f].cells_interior[v] <
+                             n_macro_cells_before * VectorizedArrayType::size(),
+                           ExcIndexRange(face_info.faces[f].cells_interior[v],
+                                         0,
+                                         n_macro_cells_before *
+                                           VectorizedArrayType::size()));
                     if (flag ||
                         (di.index_storage_variants
                              [ext ? internal::MatrixFreeFunctions::DoFInfo::
index 5f93f4ed2f5a992dc9d37563412a0f89fde1ab7e..af79e158d5752d1e0ce48c5a1429a1d5b9add11e 100644 (file)
@@ -2034,7 +2034,7 @@ namespace MatrixFreeOperators
     bool
     non_negative(const VectorizedArrayType &n)
     {
-      for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements; ++v)
+      for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
         if (n[v] < 0.)
           return false;
 
index 5275f90aa5d0f98869131de507503d344ed02ad2..46bd9b268c16886fe4559fd08747b0dc73eefc99 100644 (file)
@@ -237,7 +237,7 @@ namespace internal
     {
       const Number *vec_ptr = vec.begin() + dof_index;
       for (unsigned int i = 0; i < dofs_per_cell;
-           ++i, vec_ptr += VectorizedArrayType::n_array_elements)
+           ++i, vec_ptr += VectorizedArrayType::size())
         dof_values[i].load(vec_ptr);
     }
 
@@ -252,9 +252,9 @@ namespace internal
                             std::integral_constant<bool, false>) const
     {
       for (unsigned int i = 0; i < dofs_per_cell; ++i)
-        for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements; ++v)
-          dof_values[i][v] = vector_access(
-            vec, dof_index + v + i * VectorizedArrayType::n_array_elements);
+        for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
+          dof_values[i][v] =
+            vector_access(vec, dof_index + v + i * VectorizedArrayType::size());
     }
 
 
@@ -284,7 +284,7 @@ namespace internal
                                       std::integral_constant<bool, false>) const
     {
       for (unsigned int d = 0; d < dofs_per_cell; ++d)
-        for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements; ++v)
+        for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
           dof_values[d][v] = vector_access(vec, dof_indices[v] + d);
     }
 
@@ -315,7 +315,7 @@ namespace internal
                        VectorizedArrayType &res,
                        std::integral_constant<bool, false>) const
     {
-      for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements; ++v)
+      for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
         res[v] = vector_access(vec, indices[v] + constant_offset);
     }
 
@@ -393,7 +393,7 @@ namespace internal
     {
       Number *vec_ptr = vec.begin() + dof_index;
       for (unsigned int i = 0; i < dofs_per_cell;
-           ++i, vec_ptr += VectorizedArrayType::n_array_elements)
+           ++i, vec_ptr += VectorizedArrayType::size())
         {
           VectorizedArrayType tmp;
           tmp.load(vec_ptr);
@@ -413,10 +413,9 @@ namespace internal
                             std::integral_constant<bool, false>) const
     {
       for (unsigned int i = 0; i < dofs_per_cell; ++i)
-        for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements; ++v)
+        for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
           vector_access_add(vec,
-                            dof_index + v +
-                              i * VectorizedArrayType::n_array_elements,
+                            dof_index + v + i * VectorizedArrayType::size(),
                             dof_values[i][v]);
     }
 
@@ -445,7 +444,7 @@ namespace internal
                                       std::integral_constant<bool, false>) const
     {
       for (unsigned int d = 0; d < dofs_per_cell; ++d)
-        for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements; ++v)
+        for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
           vector_access_add(vec, dof_indices[v] + d, dof_values[d][v]);
     }
 
@@ -462,7 +461,7 @@ namespace internal
                        std::integral_constant<bool, true>) const
     {
 #if DEAL_II_COMPILER_VECTORIZATION_LEVEL < 3
-      for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements; ++v)
+      for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
         vector_access(vec, indices[v] + constant_offset) += res[v];
 #else
       // only use gather in case there is also scatter.
@@ -485,7 +484,7 @@ namespace internal
                        VectorizedArrayType &res,
                        std::integral_constant<bool, false>) const
     {
-      for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements; ++v)
+      for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
         vector_access_add(vec, indices[v] + constant_offset, res[v]);
     }
 
@@ -558,7 +557,7 @@ namespace internal
     {
       Number *vec_ptr = vec.begin() + dof_index;
       for (unsigned int i = 0; i < dofs_per_cell;
-           ++i, vec_ptr += VectorizedArrayType::n_array_elements)
+           ++i, vec_ptr += VectorizedArrayType::size())
         dof_values[i].store(vec_ptr);
     }
 
@@ -573,10 +572,8 @@ namespace internal
                             std::integral_constant<bool, false>) const
     {
       for (unsigned int i = 0; i < dofs_per_cell; ++i)
-        for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements; ++v)
-          vector_access(vec,
-                        dof_index + v +
-                          i * VectorizedArrayType::n_array_elements) =
+        for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
+          vector_access(vec, dof_index + v + i * VectorizedArrayType::size()) =
             dof_values[i][v];
     }
 
@@ -605,7 +602,7 @@ namespace internal
                                       std::integral_constant<bool, false>) const
     {
       for (unsigned int i = 0; i < dofs_per_cell; ++i)
-        for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements; ++v)
+        for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
           vector_access(vec, dof_indices[v] + i) = dof_values[i][v];
     }
 
@@ -632,7 +629,7 @@ namespace internal
                        VectorizedArrayType &res,
                        std::integral_constant<bool, false>) const
     {
-      for (unsigned int v = 0; v < VectorizedArrayType::n_array_elements; ++v)
+      for (unsigned int v = 0; v < VectorizedArrayType::size(); ++v)
         vector_access(vec, indices[v] + constant_offset) = res[v];
     }
 
index d2156ba6f3cd1966d6b0503f8d9a694294890d11..b466aef730bca5c49b7d6918f32ffaf66ad0fa75 100644 (file)
@@ -757,7 +757,7 @@ MappingQGeneric<dim, spacedim>::InternalData::initialize(
               const unsigned int max_size =
                 std::max(n_q_points, n_shape_values);
               const unsigned int vec_length =
-                dealii::VectorizedArray<double>::n_array_elements;
+                dealii::VectorizedArray<double>::size();
               const unsigned int n_comp = 1 + (spacedim - 1) / vec_length;
 
               scratch.resize((dim - 1) * max_size);
@@ -824,8 +824,8 @@ MappingQGeneric<dim, spacedim>::InternalData::initialize_face(
       const unsigned int n_shape_values = fe.n_dofs_per_cell();
       const unsigned int n_q_points     = q.size();
       const unsigned int max_size       = std::max(n_q_points, n_shape_values);
-      const unsigned int vec_length = VectorizedArray<double>::n_array_elements;
-      const unsigned int n_comp     = 1 + (spacedim - 1) / vec_length;
+      const unsigned int vec_length     = VectorizedArray<double>::size();
+      const unsigned int n_comp         = 1 + (spacedim - 1) / vec_length;
 
       scratch.resize((dim - 1) * max_size);
       values_dofs.resize(n_comp * n_shape_values);
@@ -1495,10 +1495,9 @@ namespace internal
 
         const unsigned int n_shape_values = data.n_shape_functions;
         const unsigned int n_q_points     = data.shape_info.n_q_points;
-        const unsigned int vec_length =
-          VectorizedArray<double>::n_array_elements;
-        const unsigned int n_comp     = 1 + (spacedim - 1) / vec_length;
-        const unsigned int n_hessians = (dim * (dim + 1)) / 2;
+        const unsigned int vec_length     = VectorizedArray<double>::size();
+        const unsigned int n_comp         = 1 + (spacedim - 1) / vec_length;
+        const unsigned int n_hessians     = (dim * (dim + 1)) / 2;
 
         const bool evaluate_values = update_flags & update_quadrature_points;
         const bool evaluate_gradients =
index 894b4c7a4aa8339d13f507e43864a21b4c5a270a..2849142472ab7532355867d45b1417e152150079 100644 (file)
@@ -149,7 +149,7 @@ MGTransferMatrixFree<dim, Number>::build(
     prolongation_matrix_1d[i] = elem_info.prolongation_matrix_1d[i];
 
   // reshuffle into aligned vector of vectorized arrays
-  const unsigned int vec_size = VectorizedArray<Number>::n_array_elements;
+  const unsigned int vec_size = VectorizedArray<Number>::size();
   const unsigned int n_levels =
     dof_handler.get_triangulation().n_global_levels();
 
@@ -379,8 +379,8 @@ MGTransferMatrixFree<dim, Number>::do_prolongate_add(
   LinearAlgebra::distributed::Vector<Number> &      dst,
   const LinearAlgebra::distributed::Vector<Number> &src) const
 {
-  const unsigned int vec_size    = VectorizedArray<Number>::n_array_elements;
-  const unsigned int degree_size = (degree > -1 ? degree : fe_degree) + 1;
+  const unsigned int vec_size        = VectorizedArray<Number>::size();
+  const unsigned int degree_size     = (degree > -1 ? degree : fe_degree) + 1;
   const unsigned int n_child_dofs_1d = 2 * degree_size - element_is_continuous;
   const unsigned int n_scalar_cell_dofs =
     Utilities::fixed_power<dim>(n_child_dofs_1d);
@@ -518,8 +518,8 @@ MGTransferMatrixFree<dim, Number>::do_restrict_add(
   LinearAlgebra::distributed::Vector<Number> &      dst,
   const LinearAlgebra::distributed::Vector<Number> &src) const
 {
-  const unsigned int vec_size    = VectorizedArray<Number>::n_array_elements;
-  const unsigned int degree_size = (degree > -1 ? degree : fe_degree) + 1;
+  const unsigned int vec_size        = VectorizedArray<Number>::size();
+  const unsigned int degree_size     = (degree > -1 ? degree : fe_degree) + 1;
   const unsigned int n_child_dofs_1d = 2 * degree_size - element_is_continuous;
   const unsigned int n_scalar_cell_dofs =
     Utilities::fixed_power<dim>(n_child_dofs_1d);
index efb9d9452d170c80b7d8246a7c3c009ae3c1f27a..187c8366c7c4ca671d189760612869a4d6b70cf0 100644 (file)
@@ -29,7 +29,7 @@ check()
   VectorizedArray<number>             distance_vec;
   Point<dim, VectorizedArray<number>> p1_vec, p2_vec;
 
-  for (unsigned int v = 0; v < VectorizedArray<number>::n_array_elements; ++v)
+  for (unsigned int v = 0; v < VectorizedArray<number>::size(); ++v)
     {
       Point<dim, number> p1, p2;
       for (unsigned int i = 0; i < dim; ++i)
@@ -48,12 +48,12 @@ check()
   distance_vec -= distance_vec2;
   number diff = 0.;
 
-  for (unsigned int v = 0; v < VectorizedArray<number>::n_array_elements; ++v)
+  for (unsigned int v = 0; v < VectorizedArray<number>::size(); ++v)
     diff += std::abs(distance_vec[v]);
 
   AssertThrow(diff < 2 * std::numeric_limits<number>::epsilon() *
-                       VectorizedArray<number>::n_array_elements *
-                       VectorizedArray<number>::n_array_elements,
+                       VectorizedArray<number>::size() *
+                       VectorizedArray<number>::size(),
               ExcMessage("diff is " + std::to_string(diff)));
 
   deallog << "Ok" << std::endl;
index b78cc7968aa4cb27600ba038aba98ede9e53117f..280b48d3e86913f627224e3ed6b0559735d12281 100644 (file)
@@ -25,18 +25,18 @@ template <typename VectorizedArrayType>
 void
 do_test(const VectorizedArrayType array)
 {
-  deallog << "  test " << VectorizedArrayType::n_array_elements
-          << " array elements" << std::endl;
+  deallog << "  test " << VectorizedArrayType::size() << " array elements"
+          << std::endl;
 
   auto exponentiated_array = Utilities::fixed_power<3>(array);
 
-  for (unsigned int i = 0; i < VectorizedArrayType::n_array_elements; i++)
+  for (unsigned int i = 0; i < VectorizedArrayType::size(); i++)
     deallog << exponentiated_array[i] << " ";
   deallog << std::endl;
 
   exponentiated_array = Utilities::fixed_power<-3>(array);
 
-  for (unsigned int i = 0; i < VectorizedArrayType::n_array_elements; i++)
+  for (unsigned int i = 0; i < VectorizedArrayType::size(); i++)
     deallog << exponentiated_array[i] << " ";
   deallog << std::endl;
 }
index 82c86cdbc479bc19fa5828a0101fae0566dd6abf..1ab6c354919c5e9f8a659852b438f6c32a8cdbbd 100644 (file)
@@ -30,7 +30,7 @@ test()
   // since the number of array elements is system dependent, it is not a good
   // idea to print them to an output file. Instead, check the values manually
   VectorizedArray<Number> a, b, c;
-  const unsigned int      n_vectors = VectorizedArray<Number>::n_array_elements;
+  const unsigned int      n_vectors = VectorizedArray<Number>::size();
   a                                 = Number(2.);
   b                                 = Number(-1.);
   for (unsigned int i = 0; i < n_vectors; ++i)
index c575cf0530dbdbaa37598e4a2075e6800368eb5c..ae8a386fa2006cb1c2decb39448e2316b2ea688c 100644 (file)
@@ -25,7 +25,7 @@ void
 test()
 {
   typedef VectorizedArray<double> vector_t;
-  const unsigned int n_vectors = VectorizedArray<double>::n_array_elements;
+  const unsigned int              n_vectors = VectorizedArray<double>::size();
   typedef AlignedVector<vector_t> VEC;
   std::vector<double>             a_ref(4), b_ref;
   VEC                             a(4);
index 285b3b546ed1363777f85a806b7a6afcd2908976..2a930ed212ac1ed9dd219ffed1e81d89ad2c2bf1 100644 (file)
@@ -74,7 +74,7 @@ test()
   weight = random_value<double>();
 
   VectorizedArray<double> vec;
-  for (unsigned int v = 0; v < VectorizedArray<double>::n_array_elements; ++v)
+  for (unsigned int v = 0; v < VectorizedArray<double>::size(); ++v)
     vec[v] = random_value<double>();
 
   current.values[0] = vec;
@@ -91,7 +91,7 @@ test()
   vector *= 2. * current.get_value(0)[0];
 
   double error = 0;
-  for (unsigned int v = 0; v < VectorizedArray<double>::n_array_elements; ++v)
+  for (unsigned int v = 0; v < VectorizedArray<double>::size(); ++v)
     error += std::abs(current.get_value(0)[v] / (current.cartesian_weight[v] *
                                                  current.jac_weight[0][0]) -
                       (2. * vec[v] - ol[v] - weight[v] * std::sin(vec[v])));
index e968f0cd7c40c29acddba9777acdb823937dfb19..ad9fe72856dbdb17223928e873cdf9dbb4b2a2c4 100644 (file)
@@ -25,7 +25,7 @@ template <typename Number>
 void
 test()
 {
-  const unsigned int  n_vectors = VectorizedArray<Number>::n_array_elements;
+  const unsigned int  n_vectors = VectorizedArray<Number>::size();
   std::vector<Number> values(n_vectors * 5);
   for (unsigned int i = 0; i < values.size(); ++i)
     values[i] = i;
index 91323f88127e13dec9f8e610ce13edea0af3ed25..7451e8f49b0fdcc0046361f21e2eb4f5075ca3de 100644 (file)
@@ -30,7 +30,7 @@ test()
 {
   // since the number of array elements is system dependent, it is not a good
   // idea to print them to an output file. Instead, check the values manually
-  const unsigned int      n_vectors = VectorizedArray<Number>::n_array_elements;
+  const unsigned int      n_vectors = VectorizedArray<Number>::size();
   VectorizedArray<Number> arr[n_numbers];
   Number                  other[n_vectors * n_numbers];
   unsigned int            offsets[n_vectors];
index d283f49d91d73c6af0d0eaa07240dd1d63fc1555..25793f2c27af9ebb265092890fedd4cc3cf4ff54 100644 (file)
@@ -35,7 +35,7 @@ test()
   for (unsigned int i = 0; i < vec.size(); ++i)
     vec[i] = i + 1;
 
-  const unsigned int n_vectors = VectorizedArray<Number>::n_array_elements;
+  const unsigned int n_vectors = VectorizedArray<Number>::size();
   unsigned int       indices[n_vectors];
   for (unsigned int i = 0; i < n_vectors; ++i)
     indices[i] = i;
index 7f69fcc8b36c566e32c7dab6f7a9f4ed7de251a3..2f4d10ca012e3194155fea0d985c96a5e677f916 100644 (file)
@@ -26,7 +26,7 @@ void
 test()
 {
   const unsigned int  n_chunks  = 50000;
-  const unsigned int  n_vectors = VectorizedArray<Number>::n_array_elements;
+  const unsigned int  n_vectors = VectorizedArray<Number>::size();
   std::vector<Number> values(n_vectors * n_chunks);
   for (unsigned int i = 0; i < values.size(); ++i)
     values[i] = i;
index 68230594293d0457011d6cffa0d114be63398534..ad1beea6f30a7b53d5693f2b723d55b1b8189896 100644 (file)
@@ -31,8 +31,7 @@ do_test()
 {
   // since the number of array elements is system dependent, it is not a good
   // idea to print them to an output file. Instead, check the values manually
-  const unsigned int n_vectors =
-    VectorizedArray<Number, width>::n_array_elements;
+  const unsigned int n_vectors = VectorizedArray<Number, width>::size();
   VectorizedArray<Number, width> arr[n_numbers];
   Number                         other[n_vectors * n_numbers];
   unsigned int                   offsets[n_vectors];
index f6b76d3a015d5a9779ae7774135f40a8a2a177ea..3a26982d36ebdb8c040e4400b2edeabffbbb4050 100644 (file)
@@ -29,9 +29,9 @@ void
 do_test(const VectorizedArrayType                      array,
         const typename VectorizedArrayType::value_type number)
 {
-  deallog << "  test " << VectorizedArrayType::n_array_elements
-          << " array elements" << std::endl;
-  for (unsigned int i = 0; i < VectorizedArrayType::n_array_elements; i++)
+  deallog << "  test " << VectorizedArrayType::size() << " array elements"
+          << std::endl;
+  for (unsigned int i = 0; i < VectorizedArrayType::size(); i++)
     if (array[i] != number)
       deallog << "  problem in element " << i << std::endl;
 }
index a196b99579aa4051c8ecd2a1ea8048e2ed9c4458..666c510811c84f1fa629a2115d6aa487e804e222 100644 (file)
@@ -27,7 +27,7 @@ template <typename Number>
 void
 test()
 {
-  constexpr unsigned int n = VectorizedArray<Number>::n_array_elements;
+  constexpr unsigned int n = VectorizedArray<Number>::size();
 
   VectorizedArray<Number> a;
   std::stringstream       test_stream;
index d1adc1e2ed16e07942fd51463c9296869f542c30..59ffcfe743c1b0ba30d3004687d3b28f646a7ab1 100644 (file)
@@ -26,12 +26,12 @@ void
 do_test(const VectorizedArrayType                      array,
         const typename VectorizedArrayType::value_type number)
 {
-  deallog << "  test " << VectorizedArrayType::n_array_elements
-          << " array elements" << std::endl;
+  deallog << "  test " << VectorizedArrayType::size() << " array elements"
+          << std::endl;
 
   auto exponentiated_array = std::pow(array, number);
 
-  for (unsigned int i = 0; i < VectorizedArrayType::n_array_elements; i++)
+  for (unsigned int i = 0; i < VectorizedArrayType::size(); i++)
     deallog << exponentiated_array[i] << " ";
   deallog << std::endl;
 }
index 4c1ce45c8c865653f51084187945f8f834854016..3ff642e466411458491d3ab4a72eafe83b3d403d 100644 (file)
@@ -25,11 +25,11 @@ template <typename VectorizedArrayType>
 void
 do_test()
 {
-  deallog << "  test " << VectorizedArrayType::n_array_elements
-          << " array elements" << std::endl;
+  deallog << "  test " << VectorizedArrayType::size() << " array elements"
+          << std::endl;
 
   VectorizedArrayType left;
-  for (unsigned int i = 0; i < VectorizedArrayType::n_array_elements; i++)
+  for (unsigned int i = 0; i < VectorizedArrayType::size(); i++)
     left[i] = i + 1.;
 
   VectorizedArrayType right(3.);
index 38a5b23a6ab4a2f5b738d29a921596afe6f22b69..41da2ff1a051a47fb0252c3ad44ecc4fb48c95f8 100644 (file)
@@ -31,8 +31,7 @@ do_test()
 {
   // since the number of array elements is system dependent, it is not a good
   // idea to print them to an output file. Instead, check the values manually
-  const unsigned int n_vectors =
-    VectorizedArray<Number, width>::n_array_elements;
+  const unsigned int n_vectors = VectorizedArray<Number, width>::size();
   VectorizedArray<Number, width> arr[n_numbers];
   Number                         other[n_vectors * n_numbers];
   unsigned int                   offsets[n_vectors];
index 9f45b1a05918620145ff2cbd02cb50acb6fea3b2..2354d068d103076279b91b9a713405dc7aac5b72 100644 (file)
@@ -26,15 +26,14 @@ void
 test_const(const VectorizedArray<Number> &vector)
 {
   AssertDimension(*std::max_element(vector.begin(), vector.end()),
-                  VectorizedArray<Number>::n_array_elements - 1);
+                  VectorizedArray<Number>::size() - 1);
   AssertDimension(std::distance(vector.begin(),
                                 std::max_element(vector.begin(), vector.end())),
-                  VectorizedArray<Number>::n_array_elements - 1);
+                  VectorizedArray<Number>::size() - 1);
   AssertDimension(std::distance(vector.begin(),
                                 vector.begin() +
-                                  (VectorizedArray<Number>::n_array_elements -
-                                   1)),
-                  VectorizedArray<Number>::n_array_elements - 1);
+                                  (VectorizedArray<Number>::size() - 1)),
+                  VectorizedArray<Number>::size() - 1);
 }
 
 template <typename Number>
@@ -42,19 +41,18 @@ void
 test_nonconst(VectorizedArray<Number> &vector)
 {
   AssertDimension(*std::max_element(vector.begin(), vector.end()),
-                  VectorizedArray<Number>::n_array_elements - 1);
+                  VectorizedArray<Number>::size() - 1);
   AssertDimension(std::distance(vector.begin(),
                                 std::max_element(vector.begin(), vector.end())),
-                  VectorizedArray<Number>::n_array_elements - 1);
+                  VectorizedArray<Number>::size() - 1);
   AssertDimension(std::distance(vector.begin(),
                                 vector.begin() +
-                                  (VectorizedArray<Number>::n_array_elements -
-                                   1)),
-                  VectorizedArray<Number>::n_array_elements - 1);
+                                  (VectorizedArray<Number>::size() - 1)),
+                  VectorizedArray<Number>::size() - 1);
 
   auto it = vector.begin();
-  std::advance(it, VectorizedArray<Number>::n_array_elements - 1);
-  AssertDimension(*it, VectorizedArray<Number>::n_array_elements - 1);
+  std::advance(it, VectorizedArray<Number>::size() - 1);
+  AssertDimension(*it, VectorizedArray<Number>::size() - 1);
 }
 
 template <typename Number>
index bf54655501e4b8a42e445066f62a422fcf7d9408..63e439d83b4ceade62ad67764227b0592b6a2cbd 100644 (file)
@@ -77,7 +77,7 @@ do_test(const unsigned int size)
     v3(w1.size());
   convert_to_vectorized(w1, v1);
 
-  constexpr unsigned int macro_size = VectorizedArray<double>::n_array_elements;
+  constexpr unsigned int macro_size = VectorizedArray<double>::size();
   Vector<double>         vec_flat(v1.size() * macro_size);
   std::array<unsigned int, macro_size> offsets;
   for (unsigned int i = 0; i < macro_size; ++i)
index 4849cb6306b31c622f0f8f2c20b862c4069d84c4..c645e5d1c1a9e43d3ddea8c9388ad5f2b9242156 100644 (file)
@@ -77,7 +77,7 @@ do_test()
     v3(w1.size());
   convert_to_vectorized(w1, v1);
 
-  constexpr unsigned int macro_size = VectorizedArray<double>::n_array_elements;
+  constexpr unsigned int macro_size = VectorizedArray<double>::size();
   Vector<double>         vec_flat(v1.size() * macro_size);
   std::array<unsigned int, macro_size> offsets;
   for (unsigned int i = 0; i < macro_size; ++i)
index 2e4126332f73d5f2160d4ed69ed3f47a45c983f7..f945172af2818ca497cb0cc674b64731cecf9e42 100644 (file)
@@ -77,7 +77,7 @@ do_test()
     v3(w1.size());
   convert_to_vectorized(w1, v1);
 
-  constexpr unsigned int macro_size = VectorizedArray<float>::n_array_elements;
+  constexpr unsigned int macro_size = VectorizedArray<float>::size();
   Vector<float>          vec_flat(v1.size() * macro_size);
   std::array<unsigned int, macro_size> offsets;
   for (unsigned int i = 0; i < macro_size; ++i)
index 4e6fb656e57164ea829338a3369de22e0977b146..1a0f155acc7d15d7b17c91b7a8e429542c17ad78 100644 (file)
@@ -71,7 +71,7 @@ do_test(const unsigned int size)
     v3(w1.size());
   convert_to_vectorized(w1, v1);
 
-  constexpr unsigned int macro_size = VectorizedArray<double>::n_array_elements;
+  constexpr unsigned int macro_size = VectorizedArray<double>::size();
   Vector<double>         vec_flat(v1.size() * macro_size);
   std::array<unsigned int, macro_size> offsets;
   for (unsigned int i = 0; i < macro_size; ++i)
index a6afbbda8a8dd892084a224378224ac76b3ffb8e..082254b95f0313e3254203c7d41cc58076f6171a 100644 (file)
@@ -92,8 +92,7 @@ public:
   {
     Tensor<1, dim, VectorizedArray<NumberType>> shift_vec;
     Point<dim>                                  p;
-    for (unsigned int v = 0; v < VectorizedArray<NumberType>::n_array_elements;
-         ++v)
+    for (unsigned int v = 0; v < VectorizedArray<NumberType>::size(); ++v)
       {
         for (unsigned int d = 0; d < dim; ++d)
           p[d] = p_vec[d][v];
@@ -256,8 +255,7 @@ test(const unsigned int n_ref = 0)
               const auto &qp = fe_eval.quadrature_point(q);
               const auto  v2 = qp + displacement_function.shift_value(qp);
               VectorizedArray<NumberType> dist = v1.distance(v2);
-              for (unsigned int v = 0;
-                   v < VectorizedArray<NumberType>::n_array_elements;
+              for (unsigned int v = 0; v < VectorizedArray<NumberType>::size();
                    ++v)
                 AssertThrow(dist[v] < 1e-8,
                             ExcMessage("distance: " + std::to_string(dist[v])));
@@ -336,7 +334,7 @@ test(const unsigned int n_ref = 0)
                 const auto  v2 = qp + displacement_function.shift_value(qp);
                 VectorizedArray<NumberType> dist = v1.distance(v2);
                 for (unsigned int v = 0;
-                     v < VectorizedArray<NumberType>::n_array_elements;
+                     v < VectorizedArray<NumberType>::size();
                      ++v)
                   AssertThrow(dist[v] < 1e-8,
                               ExcMessage(
index fcfc47daa06bee7b550a50589083c9ca1db25496..10e848d4f2cfd5754f992f2b9fe2476566f67a6d 100644 (file)
@@ -107,7 +107,7 @@ private:
     FEEvaluation<dim, fe_degree, n_q_points_1d, n_components, number> phi(
       data, 0, 0, start_vector_component);
 
-    const unsigned int n_vect = VectorizedArray<number>::n_array_elements;
+    const unsigned int n_vect = VectorizedArray<number>::size();
 
     for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
       {
@@ -143,7 +143,7 @@ private:
                                       n_components,
                                       number>::value_type value_type;
 
-    const unsigned int n_vect = VectorizedArray<number>::n_array_elements;
+    const unsigned int n_vect = VectorizedArray<number>::size();
 
     for (unsigned int face = face_range.first; face < face_range.second; face++)
       {
@@ -200,7 +200,7 @@ private:
                                       n_components,
                                       number>::value_type value_type;
 
-    const unsigned int n_vect = VectorizedArray<number>::n_array_elements;
+    const unsigned int n_vect = VectorizedArray<number>::size();
 
     for (unsigned int face = face_range.first; face < face_range.second; face++)
       {
@@ -225,7 +225,7 @@ private:
         for (unsigned int v = 0; v < n_vect; ++v)
           {
             std::bitset<n_vect> mask =
-              std::bitset<VectorizedArray<number>::n_array_elements>();
+              std::bitset<VectorizedArray<number>::size()>();
             mask[v] = true;
             fe_eval.distribute_local_to_global(dst, 0, mask);
           }
index e683e8f6855b34dd13a7cd602ae2d6cc18a4634a..c2bdef206c184329b5e4a7cf125345385891bec3 100644 (file)
@@ -89,12 +89,12 @@ do_test(const DoFHandler<dim> &dof)
 
         fe_eval.reinit(cell);
         for (unsigned int i = 0; i < dofs_per_cell;
-             i += VectorizedArray<double>::n_array_elements)
+             i += VectorizedArray<double>::size())
           {
             const unsigned int n_items =
-              i + VectorizedArray<double>::n_array_elements > dofs_per_cell ?
+              i + VectorizedArray<double>::size() > dofs_per_cell ?
                 (dofs_per_cell - i) :
-                VectorizedArray<double>::n_array_elements;
+                VectorizedArray<double>::size();
             for (unsigned int j = 0; j < dofs_per_cell; ++j)
               fe_eval.begin_dof_values()[j] = VectorizedArray<double>();
             for (unsigned int v = 0; v < n_items; ++v)
index b58fb5a84da8d93d599cd61a5c4d8dce5bc68a9a..a6206ed518d5ddb6daeecd7106b4a759f63765c9 100644 (file)
@@ -112,12 +112,12 @@ do_test(const DoFHandler<dim> &dof)
         const unsigned int dofs_per_cell_u = phi_u.dofs_per_cell;
         const unsigned int dofs_per_cell_p = phi_p.dofs_per_cell;
         for (unsigned int i = 0; i < dofs_per_cell_u;
-             i += VectorizedArray<double>::n_array_elements)
+             i += VectorizedArray<double>::size())
           {
             const unsigned int n_items =
-              i + VectorizedArray<double>::n_array_elements > dofs_per_cell_u ?
+              i + VectorizedArray<double>::size() > dofs_per_cell_u ?
                 (dofs_per_cell_u - i) :
-                VectorizedArray<double>::n_array_elements;
+                VectorizedArray<double>::size();
             for (unsigned int j = 0; j < dofs_per_cell_u; ++j)
               phi_u.begin_dof_values()[j] = VectorizedArray<double>();
             for (unsigned int v = 0; v < n_items; ++v)
@@ -148,12 +148,12 @@ do_test(const DoFHandler<dim> &dof)
           }
 
         for (unsigned int i = 0; i < dofs_per_cell_p;
-             i += VectorizedArray<double>::n_array_elements)
+             i += VectorizedArray<double>::size())
           {
             const unsigned int n_items =
-              i + VectorizedArray<double>::n_array_elements > dofs_per_cell_p ?
+              i + VectorizedArray<double>::size() > dofs_per_cell_p ?
                 (dofs_per_cell_p - i) :
-                VectorizedArray<double>::n_array_elements;
+                VectorizedArray<double>::size();
             for (unsigned int j = 0; j < dofs_per_cell_p; ++j)
               phi_p.begin_dof_values()[j] = VectorizedArray<double>();
             for (unsigned int v = 0; v < n_items; ++v)
index a4c8c38adc23bc256c8f25f3f491dc7feeede48e..9eea186af09de2bbd40e48cd5d21b9a730b4e204 100644 (file)
@@ -110,12 +110,12 @@ assemble_on_cell(const typename DoFHandler<dim>::active_cell_iterator &cell,
   FEEvaluation<dim, fe_degree> &fe_eval = data.fe_eval[0];
   fe_eval.reinit(cell);
   for (unsigned int i = 0; i < dofs_per_cell;
-       i += VectorizedArray<double>::n_array_elements)
+       i += VectorizedArray<double>::size())
     {
       const unsigned int n_items =
-        i + VectorizedArray<double>::n_array_elements > dofs_per_cell ?
+        i + VectorizedArray<double>::size() > dofs_per_cell ?
           (dofs_per_cell - i) :
-          VectorizedArray<double>::n_array_elements;
+          VectorizedArray<double>::size();
       for (unsigned int j = 0; j < dofs_per_cell; ++j)
         fe_eval.begin_dof_values()[j] = VectorizedArray<double>();
       for (unsigned int v = 0; v < n_items; ++v)
index bd572189021b1c54a763f60477caaaaf9b18c0bb..0dbccc766ab46c71b27517c4e516f81162e3f284 100644 (file)
@@ -43,7 +43,7 @@ void
 compare_indices(const MatrixFree<dim, number> *mf_data)
 {
   const unsigned int     n_batches  = mf_data->n_macro_cells();
-  constexpr unsigned int batch_size = VectorizedArray<number>::n_array_elements;
+  constexpr unsigned int batch_size = VectorizedArray<number>::size();
   for (unsigned int batch_no = 0; batch_no < n_batches; ++batch_no)
     {
       const unsigned int n_lanes_filled =
index 90fe98dcf8ebe449f8e9ac1688ef327df5e23ccf..5ab473d1f73293417424db1aa13adc9ec799359a 100644 (file)
@@ -278,13 +278,10 @@ private:
                         phif.inverse_jacobian(0))[dim - 1]) *
               (number)(std::max(1, fe_degree) * (fe_degree + 1.0)) * 2.;
 
-            std::array<types::boundary_id,
-                       VectorizedArray<number>::n_array_elements>
+            std::array<types::boundary_id, VectorizedArray<number>::size()>
                                     boundary_ids = data.get_faces_by_cells_boundary_id(cell, face);
             VectorizedArray<number> factor_boundary;
-            for (unsigned int v = 0;
-                 v < VectorizedArray<number>::n_array_elements;
-                 ++v)
+            for (unsigned int v = 0; v < VectorizedArray<number>::size(); ++v)
               // interior face
               if (boundary_ids[v] == numbers::invalid_boundary_id)
                 factor_boundary[v] = 0.5;
index 4a04f8f50d3fe594b6786f77f1917d84a6c417d9..2ffe08aff39887827ec349bc11cc2fcc7bf21a14 100644 (file)
@@ -101,9 +101,7 @@ test()
         n_inner_other_faces(2 * dim), n_boundary_faces(2 * dim);
       for (unsigned int f = 0; f < mf_data.n_inner_face_batches(); ++f)
         {
-          for (unsigned int v = 0;
-               v < VectorizedArray<double>::n_array_elements;
-               ++v)
+          for (unsigned int v = 0; v < VectorizedArray<double>::size(); ++v)
             if (mf_data.get_face_info(f).cells_interior[v] !=
                 numbers::invalid_unsigned_int)
               {
@@ -117,9 +115,7 @@ test()
            mf_data.n_inner_face_batches() + mf_data.n_boundary_face_batches();
            ++f)
         {
-          for (unsigned int v = 0;
-               v < VectorizedArray<double>::n_array_elements;
-               ++v)
+          for (unsigned int v = 0; v < VectorizedArray<double>::size(); ++v)
             if (mf_data.get_face_info(f).cells_interior[v] !=
                 numbers::invalid_unsigned_int)
               {
index 9596192e9d0de47c8e067f4278a8b7db8820cb70..4303a1f86a058714f6503f13a9edc70d30b94d43 100644 (file)
@@ -97,10 +97,9 @@ test(const bool adaptive_ref = true)
     mf_data->reinit(dof, constraints, quad, data);
   }
 
-  const unsigned int     n_cells  = mf_data->n_macro_cells();
-  const auto &           dof_info = mf_data->get_dof_info();
-  constexpr unsigned int n_vectorization =
-    VectorizedArray<number>::n_array_elements;
+  const unsigned int     n_cells         = mf_data->n_macro_cells();
+  const auto &           dof_info        = mf_data->get_dof_info();
+  constexpr unsigned int n_vectorization = VectorizedArray<number>::size();
 
   std::vector<unsigned int> my_rows;
   my_rows.reserve(fe.dofs_per_cell * n_vectorization);
index 70dbdc726b8cb7e883cf8376f98b4c59535edd72..8ba0a542fd4ccbb9626560fca41b5ed2f02b4eec 100644 (file)
@@ -99,10 +99,9 @@ test(const bool adaptive_ref = true)
     mf_data->reinit(dof, constraints, quad, data);
   }
 
-  const unsigned int     n_cells  = mf_data->n_macro_cells();
-  const auto &           dof_info = mf_data->get_dof_info();
-  constexpr unsigned int n_vectorization =
-    VectorizedArray<number>::n_array_elements;
+  const unsigned int     n_cells         = mf_data->n_macro_cells();
+  const auto &           dof_info        = mf_data->get_dof_info();
+  constexpr unsigned int n_vectorization = VectorizedArray<number>::size();
 
   std::vector<unsigned int> my_rows;
   my_rows.reserve(fe.dofs_per_cell * n_vectorization);
index bbc3312f0fb68082d47d1ea78089e066b296b50e..2c16d3669b8685e41e53487677eefef882fe9691 100644 (file)
@@ -119,7 +119,7 @@ test(const FiniteElement<dim> &fe, const unsigned int n_iterations)
   {
     const QGauss<1>                                  quad(fe_degree + 1);
     typename MatrixFree<dim, number>::AdditionalData data;
-    data.tasks_block_size = 8 / VectorizedArray<number>::n_array_elements;
+    data.tasks_block_size = 8 / VectorizedArray<number>::size();
     mf_data.reinit(dof, constraints, quad, data);
   }
 
index 997d65fe17728c0f5af2dcb87a40e6a67ec8336e..b74eb677600621a0963a524cd44efcb5930158fb 100644 (file)
@@ -40,7 +40,7 @@ test()
 
   VectorizedArray<double> x[N], x_ref[N], y[M], y_ref[M];
   for (unsigned int i = 0; i < N; ++i)
-    for (unsigned int v = 0; v < VectorizedArray<double>::n_array_elements; ++v)
+    for (unsigned int v = 0; v < VectorizedArray<double>::size(); ++v)
       x[i][v] = random_value<double>();
 
   // compute reference
@@ -71,8 +71,7 @@ test()
   for (unsigned int i = 0; i < M; ++i)
     {
       deallog << y[i][0] - y_ref[i][0] << " ";
-      for (unsigned int v = 1; v < VectorizedArray<double>::n_array_elements;
-           ++v)
+      for (unsigned int v = 1; v < VectorizedArray<double>::size(); ++v)
         AssertThrow(std::abs(y[i][v] - y_ref[i][v]) < 1e-12,
                     ExcInternalError());
     }
@@ -80,7 +79,7 @@ test()
 
 
   for (unsigned int i = 0; i < M; ++i)
-    for (unsigned int v = 0; v < VectorizedArray<double>::n_array_elements; ++v)
+    for (unsigned int v = 0; v < VectorizedArray<double>::size(); ++v)
       y[i][v] = random_value<double>();
 
   // compute reference
@@ -104,8 +103,7 @@ test()
   for (unsigned int i = 0; i < N; ++i)
     {
       deallog << x[i][0] - x_ref[i][0] << " ";
-      for (unsigned int v = 1; v < VectorizedArray<double>::n_array_elements;
-           ++v)
+      for (unsigned int v = 1; v < VectorizedArray<double>::size(); ++v)
         AssertThrow(std::abs(x[i][v] - x_ref[i][v]) < 1e-12,
                     ExcInternalError());
     }
index a9366f40a630cc58dad392b66bac8474aec7bcc3..98ef87100096143ac537aa6c5a7d062da2c6b5f1 100644 (file)
@@ -69,7 +69,7 @@ test()
 
   VectorizedArray<double> x[N], x_ref[N], y[M], y_ref[M];
   for (unsigned int i = 0; i < N; ++i)
-    for (unsigned int v = 0; v < VectorizedArray<double>::n_array_elements; ++v)
+    for (unsigned int v = 0; v < VectorizedArray<double>::size(); ++v)
       x[i][v] = random_value<double>();
 
   // compute reference
@@ -100,15 +100,14 @@ test()
   for (unsigned int i = 0; i < M; ++i)
     {
       deallog << y[i][0] - y_ref[i][0] << " ";
-      for (unsigned int v = 1; v < VectorizedArray<double>::n_array_elements;
-           ++v)
+      for (unsigned int v = 1; v < VectorizedArray<double>::size(); ++v)
         AssertThrow(std::abs(y[i][v] - y_ref[i][v]) < 1e-12,
                     ExcInternalError());
     }
   deallog << std::endl;
 
   for (unsigned int i = 0; i < M; ++i)
-    for (unsigned int v = 0; v < VectorizedArray<double>::n_array_elements; ++v)
+    for (unsigned int v = 0; v < VectorizedArray<double>::size(); ++v)
       y[i][v] = random_value<double>();
 
   // compute reference
@@ -132,8 +131,7 @@ test()
   for (unsigned int i = 0; i < N; ++i)
     {
       deallog << x[i][0] - x_ref[i][0] << " ";
-      for (unsigned int v = 1; v < VectorizedArray<double>::n_array_elements;
-           ++v)
+      for (unsigned int v = 1; v < VectorizedArray<double>::size(); ++v)
         AssertThrow(std::abs(x[i][v] - x_ref[i][v]) < 1e-12,
                     ExcInternalError());
     }
index b52eaa9c7757badc8e7507c8701125fb402bc4de..b712942448ce3b57e0636a3aa224db7cfe39c191 100644 (file)
@@ -48,7 +48,7 @@ test()
 
   VectorizedArray<double> x[N], x_ref[N], y[M], y_ref[M];
   for (unsigned int i = 0; i < N; ++i)
-    for (unsigned int v = 0; v < VectorizedArray<double>::n_array_elements; ++v)
+    for (unsigned int v = 0; v < VectorizedArray<double>::size(); ++v)
       x[i][v] = random_value<double>();
 
   // compute reference
@@ -79,8 +79,7 @@ test()
   for (unsigned int i = 0; i < M; ++i)
     {
       deallog << y[i][0] - y_ref[i][0] << " ";
-      for (unsigned int v = 1; v < VectorizedArray<double>::n_array_elements;
-           ++v)
+      for (unsigned int v = 1; v < VectorizedArray<double>::size(); ++v)
         AssertThrow(std::abs(y[i][v] - y_ref[i][v]) < 1e-12,
                     ExcInternalError());
     }
@@ -88,7 +87,7 @@ test()
 
 
   for (unsigned int i = 0; i < M; ++i)
-    for (unsigned int v = 0; v < VectorizedArray<double>::n_array_elements; ++v)
+    for (unsigned int v = 0; v < VectorizedArray<double>::size(); ++v)
       y[i][v] = random_value<double>();
 
   // compute reference
@@ -112,8 +111,7 @@ test()
   for (unsigned int i = 0; i < N; ++i)
     {
       deallog << x[i][0] - x_ref[i][0] << " ";
-      for (unsigned int v = 1; v < VectorizedArray<double>::n_array_elements;
-           ++v)
+      for (unsigned int v = 1; v < VectorizedArray<double>::size(); ++v)
         AssertThrow(std::abs(x[i][v] - x_ref[i][v]) < 1e-12,
                     ExcInternalError());
     }
index e57f50518b7aef3409eba6e478d787accb0c4b2a..17aac3574686ef1df258744990fe9fd205404b1c 100644 (file)
@@ -88,9 +88,7 @@ private:
           {
             VectorizedArray<number> diff =
               (ref.get_value(q) - check.get_value(q));
-            for (unsigned int v = 0;
-                 v < VectorizedArray<number>::n_array_elements;
-                 ++v)
+            for (unsigned int v = 0; v < VectorizedArray<number>::size(); ++v)
               {
                 if (std::abs(diff[v]) > 1e-12)
                   {
@@ -138,9 +136,7 @@ private:
           {
             VectorizedArray<number> diff =
               (refr.get_value(q) - checkr.get_value(q));
-            for (unsigned int v = 0;
-                 v < VectorizedArray<number>::n_array_elements;
-                 ++v)
+            for (unsigned int v = 0; v < VectorizedArray<number>::size(); ++v)
               {
                 if (std::abs(diff[v]) > 1e-12)
                   {
index 617f3bc26872bee5c835f641dac40252f5e8b09b..2c60da94a14ebf5076e7a91cf7c439104b401238 100644 (file)
@@ -88,9 +88,7 @@ private:
           {
             VectorizedArray<number> diff =
               (ref.get_value(q) - check.get_value(q));
-            for (unsigned int v = 0;
-                 v < VectorizedArray<number>::n_array_elements;
-                 ++v)
+            for (unsigned int v = 0; v < VectorizedArray<number>::size(); ++v)
               {
                 if (std::abs(diff[v]) > 1e-12)
                   {
@@ -138,9 +136,7 @@ private:
           {
             VectorizedArray<number> diff =
               (refr.get_value(q) - checkr.get_value(q));
-            for (unsigned int v = 0;
-                 v < VectorizedArray<number>::n_array_elements;
-                 ++v)
+            for (unsigned int v = 0; v < VectorizedArray<number>::size(); ++v)
               {
                 if (std::abs(diff[v]) > 1e-12)
                   {
index 2c6f45e29cf06b74105c90261767f0077bb26b86..364714ccfd27942375aec9ccc0e431e1317288a3 100644 (file)
@@ -132,8 +132,7 @@ operator()(const MatrixFree<dim, Number> &data,
       // FEEvaluations. Those are tested in other
       // functions and seen as reference here
       for (unsigned int q = 0; q < fe_eval.n_q_points; ++q)
-        for (unsigned int j = 0; j < VectorizedArray<Number>::n_array_elements;
-             ++j)
+        for (unsigned int j = 0; j < VectorizedArray<Number>::size(); ++j)
           {
             errors[0] +=
               std::fabs(fe_eval.get_value(q)[j] - fe_eval2.get_value(q)[j]);
index db387ee071a5a9d8d35657979f05ddd784356232..95f46ed9658ea8c625e35e0875681300df0321ea 100644 (file)
@@ -128,8 +128,7 @@ operator()(const MatrixFree<dim, Number> &data,
       // FEEvaluations. Those are tested in other
       // functions and seen as reference here
       for (unsigned int q = 0; q < fe_eval.n_q_points; ++q)
-        for (unsigned int j = 0; j < VectorizedArray<Number>::n_array_elements;
-             ++j)
+        for (unsigned int j = 0; j < VectorizedArray<Number>::size(); ++j)
           {
             errors[0] +=
               std::fabs(fe_eval.get_value(q)[j] - fe_eval2.get_value(q)[j]);
index 58550ef4e804be7edaa8c3b739b604a0cb6355ec..67cf1d29dec4c260d8d4d59998f8b64539764679 100644 (file)
@@ -75,9 +75,7 @@ public:
         fe_eval_plain.read_dof_values_plain(src);
 
         for (unsigned int i = 0; i < fe_eval.dofs_per_cell; ++i)
-          for (unsigned int j = 0;
-               j < VectorizedArray<Number>::n_array_elements;
-               ++j)
+          for (unsigned int j = 0; j < VectorizedArray<Number>::size(); ++j)
             {
               error += std::fabs(fe_eval.get_dof_value(i)[j] -
                                  fe_eval_plain.get_dof_value(i)[j]);
index 914fbf42180aa0c3c166a638cb6276bf643d1213..ce14deb268ce90ec11e4feb2b1431a4b8ca16a9c 100644 (file)
@@ -130,8 +130,7 @@ public:
         fe_evalp.read_dof_values(src);
         fe_evalp.evaluate(true, true);
 
-        for (unsigned int j = 0; j < VectorizedArray<Number>::n_array_elements;
-             ++j)
+        for (unsigned int j = 0; j < VectorizedArray<Number>::size(); ++j)
           {
             // skip empty components in VectorizedArray
             if (data.get_face_info(face).cells_interior[j] ==
@@ -194,8 +193,7 @@ public:
         fe_evalm.read_dof_values(src);
         fe_evalm.evaluate(true, true);
 
-        for (unsigned int j = 0; j < VectorizedArray<Number>::n_array_elements;
-             ++j)
+        for (unsigned int j = 0; j < VectorizedArray<Number>::size(); ++j)
           {
             // skip empty components in VectorizedArray
             if (data.get_face_info(face).cells_interior[j] ==
index 5b1770cd5a0d52845e98947e1f13ba09cb0c2f3f..a88bd4b8d5808aedef1d7bdff94348d77a79a6e0 100644 (file)
@@ -69,7 +69,7 @@ public:
   {
     VectorizedArray<double> res = make_vectorized_array(0.);
     Point<dim>              p;
-    for (unsigned int v = 0; v < VectorizedArray<double>::n_array_elements; ++v)
+    for (unsigned int v = 0; v < VectorizedArray<double>::size(); ++v)
       {
         for (unsigned int d = 0; d < dim; d++)
           p[d] = p_vec[d][v];
index 9372a9be23591226e49c73ab8128421937cd4bdc..e8f86e88c449e59e469d1b56344b18b871d71da5 100644 (file)
@@ -83,8 +83,7 @@ class MatrixFreeTest
 {
 public:
   typedef VectorizedArray<Number> vector_t;
-  static const std::size_t        n_vectors =
-    VectorizedArray<Number>::n_array_elements;
+  static const std::size_t        n_vectors = VectorizedArray<Number>::size();
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
index c391df4808a71c68b25f2b3918848fd0739b370e..f9000a4fa289bc7adb00d72bb9d9cbccbe26f509 100644 (file)
@@ -83,8 +83,7 @@ class MatrixFreeTest
 {
 public:
   typedef VectorizedArray<Number> vector_t;
-  static const std::size_t        n_vectors =
-    VectorizedArray<Number>::n_array_elements;
+  static const std::size_t        n_vectors = VectorizedArray<Number>::size();
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
index 05a6a32eb548c24798a9eaa38abeea80eccb6ced..1cb372566167da2817068123f64f91d5f56f7b88 100644 (file)
@@ -95,8 +95,7 @@ class MatrixFreeTest
 {
 public:
   typedef VectorizedArray<Number> vector_t;
-  static const std::size_t        n_vectors =
-    VectorizedArray<Number>::n_array_elements;
+  static const std::size_t        n_vectors = VectorizedArray<Number>::size();
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
index 4266bda7481c5dfe9d30ae8a3a791936af2af2ae..8eca70a3b3509cfe80c1642c8e9a44dce7044b50 100644 (file)
@@ -85,8 +85,7 @@ class MatrixFreeTest
 {
 public:
   typedef VectorizedArray<Number> vector_t;
-  static const std::size_t        n_vectors =
-    VectorizedArray<Number>::n_array_elements;
+  static const std::size_t        n_vectors = VectorizedArray<Number>::size();
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
index 89ac7ef7d1f13c40324e77227af57eab5c91a65d..60b96837b454062629561863ceb51ab49d6152a1 100644 (file)
@@ -84,8 +84,7 @@ class MatrixFreeTest
 {
 public:
   typedef VectorizedArray<Number> vector_t;
-  static const std::size_t        n_vectors =
-    VectorizedArray<Number>::n_array_elements;
+  static const std::size_t        n_vectors = VectorizedArray<Number>::size();
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
index 0fc5b02e96aac57f89abd961e355d891d14e876d..99320148a7fcab31c3d361f23b0f892acc421b49 100644 (file)
@@ -96,8 +96,7 @@ class MatrixFreeTest
 {
 public:
   typedef VectorizedArray<Number> vector_t;
-  static const std::size_t        n_vectors =
-    VectorizedArray<Number>::n_array_elements;
+  static const std::size_t        n_vectors = VectorizedArray<Number>::size();
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
index 7e91396c31aaa7b675a8fb331d8be116cc94bb39..71e2691928bb79b1d052b43f055c6ff2c7bd840e 100644 (file)
@@ -165,17 +165,14 @@ private:
           {
             value_type average_value =
               (fe_eval.get_value(q) - fe_eval_neighbor.get_value(q)) *
-              make_vectorized_array<number,
-                                    VectorizedArrayType::n_array_elements>(0.5);
+              make_vectorized_array<number, VectorizedArrayType::size()>(0.5);
             value_type average_valgrad =
               fe_eval.get_normal_derivative(q) +
               fe_eval_neighbor.get_normal_derivative(q);
             average_valgrad =
               average_value * sigmaF -
               average_valgrad *
-                make_vectorized_array<number,
-                                      VectorizedArrayType::n_array_elements>(
-                  0.5);
+                make_vectorized_array<number, VectorizedArrayType::size()>(0.5);
             fe_eval.submit_normal_derivative(-average_value, q);
             fe_eval_neighbor.submit_normal_derivative(-average_value, q);
             fe_eval.submit_value(average_valgrad, q);
@@ -369,17 +366,14 @@ private:
           {
             value_type average_value =
               (fe_eval.get_value(q) - fe_eval_neighbor.get_value(q)) *
-              make_vectorized_array<number,
-                                    VectorizedArrayType::n_array_elements>(0.5);
+              make_vectorized_array<number, VectorizedArrayType::size()>(0.5);
             value_type average_valgrad =
               fe_eval.get_normal_derivative(q) +
               fe_eval_neighbor.get_normal_derivative(q);
             average_valgrad =
               average_value * sigmaF -
               average_valgrad *
-                make_vectorized_array<number,
-                                      VectorizedArrayType::n_array_elements>(
-                  0.5);
+                make_vectorized_array<number, VectorizedArrayType::size()>(0.5);
             fe_eval.submit_normal_derivative(-average_value, q);
             fe_eval_neighbor.submit_normal_derivative(-average_value, q);
             fe_eval.submit_value(average_valgrad, q);
@@ -592,9 +586,7 @@ private:
             const VectorizedArrayType normal_times_advection =
               advection * phi_m.get_normal_vector(q);
             const value_type flux_times_normal =
-              make_vectorized_array<number,
-                                    VectorizedArrayType::n_array_elements>(
-                0.5) *
+              make_vectorized_array<number, VectorizedArrayType::size()>(0.5) *
               ((u_minus + u_plus) * normal_times_advection +
                std::abs(normal_times_advection) * (u_minus - u_plus));
             phi_m.submit_value(-flux_times_normal, q);
@@ -628,8 +620,7 @@ private:
                                 number,
                                 VectorizedArrayType>::value_type value_type;
     value_type                                                   u_plus;
-    u_plus =
-      make_vectorized_array<number, VectorizedArrayType::n_array_elements>(1.3);
+    u_plus = make_vectorized_array<number, VectorizedArrayType::size()>(1.3);
 
     for (unsigned int face = face_range.first; face < face_range.second; face++)
       {
@@ -642,9 +633,7 @@ private:
             const VectorizedArrayType normal_times_advection =
               advection * fe_eval.get_normal_vector(q);
             const value_type flux_times_normal =
-              make_vectorized_array<number,
-                                    VectorizedArrayType::n_array_elements>(
-                0.5) *
+              make_vectorized_array<number, VectorizedArrayType::size()>(0.5) *
               ((u_minus + u_plus) * normal_times_advection +
                std::abs(normal_times_advection) * (u_minus - u_plus));
             fe_eval.submit_value(-flux_times_normal, q);
index 733a0b0b664d8fb134722d340ec5225f00e49d0c..7df1f593a076fe13dc920fea98ce66d4afc2a351 100644 (file)
@@ -331,13 +331,10 @@ private:
               std::abs((phif.get_normal_vector(0) *
                         phif.inverse_jacobian(0))[dim - 1]) *
               (number)(std::max(1, fe_degree) * (fe_degree + 1.0)) * 2.;
-            std::array<types::boundary_id,
-                       VectorizedArray<number>::n_array_elements>
+            std::array<types::boundary_id, VectorizedArray<number>::size()>
                                     boundary_ids = data.get_faces_by_cells_boundary_id(cell, face);
             VectorizedArray<number> factor_boundary;
-            for (unsigned int v = 0;
-                 v < VectorizedArray<number>::n_array_elements;
-                 ++v)
+            for (unsigned int v = 0; v < VectorizedArray<number>::size(); ++v)
               // interior face
               if (boundary_ids[v] == numbers::invalid_boundary_id)
                 factor_boundary[v] = 0.5;
index 2599d3930ef132453313d87738eda02c8185074f..302c6e234cd3128651aecd352f60f5ab80974db1 100644 (file)
@@ -85,9 +85,7 @@ public:
 
         // values should evaluate to one, derivatives to zero
         for (unsigned int q = 0; q < fe_eval.n_q_points; ++q)
-          for (unsigned int d = 0;
-               d < VectorizedArray<Number>::n_array_elements;
-               ++d)
+          for (unsigned int d = 0; d < VectorizedArray<Number>::size(); ++d)
             {
               Assert(fe_eval.get_value(q)[d] == 1., ExcInternalError());
               for (unsigned int e = 0; e < dim; ++e)
index 415256267f5c22753eae08613c85b1f980872058..8ebed3be8f8c65c9838320192eff96efdb5af45e 100644 (file)
@@ -180,8 +180,7 @@ private:
       }
   }
 
-  AlignedVector<std::array<CellId, VectorizedArrayType::n_array_elements>>
-    cell_ids;
+  AlignedVector<std::array<CellId, VectorizedArrayType::size()>> cell_ids;
 };
 
 
index 7a11f6a1e5a6bde2202c244a4ed0ab7f4d89a932..b5341333609fe21d387f7645b1f9dd53244fef90 100644 (file)
@@ -151,8 +151,7 @@ private:
       }
   }
 
-  AlignedVector<std::array<CellId, VectorizedArrayType::n_array_elements>>
-    cell_ids;
+  AlignedVector<std::array<CellId, VectorizedArrayType::size()>> cell_ids;
 };
 
 
index b8106a0c5bc6c52c6a2e5e030a5cdb5d976041a3..2c3e592b3e4d036687094c034999e8dfc83e872f 100644 (file)
@@ -154,9 +154,7 @@ namespace Step48
             // components (should be stable irrespective of vectorization
             // width)
             if (q == 0)
-              for (unsigned int v = 0;
-                   v < VectorizedArray<double>::n_array_elements;
-                   ++v)
+              for (unsigned int v = 0; v < VectorizedArray<double>::size(); ++v)
                 deallog << submit_value[v] << " = " << simple_value[v] << " - "
                         << sin_value[v] << std::endl;
           }
index 67aebc6b53bd3f35dca87a077880c78db9c67c26..1accfa44e6b1286b06080f95b542980797d3012b 100644 (file)
@@ -486,9 +486,7 @@ namespace StokesClass
           {
             VectorizedArray<number> return_value =
               make_vectorized_array<number>(1.);
-            for (unsigned int i = 0;
-                 i < VectorizedArray<number>::n_array_elements;
-                 ++i)
+            for (unsigned int i = 0; i < VectorizedArray<number>::size(); ++i)
               {
                 Point<dim> p;
                 for (unsigned int d = 0; d < dim; ++d)
@@ -623,9 +621,7 @@ namespace StokesClass
           {
             VectorizedArray<number> return_value =
               make_vectorized_array<number>(1.);
-            for (unsigned int i = 0;
-                 i < VectorizedArray<number>::n_array_elements;
-                 ++i)
+            for (unsigned int i = 0; i < VectorizedArray<number>::size(); ++i)
               {
                 Point<dim> p;
                 for (unsigned int d = 0; d < dim; ++d)
@@ -803,9 +799,7 @@ namespace StokesClass
           {
             VectorizedArray<number> return_value =
               make_vectorized_array<number>(1.);
-            for (unsigned int i = 0;
-                 i < VectorizedArray<number>::n_array_elements;
-                 ++i)
+            for (unsigned int i = 0; i < VectorizedArray<number>::size(); ++i)
               {
                 Point<dim> p;
                 for (unsigned int d = 0; d < dim; ++d)
@@ -1228,9 +1222,7 @@ namespace StokesClass
             for (unsigned int d = 0; d < dim; ++d)
               rhs_u[d] = make_vectorized_array<double>(1.0);
             VectorizedArray<double> rhs_p = make_vectorized_array<double>(1.0);
-            for (unsigned int i = 0;
-                 i < VectorizedArray<double>::n_array_elements;
-                 ++i)
+            for (unsigned int i = 0; i < VectorizedArray<double>::size(); ++i)
               {
                 Point<dim> p;
                 for (unsigned int d = 0; d < dim; ++d)
index 580a18d547dc58b563aa44698d75ad6b84ad51d4..2ab69a3df7359c1041c7cca1f0388b8c232f391b 100644 (file)
@@ -78,7 +78,7 @@ public:
   {
     VectorizedArray<double> res = make_vectorized_array(0.);
     Point<dim>              p;
-    for (unsigned int v = 0; v < VectorizedArray<double>::n_array_elements; ++v)
+    for (unsigned int v = 0; v < VectorizedArray<double>::size(); ++v)
       {
         for (unsigned int d = 0; d < dim; d++)
           p[d] = p_vec[d][v];
index 357a4926a253cab7500480e47f3d7d6d32f06e3f..2f9a0dc2cb39afe8455ee92fc71bd36a2bedd8ba 100644 (file)
@@ -80,7 +80,7 @@ public:
   {
     VectorizedArray<double> res = make_vectorized_array(0.);
     Point<dim>              p;
-    for (unsigned int v = 0; v < VectorizedArray<double>::n_array_elements; ++v)
+    for (unsigned int v = 0; v < VectorizedArray<double>::size(); ++v)
       {
         for (unsigned int d = 0; d < dim; d++)
           p[d] = p_vec[d][v];
index 10ef530719ade41fef02d886e1efb2f8cabb3bd1..130f7d3fdd1309b2eff0e64b4575a7f38c70a937 100644 (file)
@@ -55,7 +55,7 @@ main()
 
   // Scale the gradients along the vectorization-index so that each grad_u[v] is
   // unique.
-  for (unsigned int v = 0; v < VectorizedArray<double>::n_array_elements; v++)
+  for (unsigned int v = 0; v < VectorizedArray<double>::size(); v++)
     for (unsigned int i = 0; i < dim; i++)
       for (unsigned int j = 0; j < dim; j++)
         grad_u[i][j][v] *= (v + 1);
@@ -69,7 +69,7 @@ main()
 
   // You can't use .norm() on some difference-tensor of the two so we compare
   // element-wise!
-  for (unsigned int v = 0; v < VectorizedArray<double>::n_array_elements; v++)
+  for (unsigned int v = 0; v < VectorizedArray<double>::size(); v++)
     for (unsigned int i = 0; i < dim; i++)
       for (unsigned int j = 0; j < dim; j++)
         if (F_solution[i][j][v] - F_test[i][j][v] != 0.0)
@@ -84,7 +84,7 @@ main()
   SymmetricTensor<2, dim, VectorizedArray<double>> E_test =
     Kinematics::E(F_test);
 
-  for (unsigned int v = 0; v < VectorizedArray<double>::n_array_elements; v++)
+  for (unsigned int v = 0; v < VectorizedArray<double>::size(); v++)
     for (unsigned int i = 0; i < dim; i++)
       for (unsigned int j = 0; j < dim; j++)
         if (E_test[i][j][v] - E_solution[i][j][v] != 0.0)
@@ -96,7 +96,7 @@ main()
   Tensor<2, dim, VectorizedArray<double>> F_iso_test;
   F_iso_test = Kinematics::F_iso(F_test);
 
-  for (unsigned int v = 0; v < VectorizedArray<double>::n_array_elements; v++)
+  for (unsigned int v = 0; v < VectorizedArray<double>::size(); v++)
     for (unsigned int i = 0; i < dim; i++)
       for (unsigned int j = 0; j < dim; j++)
         if (F_iso_test[i][j][v] - F_iso_solution[i][j][v] != 0.0)
index 1c1e40153f34e4b1f63cd929914e837ccf35e703..17c2406b3ef3bb2df4d9f6ffa8b6b5ca8c80625d 100644 (file)
@@ -52,8 +52,7 @@ main()
         deallog << r1[i][j][0] << std::endl;
         AssertThrow(std::abs(r1[i][j][0] - factor_float * s1[i][j][0]) < 1.e-10,
                     ExcInternalError());
-        for (unsigned int k = 1; k < VectorizedArray<float>::n_array_elements;
-             ++k)
+        for (unsigned int k = 1; k < VectorizedArray<float>::size(); ++k)
           {
             AssertThrow(std::abs(r1[i][j][k] - r1[i][j][0]) < 1.e-10,
                         ExcInternalError());
@@ -61,8 +60,7 @@ main()
         deallog << r2[i][j][0] << std::endl;
         Assert(std::abs(r2[i][j][0] - factor_double * s2[i][j][0]) < 1.e-10,
                ExcInternalError());
-        for (unsigned int k = 1; k < VectorizedArray<double>::n_array_elements;
-             ++k)
+        for (unsigned int k = 1; k < VectorizedArray<double>::size(); ++k)
           {
             AssertThrow(std::abs(r2[i][j][k] - r2[i][j][0]) < 1.e-10,
                         ExcInternalError());
index 1fef6758bf848ede082f91616fe747fad81c0dda..1e3e7c9e26c1f9d2cfe6b38a38171f44eddc160b 100644 (file)
@@ -32,9 +32,7 @@ void fill_tensor(
   Number counter = 0.0;
   for (unsigned int i = 0; i < dim; ++i)
     for (unsigned int j = 0; j < dim; ++j)
-      for (unsigned int v = 0;
-           v < dealii::VectorizedArray<Number>::n_array_elements;
-           v++)
+      for (unsigned int v = 0; v < dealii::VectorizedArray<Number>::size(); v++)
         {
           A[i][j][v] = counter;
           counter += 1.0;
@@ -72,8 +70,7 @@ main()
   // like VectorizedArray<double> frob_norm = B.norm() -> Maybe a TODO?
   for (unsigned int i = 0; i < dim; ++i)
     for (unsigned int j = 0; j < dim; ++j)
-      for (unsigned int v = 0; v < VectorizedArray<double>::n_array_elements;
-           ++v)
+      for (unsigned int v = 0; v < VectorizedArray<double>::size(); ++v)
         if (B[i][j][v] != 0.0)
           deallog << "Not OK" << std::endl;
 

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.