Handle a test which fails under GCC 5.4

diff --git a/tests/physics/notation-kelvin_01.cc b/tests/physics/notation-kelvin_01.cc
index a6b59949f555d3289baf31fe8aa38324db5129fb..98adfd9627ec77d50b1d66d75e81dc36e00a917c 100644 (file)
--- a/tests/physics/notation-kelvin_01.cc
+++ b/tests/physics/notation-kelvin_01.cc
@@ -147,9 +147,12 @@ test_rank_0_tensors()
   const Vector<double>     vA = Notation::Kelvin::to_vector(A);
   const FullMatrix<double> mA = Notation::Kelvin::to_matrix(A);
 
-  using InpType      = typename std::decay<decltype(A)>::type;
-  const auto vA_conv = Notation::Kelvin::to_tensor<InpType>(vA);
-  const auto mA_conv = Notation::Kelvin::to_tensor<InpType>(mA);
+  using InpType = typename std::decay<decltype(A)>::type;
+  // Here and below we need both types to work around a problem present in GCC
+  // 5.4.0 in which the compiler does not correctly handle SFINAE with
+  // static_assert(). This was fixed by GCC 9.
+  const auto vA_conv = Notation::Kelvin::to_tensor<InpType, double>(vA);
+  const auto mA_conv = Notation::Kelvin::to_tensor<InpType, double>(mA);
 
   Assert(std::abs(vA_conv - A) < 1e-12,
          ExcMessage("Different result for vector conversion"));
@@ -167,7 +170,7 @@ test_rank_1_tensors()
   const Vector<double> vA = Notation::Kelvin::to_vector(A);
 
   using InpType      = typename std::decay<decltype(A)>::type;
-  const auto vA_conv = Notation::Kelvin::to_tensor<InpType>(vA);
+  const auto vA_conv = Notation::Kelvin::to_tensor<InpType, double>(vA);
 
   Assert((vA_conv - A).norm() < 1e-12,
          ExcMessage("Different result for vector conversion"));
@@ -186,8 +189,8 @@ test_rank_2_tensors()
     const FullMatrix<double> mA = Notation::Kelvin::to_matrix(A);
 
     using InpType      = typename std::decay<decltype(A)>::type;
-    const auto vA_conv = Notation::Kelvin::to_tensor<InpType>(vA);
-    const auto mA_conv = Notation::Kelvin::to_tensor<InpType>(mA);
+    const auto vA_conv = Notation::Kelvin::to_tensor<InpType, double>(vA);
+    const auto mA_conv = Notation::Kelvin::to_tensor<InpType, double>(mA);
 
     Assert((vA_conv - A).norm() < 1e-12,
            ExcMessage("Different result for vector conversion"));
@@ -204,8 +207,8 @@ test_rank_2_tensors()
     const FullMatrix<double> mA = Notation::Kelvin::to_matrix(A);
 
     using InpType      = typename std::decay<decltype(A)>::type;
-    const auto vA_conv = Notation::Kelvin::to_tensor<InpType>(vA);
-    const auto mA_conv = Notation::Kelvin::to_tensor<InpType>(mA);
+    const auto vA_conv = Notation::Kelvin::to_tensor<InpType, double>(vA);
+    const auto mA_conv = Notation::Kelvin::to_tensor<InpType, double>(mA);
 
     Assert((vA_conv - A).norm() < 1e-12,
            ExcMessage("Different result for vector conversion"));
@@ -227,7 +230,7 @@ test_rank_3_tensors()
       Notation::Kelvin::to_matrix<dim, Tensor<1, dim>, Tensor<2, dim>>(A);
 
     using InpType      = typename std::decay<decltype(A)>::type;
-    const auto mA_conv = Notation::Kelvin::to_tensor<InpType>(mA);
+    const auto mA_conv = Notation::Kelvin::to_tensor<InpType, double>(mA);
 
     Assert((mA_conv - A).norm() < 1e-12,
            ExcMessage("Different result for matrix conversion"));
@@ -242,7 +245,7 @@ test_rank_3_tensors()
       Notation::Kelvin::to_matrix<dim, Tensor<2, dim>, Tensor<1, dim>>(A);
 
     using InpType      = typename std::decay<decltype(A)>::type;
-    const auto mA_conv = Notation::Kelvin::to_tensor<InpType>(mA);
+    const auto mA_conv = Notation::Kelvin::to_tensor<InpType, double>(mA);
 
     Assert((mA_conv - A).norm() < 1e-12,
            ExcMessage("Different result for matrix conversion"));
@@ -258,7 +261,7 @@ test_rank_3_tensors()
         A);
 
     using InpType      = typename std::decay<decltype(A)>::type;
-    const auto mA_conv = Notation::Kelvin::to_tensor<InpType>(mA);
+    const auto mA_conv = Notation::Kelvin::to_tensor<InpType, double>(mA);
 
     Assert((mA_conv - A).norm() < 1e-12,
            ExcMessage("Different result for matrix conversion"));
@@ -274,7 +277,7 @@ test_rank_3_tensors()
         A);
 
     using InpType      = typename std::decay<decltype(A)>::type;
-    const auto mA_conv = Notation::Kelvin::to_tensor<InpType>(mA);
+    const auto mA_conv = Notation::Kelvin::to_tensor<InpType, double>(mA);
 
     Assert((mA_conv - A).norm() < 1e-12,
            ExcMessage("Different result for matrix conversion"));
@@ -293,7 +296,7 @@ test_rank_4_tensors()
     const FullMatrix<double> mA = Notation::Kelvin::to_matrix(A);
 
     using InpType      = typename std::decay<decltype(A)>::type;
-    const auto mA_conv = Notation::Kelvin::to_tensor<InpType>(mA);
+    const auto mA_conv = Notation::Kelvin::to_tensor<InpType, double>(mA);
 
     Assert((mA_conv - A).norm() < 1e-12,
            ExcMessage("Different result for matrix conversion"));
@@ -307,7 +310,7 @@ test_rank_4_tensors()
     const FullMatrix<double> mA = Notation::Kelvin::to_matrix(A);
 
     using InpType      = typename std::decay<decltype(A)>::type;
-    const auto mA_conv = Notation::Kelvin::to_tensor<InpType>(mA);
+    const auto mA_conv = Notation::Kelvin::to_tensor<InpType, double>(mA);
 
     Assert((mA_conv - A).norm() < 1e-12,
            ExcMessage("Different result for matrix conversion"));

diff --git a/tests/physics/notation-kelvin_02.cc b/tests/physics/notation-kelvin_02.cc
index 84756e39c3d4bcde34d25a353bb3fbefb2ae7e52..1d0b4cc99b9f93a956637bdbacfc018ddc46bad6 100644 (file)
--- a/tests/physics/notation-kelvin_02.cc
+++ b/tests/physics/notation-kelvin_02.cc
@@ -135,12 +135,15 @@ test_scalars()
   Vector<double>           vB(mC.m());
   mC.vmult(vB, vA);
 
-  using InpVecType  = typename std::decay<decltype(A)>::type;
-  using ResVecType  = typename std::decay<decltype(B)>::type;
-  using InpMatType  = typename std::decay<decltype(C)>::type;
-  const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
-  const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
-  const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
+  using InpVecType = typename std::decay<decltype(A)>::type;
+  using ResVecType = typename std::decay<decltype(B)>::type;
+  using InpMatType = typename std::decay<decltype(C)>::type;
+  // Here and below we need both types to work around a problem present in GCC
+  // 5.4.0 in which the compiler does not correctly handle SFINAE with
+  // static_assert(). This was fixed by GCC 9.
+  const auto A_conv = Notation::Kelvin::to_tensor<InpVecType, double>(vA);
+  const auto B_conv = Notation::Kelvin::to_tensor<ResVecType, double>(vB);
+  const auto C_conv = Notation::Kelvin::to_tensor<InpMatType, double>(mC);
 
   std::cout << "Scalar" << std::endl;
   std::cout << "A: " << A << "  A_conv: " << A_conv << std::endl;
@@ -178,9 +181,9 @@ test_rank_0_tensors()
   using InpVecType  = typename std::decay<decltype(A)>::type;
   using ResVecType  = typename std::decay<decltype(B)>::type;
   using InpMatType  = typename std::decay<decltype(C)>::type;
-  const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
-  const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
-  const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
+  const auto A_conv = Notation::Kelvin::to_tensor<InpVecType, double>(vA);
+  const auto B_conv = Notation::Kelvin::to_tensor<ResVecType, double>(vB);
+  const auto C_conv = Notation::Kelvin::to_tensor<InpMatType, double>(mC);
 
   std::cout << "Rank 0" << std::endl;
   std::cout << "A: " << A << "  A_conv: " << A_conv << std::endl;
@@ -222,9 +225,9 @@ test_rank_1_2_tensors()
     using InpVecType  = typename std::decay<decltype(A)>::type;
     using ResVecType  = typename std::decay<decltype(B)>::type;
     using InpMatType  = typename std::decay<decltype(C)>::type;
-    const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
-    const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
-    const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
+    const auto A_conv = Notation::Kelvin::to_tensor<InpVecType, double>(vA);
+    const auto B_conv = Notation::Kelvin::to_tensor<ResVecType, double>(vB);
+    const auto C_conv = Notation::Kelvin::to_tensor<InpMatType, double>(mC);
 
     std::cout << "Rank 1 (non-symm)" << std::endl;
     std::cout << "A: " << A << "  A_conv: " << A_conv << std::endl;
@@ -262,9 +265,9 @@ test_rank_1_2_tensors()
     using InpVecType  = typename std::decay<decltype(A)>::type;
     using ResVecType  = typename std::decay<decltype(B)>::type;
     using InpMatType  = typename std::decay<decltype(C)>::type;
-    const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
-    const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
-    const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
+    const auto A_conv = Notation::Kelvin::to_tensor<InpVecType, double>(vA);
+    const auto B_conv = Notation::Kelvin::to_tensor<ResVecType, double>(vB);
+    const auto C_conv = Notation::Kelvin::to_tensor<InpMatType, double>(mC);
 
     std::cout << "Rank 1 (symm)" << std::endl;
     std::cout << "A: " << A << "  A_conv: " << A_conv << std::endl;
@@ -307,9 +310,9 @@ test_rank_2_4_tensors()
     using InpVecType  = typename std::decay<decltype(A)>::type;
     using ResVecType  = typename std::decay<decltype(B)>::type;
     using InpMatType  = typename std::decay<decltype(C)>::type;
-    const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
-    const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
-    const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
+    const auto A_conv = Notation::Kelvin::to_tensor<InpVecType, double>(vA);
+    const auto B_conv = Notation::Kelvin::to_tensor<ResVecType, double>(vB);
+    const auto C_conv = Notation::Kelvin::to_tensor<InpMatType, double>(mC);
 
     std::cout << "Rank 2 (non-symm)" << std::endl;
     std::cout << "A: " << A << "  A_conv: " << A_conv << std::endl;
@@ -347,9 +350,9 @@ test_rank_2_4_tensors()
     using InpVecType  = typename std::decay<decltype(A)>::type;
     using ResVecType  = typename std::decay<decltype(B)>::type;
     using InpMatType  = typename std::decay<decltype(C)>::type;
-    const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
-    const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
-    const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
+    const auto A_conv = Notation::Kelvin::to_tensor<InpVecType, double>(vA);
+    const auto B_conv = Notation::Kelvin::to_tensor<ResVecType, double>(vB);
+    const auto C_conv = Notation::Kelvin::to_tensor<InpMatType, double>(mC);
 
     std::cout << "Rank 2 (symm)" << std::endl;
     std::cout << "A: " << A << "  A_conv: " << A_conv << std::endl;
@@ -390,9 +393,9 @@ test_rank_2_4_tensors()
     using InpVecType  = typename std::decay<decltype(A)>::type;
     using ResVecType  = typename std::decay<decltype(B)>::type;
     using InpMatType  = typename std::decay<decltype(C)>::type;
-    const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
-    const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
-    const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
+    const auto A_conv = Notation::Kelvin::to_tensor<InpVecType, double>(vA);
+    const auto B_conv = Notation::Kelvin::to_tensor<ResVecType, double>(vB);
+    const auto C_conv = Notation::Kelvin::to_tensor<InpMatType, double>(mC);
 
     std::cout << "Rank 2 (non-symm from symm)" << std::endl;
     std::cout << "A: " << A << "  A_conv: " << A_conv << std::endl;
@@ -437,9 +440,9 @@ test_rank_3_tensors()
     using InpVecType  = typename std::decay<decltype(A)>::type;
     using ResVecType  = typename std::decay<decltype(B)>::type;
     using InpMatType  = typename std::decay<decltype(C)>::type;
-    const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
-    const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
-    const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
+    const auto A_conv = Notation::Kelvin::to_tensor<InpVecType, double>(vA);
+    const auto B_conv = Notation::Kelvin::to_tensor<ResVecType, double>(vB);
+    const auto C_conv = Notation::Kelvin::to_tensor<InpMatType, double>(mC);
 
     std::cout << "Rank 3 (non-symm 1)" << std::endl;
     std::cout << "A: " << A << "  A_conv: " << A_conv << std::endl;
@@ -481,9 +484,9 @@ test_rank_3_tensors()
     using InpVecType  = typename std::decay<decltype(A)>::type;
     using ResVecType  = typename std::decay<decltype(B)>::type;
     using InpMatType  = typename std::decay<decltype(C)>::type;
-    const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
-    const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
-    const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
+    const auto A_conv = Notation::Kelvin::to_tensor<InpVecType, double>(vA);
+    const auto B_conv = Notation::Kelvin::to_tensor<ResVecType, double>(vB);
+    const auto C_conv = Notation::Kelvin::to_tensor<InpMatType, double>(mC);
 
     std::cout << "Rank 3 (non-symm 2)" << std::endl;
     std::cout << "A: " << A << "  A_conv: " << A_conv << std::endl;
@@ -526,9 +529,9 @@ test_rank_3_tensors()
     using InpVecType  = typename std::decay<decltype(A)>::type;
     using ResVecType  = typename std::decay<decltype(B)>::type;
     using InpMatType  = typename std::decay<decltype(C)>::type;
-    const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
-    const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
-    const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
+    const auto A_conv = Notation::Kelvin::to_tensor<InpVecType, double>(vA);
+    const auto B_conv = Notation::Kelvin::to_tensor<ResVecType, double>(vB);
+    const auto C_conv = Notation::Kelvin::to_tensor<InpMatType, double>(mC);
 
     std::cout << "Rank 3 (symm 1)" << std::endl;
     std::cout << "A: " << A << "  A_conv: " << A_conv << std::endl;
@@ -571,9 +574,9 @@ test_rank_3_tensors()
     using InpVecType  = typename std::decay<decltype(A)>::type;
     using ResVecType  = typename std::decay<decltype(B)>::type;
     using InpMatType  = typename std::decay<decltype(C)>::type;
-    const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
-    const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
-    const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
+    const auto A_conv = Notation::Kelvin::to_tensor<InpVecType, double>(vA);
+    const auto B_conv = Notation::Kelvin::to_tensor<ResVecType, double>(vB);
+    const auto C_conv = Notation::Kelvin::to_tensor<InpMatType, double>(mC);
 
     std::cout << "Rank 3 (symm 2)" << std::endl;
     std::cout << "A: " << A << "  A_conv: " << A_conv << std::endl;