From af6aeca5f0d9807d4f6a6cb397e00e0e196b932c Mon Sep 17 00:00:00 2001
From: Ernesto Prudencio <eeprude@sandia.gov>
Date: Sun, 19 Nov 2023 20:35:39 -0700
Subject: [PATCH 01/14] Backup

---
 blas/unit_test/Test_Blas2_syr2.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/blas/unit_test/Test_Blas2_syr2.hpp b/blas/unit_test/Test_Blas2_syr2.hpp
index 76b2cf43c1..11029b8778 100644
--- a/blas/unit_test/Test_Blas2_syr2.hpp
+++ b/blas/unit_test/Test_Blas2_syr2.hpp
@@ -207,8 +207,8 @@ Syr2Tester<ScalarX, tLayoutX, ScalarY, tLayoutY, ScalarA, tLayoutA,
       // large enough to require 'relTol' to value 5.0e-3. The same
       // calculations show no discrepancies for calculations with double.
       // ****************************************************************
-      _absTol(std::is_same<_AuxType, float>::value ? 1.0e-6 : 1.0e-9),
-      _relTol(std::is_same<_AuxType, float>::value ? 5.0e-3 : 1.0e-6),
+      _absTol(std::is_same<_AuxType, float>::value ? 1.0e-6 : (std::is_same<_AuxType, double>::value ? 1.0e-9 : 0)),
+      _relTol(std::is_same<_AuxType, float>::value ? 5.0e-3 : (std::is_same<_AuxType, double>::value ? 1.0e-6 : 0)),
       _M(-1),
       _N(-1),
       _useAnalyticalResults(false),
@@ -610,7 +610,7 @@ Syr2Tester<ScalarX, tLayoutX, ScalarY, tLayoutY, ScalarA, tLayoutA,
                                              _HostViewTypeY& h_y,
                                              _HostViewTypeA& h_A,
                                              _ViewTypeExpected& h_expected) {
-  alpha = 1.1;
+  alpha = std::is_same<_AuxType, int>::value ? 1 : 1.1;
 
   for (int i = 0; i < _M; ++i) {
     _AuxType auxI = this->shrinkAngleToZeroTwoPiRange(static_cast<_AuxType>(i));

From 5188b71db807f303f9aeed9952e1e4d07c426799 Mon Sep 17 00:00:00 2001
From: Ernesto Prudencio <eeprude@sandia.gov>
Date: Mon, 20 Nov 2023 00:45:41 -0700
Subject: [PATCH 02/14] Backup

---
 .../Test_Blas1_axpby_unification.hpp          | 631 ++++++++++++++----
 1 file changed, 502 insertions(+), 129 deletions(-)

diff --git a/blas/unit_test/Test_Blas1_axpby_unification.hpp b/blas/unit_test/Test_Blas1_axpby_unification.hpp
index 6b2e5a3f5c..447924a5a7 100644
--- a/blas/unit_test/Test_Blas1_axpby_unification.hpp
+++ b/blas/unit_test/Test_Blas1_axpby_unification.hpp
@@ -80,9 +80,10 @@ template <class tScalarA, class tA, class tX, class tScalarB, class tB,
           class tY, class Device>
 void impl_test_axpby_unification_compare(
     tA const& a, tX const& x, tB const& b, tY const& y, int N,
+    bool testWithNanY,
     typename Kokkos::ArithTraits<tScalarB>::mag_type const max_val,
     typename Kokkos::ArithTraits<tScalarB>::mag_type const max_error,
-    tScalarA const inputValueA = 0, tScalarB const inputValueB = 0) {
+    tScalarA const inputValueA = Kokkos::ArithTraits<tScalarA>::zero(), tScalarB const inputValueB = Kokkos::ArithTraits<tScalarB>::zero()) {
   using ScalarTypeX =
       typename std::remove_const<typename tX::DView::value_type>::type;
   using ScalarTypeY =
@@ -101,13 +102,18 @@ void impl_test_axpby_unification_compare(
   {
     ScalarTypeY randStart, randEnd;
     Test::getRandomBounds(max_val, randStart, randEnd);
-    Kokkos::fill_random(y.d_view, rand_pool, randStart, randEnd);
+    if (testWithNanY) {
+      Kokkos::deep_copy(y.d_view, Kokkos::ArithTraits<ScalarTypeY>::nan());
+    }
+    else {
+      Kokkos::fill_random(y.d_view, rand_pool, randStart, randEnd);
+    }
   }
   tY org_y("Org_Y", N);
   Kokkos::deep_copy(org_y.h_view, y.d_view);
 
-  tScalarA valueA(0);
-  tScalarB valueB(0);
+  tScalarA valueA(Kokkos::ArithTraits<tScalarA>::zero());
+  tScalarB valueB(Kokkos::ArithTraits<tScalarB>::zero());
 
   if constexpr (std::is_same_v<tA, tScalarA>) {
     valueA = a;
@@ -181,10 +187,44 @@ void impl_test_axpby_unification_compare(
 
   Kokkos::deep_copy(y.h_view, y.d_view);
 
-  for (int i(0); i < N; ++i) {
-    EXPECT_NEAR_KK(static_cast<ScalarTypeY>(valueA * x.h_view(i) +
-                                            valueB * org_y.h_view(i)),
-                   y.h_view(i), 2. * max_error);
+  if (testWithNanY == false) {
+    for (int i(0); i < N; ++i) {
+      EXPECT_NEAR_KK(static_cast<ScalarTypeY>(valueA * x.h_view(i) +
+                                              valueB * org_y.h_view(i)),
+                     y.h_view(i), 2. * max_error);
+    }
+  }
+  else {
+    // ********************************************************
+    // Tests with 'Y == nan()' are called only for cases where
+    // b == Kokkos::ArithTraits<tScalarB>::zero()
+    // ********************************************************
+    for (int i(0); i < N; ++i) {
+#if 0
+      ScalarTypeY tmp = static_cast<ScalarTypeY>(valueA * x.h_view(i) + valueB * org_y.h_view(i));
+      std::cout << "i = "                 << i
+                << ", valueA = "          << valueA
+                << ", x.h_view(i) = "     << x.h_view(i)
+                << ", valueB = "          << valueB
+                << ", org_y.h_view(i) = " << org_y.h_view(i)
+                << ", tmp = "             << tmp
+                << ", y.h_view(i) = "     << y.h_view(i)
+                << std::endl;
+#endif
+      if constexpr (std::is_same_v<ScalarTypeY, int>) {
+        // ****************************************************************
+        // 'nan()' converts to '-1' in case of 'int' => no need to compare
+        // ****************************************************************
+        if (y.h_view(i) != -1) {
+          EXPECT_NE(y.h_view(i), Kokkos::ArithTraits<ScalarTypeY>::nan());
+        }
+      }
+      else {
+        EXPECT_NE(y.h_view(i), Kokkos::ArithTraits<ScalarTypeY>::nan());
+      }
+      EXPECT_NEAR_KK(static_cast<ScalarTypeY>(valueA * x.h_view(i)),
+                     y.h_view(i), 2. * max_error);
+    }
   }
 }
 
@@ -192,9 +232,10 @@ template <class tScalarA, class tA, class tX, class tScalarB, class tB,
           class tY, class Device>
 void impl_test_axpby_mv_unification_compare(
     tA const& a, tX const& x, tB const& b, tY const& y, int N, int K,
+    bool testWithNanY,
     typename Kokkos::ArithTraits<tScalarB>::mag_type const max_val,
     typename Kokkos::ArithTraits<tScalarB>::mag_type const max_error,
-    tScalarA const inputValueA = 0, tScalarB const inputValueB = 0) {
+    tScalarA const inputValueA = Kokkos::ArithTraits<tScalarA>::zero(), tScalarB const inputValueB = Kokkos::ArithTraits<tScalarB>::zero()) {
   using ScalarTypeX =
       typename std::remove_const<typename tY::DView::value_type>::type;
   using ScalarTypeY =
@@ -213,7 +254,12 @@ void impl_test_axpby_mv_unification_compare(
   {
     ScalarTypeY randStart, randEnd;
     Test::getRandomBounds(max_val, randStart, randEnd);
-    Kokkos::fill_random(y.d_view, rand_pool, randStart, randEnd);
+    if (testWithNanY) {
+      Kokkos::deep_copy(y.d_view, Kokkos::ArithTraits<ScalarTypeY>::nan());
+    }
+    else {
+      Kokkos::fill_random(y.d_view, rand_pool, randStart, randEnd);
+    }
   }
   tY org_y("Org_Y", N, K);
   Kokkos::deep_copy(org_y.h_view, y.d_view);
@@ -232,8 +278,8 @@ void impl_test_axpby_mv_unification_compare(
     Kokkos::deep_copy(b.h_view, b.d_view);
   }
 
-  tScalarA valueA(0);
-  tScalarB valueB(0);
+  tScalarA valueA(Kokkos::ArithTraits<tScalarA>::zero());
+  tScalarB valueB(Kokkos::ArithTraits<tScalarB>::zero());
   if constexpr (std::is_same_v<tA, tScalarA>) {
     valueA = a;
     if constexpr (std::is_same_v<tB, tScalarB>) {
@@ -302,36 +348,97 @@ void impl_test_axpby_mv_unification_compare(
 
   Kokkos::deep_copy(y.h_view, y.d_view);
 
-  for (int i(0); i < N; ++i) {
-    for (int k(0); k < K; ++k) {
-      ScalarTypeY vanillaValue(0.);
-      if constexpr (aIsRank1) {
-        (void)valueA;  // Avoid "set but not used" error
-        if constexpr (bIsRank1) {
-          (void)valueB;  // Avoid "set but not used" error
-          int a_k(a.h_view.extent(0) == 1 ? 0 : k);
-          int b_k(b.h_view.extent(0) == 1 ? 0 : k);
-          vanillaValue =
-              static_cast<ScalarTypeY>(a.h_view(a_k) * x.h_view(i, k) +
-                                       b.h_view(b_k) * org_y.h_view(i, k));
+  if (testWithNanY == false) {
+    for (int i(0); i < N; ++i) {
+      for (int k(0); k < K; ++k) {
+        ScalarTypeY vanillaValue(Kokkos::ArithTraits<ScalarTypeY>::zero());
+        if constexpr (aIsRank1) {
+          (void)valueA;  // Avoid "set but not used" error
+          if constexpr (bIsRank1) {
+            (void)valueB;  // Avoid "set but not used" error
+            int a_k(a.h_view.extent(0) == 1 ? 0 : k);
+            int b_k(b.h_view.extent(0) == 1 ? 0 : k);
+            vanillaValue =
+                static_cast<ScalarTypeY>(a.h_view(a_k) * x.h_view(i, k) +
+                                         b.h_view(b_k) * org_y.h_view(i, k));
+          } else {
+            int a_k(a.h_view.extent(0) == 1 ? 0 : k);
+            vanillaValue = static_cast<ScalarTypeY>(
+                a.h_view(a_k) * x.h_view(i, k) + valueB * org_y.h_view(i, k));
+          }
         } else {
-          int a_k(a.h_view.extent(0) == 1 ? 0 : k);
-          vanillaValue = static_cast<ScalarTypeY>(
-              a.h_view(a_k) * x.h_view(i, k) + valueB * org_y.h_view(i, k));
+          if constexpr (bIsRank1) {
+            (void)valueB;  // Avoid "set but not used" error
+            int b_k(b.h_view.extent(0) == 1 ? 0 : k);
+            vanillaValue = static_cast<ScalarTypeY>(
+                valueA * x.h_view(i, k) + b.h_view(b_k) * org_y.h_view(i, k));
+          } else {
+            vanillaValue = static_cast<ScalarTypeY>(valueA * x.h_view(i, k) +
+                                                    valueB * org_y.h_view(i, k));
+          }
         }
-      } else {
-        if constexpr (bIsRank1) {
-          (void)valueB;  // Avoid "set but not used" error
-          int b_k(b.h_view.extent(0) == 1 ? 0 : k);
-          vanillaValue = static_cast<ScalarTypeY>(
-              valueA * x.h_view(i, k) + b.h_view(b_k) * org_y.h_view(i, k));
+
+        EXPECT_NEAR_KK(vanillaValue, y.h_view(i, k), 2. * max_error);
+      }
+    }
+  }
+  else {
+    // ********************************************************
+    // Tests with 'Y == nan()' are called only for cases where
+    // b == Kokkos::ArithTraits<tScalarB>::zero()
+    // ********************************************************
+    for (int i(0); i < N; ++i) {
+      for (int k(0); k < K; ++k) {
+        ScalarTypeY vanillaValue(Kokkos::ArithTraits<ScalarTypeY>::zero());
+        if constexpr (aIsRank1) {
+          (void)valueA;  // Avoid "set but not used" error
+          int a_k(a.h_view.extent(0) == 1 ? 0 : k);
+          vanillaValue = static_cast<ScalarTypeY>(a.h_view(a_k) * x.h_view(i, k));
+#if 1
+          ScalarTypeY tmp = static_cast<ScalarTypeY>(a.h_view(a_k) * x.h_view(i, k) + valueB * org_y.h_view(i, k));
+          std::cout << "i = "                    << i
+                    << ", k = "                  << k
+                    << ", a_k = "                << a_k
+                    << ", a.h_view(a_k) = "      << a.h_view(a_k)
+                    << ", x.h_view(i, k) = "     << x.h_view(i, k)
+                    << ", valueB = "             << valueB
+                    << ", org_y.h_view(i, k) = " << org_y.h_view(i, k)
+                    << ", tmp = "                << tmp
+                    << ", vanillaValue = "       << vanillaValue
+                    << ", y.h_view(i, k) = "     << y.h_view(i, k)
+                    << std::endl;
+#endif
         } else {
-          vanillaValue = static_cast<ScalarTypeY>(valueA * x.h_view(i, k) +
-                                                  valueB * org_y.h_view(i, k));
+          vanillaValue = static_cast<ScalarTypeY>(valueA * x.h_view(i, k));
+#if 1
+          ScalarTypeY tmp = static_cast<ScalarTypeY>(valueA * x.h_view(i, k) + valueB * org_y.h_view(i, k));
+          std::cout << "i = "                    << i
+                    << ", k = "                  << k
+                    << ", valueA = "             << valueA
+                    << ", x.h_view(i, k) = "     << x.h_view(i, k)
+                    << ", valueB = "             << valueB
+                    << ", org_y.h_view(i, k) = " << org_y.h_view(i, k)
+                    << ", tmp = "                << tmp
+                    << ", vanillaValue = "       << vanillaValue
+                    << ", y.h_view(i, k) = "     << y.h_view(i, k)
+                    << std::endl;
+#endif
         }
-      }
 
-      EXPECT_NEAR_KK(vanillaValue, y.h_view(i, k), 2. * max_error);
+        if constexpr (std::is_same_v<ScalarTypeY, int>) {
+          // ****************************************************************
+          // 'nan()' converts to '-1' in case of 'int' => no need to compare
+          // ****************************************************************
+          if (y.h_view(i, k) != -1) {
+            EXPECT_NE(y.h_view(i, k), Kokkos::ArithTraits<ScalarTypeY>::nan());
+          }
+        }
+        else {
+          EXPECT_NE(y.h_view(i, k), Kokkos::ArithTraits<ScalarTypeY>::nan());
+        }
+	
+        EXPECT_NEAR_KK(vanillaValue, y.h_view(i, k), 2. * max_error);
+      }
     }
   }
 }
@@ -352,8 +459,8 @@ void impl_test_axpby_unification(int const N) {
 
   using ViewTypeY = Kokkos::View<tScalarY*, tLayoutY, Device>;
 
-  std::array<tScalarA, 4> const valuesA{-1, 0, 1, 3};
-  std::array<tScalarB, 4> const valuesB{-1, 0, 1, 5};
+  std::array<tScalarA, 4> const valuesA{-1, Kokkos::ArithTraits<tScalarA>::zero(), 1, 3};
+  std::array<tScalarB, 4> const valuesB{-1, Kokkos::ArithTraits<tScalarB>::zero(), 1, 5};
 
   // eps should probably be based on tScalarB since that is the type
   // in which the result is computed.
@@ -385,7 +492,13 @@ void impl_test_axpby_unification(int const N) {
         impl_test_axpby_unification_compare<
             tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
             tScalarB, view_stride_adapter<ViewTypeY>, Device>(
-            a, x, b, y, N, max_val, max_error);
+            a, x, b, y, N, false, max_val, max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_unification_compare<
+              tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
+              tScalarB, view_stride_adapter<ViewTypeY>, Device>(
+              a, x, b, y, N, true, max_val, max_error);
+        }
       }
     }
   }
@@ -415,7 +528,13 @@ void impl_test_axpby_unification(int const N) {
           impl_test_axpby_unification_compare<
               tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
               ViewTypeBr0, view_stride_adapter<ViewTypeY>, Device>(
-              a, x, b, y, N, max_val, max_error);
+              a, x, b, y, N, false, max_val, max_error);
+          if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+            impl_test_axpby_unification_compare<
+                tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
+                ViewTypeBr0, view_stride_adapter<ViewTypeY>, Device>(
+                a, x, b, y, N, true, max_val, max_error);
+          }
         }
       }
     }
@@ -440,7 +559,13 @@ void impl_test_axpby_unification(int const N) {
         impl_test_axpby_unification_compare<
             tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, max_val, max_error);
+            Device>(a, x, b, y, N, false, max_val, max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_unification_compare<
+              tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
+              view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
+              Device>(a, x, b, y, N, true, max_val, max_error);
+        }
       }
     }
   }
@@ -464,7 +589,13 @@ void impl_test_axpby_unification(int const N) {
         impl_test_axpby_unification_compare<
             tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, max_val, max_error);
+            Device>(a, x, b, y, N, false, max_val, max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_unification_compare<
+              tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
+              view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
+              Device>(a, x, b, y, N, true, max_val, max_error);
+        }
       }
     }
   }
@@ -491,7 +622,13 @@ void impl_test_axpby_unification(int const N) {
           impl_test_axpby_unification_compare<
               tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
               tScalarB, view_stride_adapter<ViewTypeY>, Device>(
-              a, x, b, y, N, max_val, max_error);
+              a, x, b, y, N, false, max_val, max_error);
+          if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+            impl_test_axpby_unification_compare<
+                tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
+                tScalarB, view_stride_adapter<ViewTypeY>, Device>(
+                a, x, b, y, N, true, max_val, max_error);
+          }
         }
       }
     }
@@ -520,7 +657,13 @@ void impl_test_axpby_unification(int const N) {
           impl_test_axpby_unification_compare<
               tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
               ViewTypeBr0, view_stride_adapter<ViewTypeY>, Device>(
-              a, x, b, y, N, max_val, max_error);
+              a, x, b, y, N, false, max_val, max_error);
+          if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+            impl_test_axpby_unification_compare<
+                tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
+                ViewTypeBr0, view_stride_adapter<ViewTypeY>, Device>(
+                a, x, b, y, N, true, max_val, max_error);
+          }
         }
       }
     }
@@ -548,8 +691,15 @@ void impl_test_axpby_unification(int const N) {
           impl_test_axpby_unification_compare<
               tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
               view_stride_adapter<ViewTypeBr1s_1>,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, max_val,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, false, max_val,
                                                       max_error);
+          if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+            impl_test_axpby_unification_compare<
+                tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
+                view_stride_adapter<ViewTypeBr1s_1>,
+                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, true, max_val,
+                                                        max_error);
+          }
         }
       }
     }
@@ -577,7 +727,13 @@ void impl_test_axpby_unification(int const N) {
           impl_test_axpby_unification_compare<
               tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
               view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
-              Device>(a, x, b, y, N, max_val, max_error);
+              Device>(a, x, b, y, N, false, max_val, max_error);
+          if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+            impl_test_axpby_unification_compare<
+                tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
+                view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
+                Device>(a, x, b, y, N, true, max_val, max_error);
+          }
         }
       }
     }
@@ -602,8 +758,15 @@ void impl_test_axpby_unification(int const N) {
         impl_test_axpby_unification_compare<
             tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
             view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
-            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, max_val,
+            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, false, max_val,
                                                     max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_unification_compare<
+              tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
+              view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, true, max_val,
+                                                      max_error);
+        }
       }
     }
   }
@@ -630,8 +793,15 @@ void impl_test_axpby_unification(int const N) {
           impl_test_axpby_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
               view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, max_val,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, false, max_val,
                                                       max_error);
+          if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+            impl_test_axpby_unification_compare<
+                tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
+                view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
+                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, true, max_val,
+                                                        max_error);
+          }
         }
       }
     }
@@ -657,7 +827,14 @@ void impl_test_axpby_unification(int const N) {
             tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, max_val, max_error);
+            Device>(a, x, b, y, N, false, max_val, max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_unification_compare<
+              tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
+              view_stride_adapter<ViewTypeX>, tScalarB,
+              view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
+              Device>(a, x, b, y, N, true, max_val, max_error);
+        }
       }
     }
   }
@@ -682,7 +859,14 @@ void impl_test_axpby_unification(int const N) {
             tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, max_val, max_error);
+            Device>(a, x, b, y, N, false, max_val, max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_unification_compare<
+              tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
+              view_stride_adapter<ViewTypeX>, tScalarB,
+              view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
+              Device>(a, x, b, y, N, true, max_val, max_error);
+        }
       }
     }
   }
@@ -706,8 +890,15 @@ void impl_test_axpby_unification(int const N) {
         impl_test_axpby_unification_compare<
             tScalarA, view_stride_adapter<ViewTypeAr1d>,
             view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
-            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, max_val,
+            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, false, max_val,
                                                     max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_unification_compare<
+              tScalarA, view_stride_adapter<ViewTypeAr1d>,
+              view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, true, max_val,
+                                                      max_error);
+        }
       }
     }
   }
@@ -734,8 +925,15 @@ void impl_test_axpby_unification(int const N) {
           impl_test_axpby_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1d>,
               view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, max_val,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, false, max_val,
                                                       max_error);
+          if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+            impl_test_axpby_unification_compare<
+                tScalarA, view_stride_adapter<ViewTypeAr1d>,
+                view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
+                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, true, max_val,
+                                                        max_error);
+          }
         }
       }
     }
@@ -761,7 +959,14 @@ void impl_test_axpby_unification(int const N) {
             tScalarA, view_stride_adapter<ViewTypeAr1d>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, max_val, max_error);
+            Device>(a, x, b, y, N, false, max_val, max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_unification_compare<
+              tScalarA, view_stride_adapter<ViewTypeAr1d>,
+              view_stride_adapter<ViewTypeX>, tScalarB,
+              view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
+              Device>(a, x, b, y, N, true, max_val, max_error);
+        }
       }
     }
   }
@@ -786,7 +991,14 @@ void impl_test_axpby_unification(int const N) {
             tScalarA, view_stride_adapter<ViewTypeAr1d>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, max_val, max_error);
+            Device>(a, x, b, y, N, false, max_val, max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_unification_compare<
+              tScalarA, view_stride_adapter<ViewTypeAr1d>,
+              view_stride_adapter<ViewTypeX>, tScalarB,
+              view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
+              Device>(a, x, b, y, N, true, max_val, max_error);
+        }
       }
     }
   }
@@ -819,8 +1031,8 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
 
   using ViewTypeY = Kokkos::View<tScalarY**, tLayoutY, Device>;
 
-  std::array<tScalarA, 4> const valuesA{-1, 0, 1, 3};
-  std::array<tScalarB, 4> const valuesB{-1, 0, 1, 5};
+  std::array<tScalarA, 4> const valuesA{-1, Kokkos::ArithTraits<tScalarA>::zero(), 1, 3};
+  std::array<tScalarB, 4> const valuesB{-1, Kokkos::ArithTraits<tScalarB>::zero(), 1, 5};
 
   // eps should probably be based on tScalarB since that is the type
   // in which the result is computed.
@@ -836,7 +1048,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 01/36: Ascalar + Bscalar
   // ************************************************************
-  // std::cout << "Starting case 01/36" << std::endl;
+  std::cout << "Starting case 01/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -852,7 +1064,13 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
         impl_test_axpby_mv_unification_compare<
             tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
             tScalarB, view_stride_adapter<ViewTypeY>, Device>(
-            a, x, b, y, N, K, max_val, max_error);
+            a, x, b, y, N, K, false, max_val, max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_mv_unification_compare<
+              tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
+              tScalarB, view_stride_adapter<ViewTypeY>, Device>(
+              a, x, b, y, N, K, true, max_val, max_error);
+        }
       }
     }
   }
@@ -860,7 +1078,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 02/36: Ascalar + Br0
   // ************************************************************
-  // std::cout << "Starting case 02/36" << std::endl;
+  std::cout << "Starting case 02/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutB, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -879,7 +1097,13 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
               ViewTypeBr0, view_stride_adapter<ViewTypeY>, Device>(
-              a, x, b, y, N, K, max_val, max_error);
+              a, x, b, y, N, K, false, max_val, max_error);
+          if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+            impl_test_axpby_mv_unification_compare<
+                tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
+                ViewTypeBr0, view_stride_adapter<ViewTypeY>, Device>(
+                a, x, b, y, N, K, true, max_val, max_error);
+          }
         }
       }
     }
@@ -888,7 +1112,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 03/36: Ascalar + Br1s_1
   // ************************************************************
-  // std::cout << "Starting case 03/36" << std::endl;
+  std::cout << "Starting case 03/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -904,7 +1128,13 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
         impl_test_axpby_mv_unification_compare<
             tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_mv_unification_compare<
+              tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
+              view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
+              Device>(a, x, b, y, N, K, true, max_val, max_error);
+        }
       }
     }
   }
@@ -912,7 +1142,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 04/36: Ascalar + Br1s_k
   // ************************************************************
-  // std::cout << "Starting case 04/36" << std::endl;
+  std::cout << "Starting case 04/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -938,7 +1168,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
         impl_test_axpby_mv_unification_compare<
             tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1s_k>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
       }
     }
   }
@@ -946,7 +1176,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 05/36: Ascalar + Br1d,1
   // ************************************************************
-  // std::cout << "Starting case 05/36" << std::endl;
+  std::cout << "Starting case 05/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -962,7 +1192,13 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
         impl_test_axpby_mv_unification_compare<
             tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_mv_unification_compare<
+              tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
+              view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
+              Device>(a, x, b, y, N, K, true, max_val, max_error);
+        }
       }
     }
   }
@@ -970,7 +1206,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 06/36: Ascalar + Br1d,k
   // ************************************************************
-  // std::cout << "Starting case 06/36" << std::endl;
+  std::cout << "Starting case 06/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -996,7 +1232,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
         impl_test_axpby_mv_unification_compare<
             tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
       }
     }
   }
@@ -1004,7 +1240,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 07/36: Ar0 + Bscalar
   // ************************************************************w
-  // std::cout << "Starting case 07/36" << std::endl;
+  std::cout << "Starting case 07/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutA, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -1023,7 +1259,13 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
               tScalarB, view_stride_adapter<ViewTypeY>, Device>(
-              a, x, b, y, N, K, max_val, max_error);
+              a, x, b, y, N, K, false, max_val, max_error);
+          if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+            impl_test_axpby_mv_unification_compare<
+                tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
+                tScalarB, view_stride_adapter<ViewTypeY>, Device>(
+                a, x, b, y, N, K, true, max_val, max_error);
+          }
         }
       }
     }
@@ -1032,7 +1274,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 08/36: Ar0 + Br0
   // ************************************************************
-  // std::cout << "Starting case 08/36" << std::endl;
+  std::cout << "Starting case 08/36" << std::endl;
   if constexpr ((std::is_same_v<tLayoutA, Kokkos::LayoutStride>) ||
                 (std::is_same_v<tLayoutB, Kokkos::LayoutStride>)) {
     // Avoid the test, due to compilation errors
@@ -1052,7 +1294,13 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
               ViewTypeBr0, view_stride_adapter<ViewTypeY>, Device>(
-              a, x, b, y, N, K, max_val, max_error);
+              a, x, b, y, N, K, false, max_val, max_error);
+          if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+            impl_test_axpby_mv_unification_compare<
+                tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
+                ViewTypeBr0, view_stride_adapter<ViewTypeY>, Device>(
+                a, x, b, y, N, K, true, max_val, max_error);
+          }
         }
       }
     }
@@ -1061,7 +1309,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 09/36: Ar0 + Br1s_1
   // ************************************************************
-  // std::cout << "Starting case 09/36" << std::endl;
+  std::cout << "Starting case 09/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutA, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -1080,8 +1328,15 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
               view_stride_adapter<ViewTypeBr1s_1>,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, max_val,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
                                                       max_error);
+          if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+            impl_test_axpby_mv_unification_compare<
+                tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
+                view_stride_adapter<ViewTypeBr1s_1>,
+                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true, max_val,
+                                                        max_error);
+          }
         }
       }
     }
@@ -1090,7 +1345,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 10/36: Ar0 + Br1s_k
   // ************************************************************
-  // std::cout << "Starting case 10/36" << std::endl;
+  std::cout << "Starting case 10/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutA, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -1119,7 +1374,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
               view_stride_adapter<ViewTypeBr1s_k>,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, max_val,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
                                                       max_error);
         }
       }
@@ -1129,7 +1384,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 11/36: Ar0 + Br1d,1
   // ************************************************************
-  // std::cout << "Starting case 11/36" << std::endl;
+  std::cout << "Starting case 11/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutA, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -1148,7 +1403,13 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
               view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
-              Device>(a, x, b, y, N, K, max_val, max_error);
+              Device>(a, x, b, y, N, K, false, max_val, max_error);
+          if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+            impl_test_axpby_mv_unification_compare<
+                tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
+                view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
+                Device>(a, x, b, y, N, K, true, max_val, max_error);
+          }
         }
       }
     }
@@ -1157,7 +1418,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 12/36: Ar0 + Br1d,k
   // ************************************************************
-  // std::cout << "Starting case 12/36" << std::endl;
+  std::cout << "Starting case 12/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutA, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -1186,7 +1447,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
               view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
-              Device>(a, x, b, y, N, K, max_val, max_error);
+              Device>(a, x, b, y, N, K, false, max_val, max_error);
         }
       }
     }
@@ -1195,7 +1456,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 13/36: Ar1s_1 + Bscalar
   // ************************************************************w
-  // std::cout << "Starting case 13/36" << std::endl;
+  std::cout << "Starting case 13/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1211,8 +1472,15 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
         impl_test_axpby_mv_unification_compare<
             tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
             view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
-            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, max_val,
+            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
                                                     max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_mv_unification_compare<
+              tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
+              view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true, max_val,
+                                                      max_error);
+        }
       }
     }
   }
@@ -1220,7 +1488,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 14/36: Ar1s_1 + Br0
   // ************************************************************
-  // std::cout << "Starting case 14/36" << std::endl;
+  std::cout << "Starting case 14/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutB, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -1239,8 +1507,15 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
               view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, max_val,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
                                                       max_error);
+          if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+            impl_test_axpby_mv_unification_compare<
+                tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
+                view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
+                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true, max_val,
+                                                        max_error);
+          }
         }
       }
     }
@@ -1249,7 +1524,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 15/36: Ar1s_1 + Br1s_1
   // ************************************************************
-  // std::cout << "Starting case 15/36" << std::endl;
+  std::cout << "Starting case 15/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1266,7 +1541,14 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
             tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_mv_unification_compare<
+              tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
+              view_stride_adapter<ViewTypeX>, tScalarB,
+              view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
+              Device>(a, x, b, y, N, K, true, max_val, max_error);
+        }
       }
     }
   }
@@ -1274,7 +1556,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 16/36: Ar1s_1 + Br1s_k
   // ************************************************************
-  // std::cout << "Starting case 16/36" << std::endl;
+  std::cout << "Starting case 16/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1301,7 +1583,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
             tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1s_k>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
       }
     }
   }
@@ -1309,7 +1591,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 17/36: Ar1s_1 + Br1d,1
   // ************************************************************
-  // std::cout << "Starting case 17/36" << std::endl;
+  std::cout << "Starting case 17/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1326,7 +1608,14 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
             tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_mv_unification_compare<
+              tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
+              view_stride_adapter<ViewTypeX>, tScalarB,
+              view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
+              Device>(a, x, b, y, N, K, true, max_val, max_error);
+        }
       }
     }
   }
@@ -1334,7 +1623,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 18/36: Ar1s_1 + Br1d,k
   // ************************************************************
-  // std::cout << "Starting case 18/36" << std::endl;
+  std::cout << "Starting case 18/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1361,7 +1650,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
             tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
       }
     }
   }
@@ -1369,7 +1658,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 19/36: Ar1s_k + Bscalar
   // ************************************************************
-  // std::cout << "Starting case 19/36" << std::endl;
+  std::cout << "Starting case 19/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1395,8 +1684,15 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
         impl_test_axpby_mv_unification_compare<
             tScalarA, view_stride_adapter<ViewTypeAr1s_k>,
             view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
-            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, max_val,
+            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
                                                     max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_mv_unification_compare<
+              tScalarA, view_stride_adapter<ViewTypeAr1s_k>,
+              view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true, max_val,
+                                                      max_error);
+        }
       }
     }
   }
@@ -1404,7 +1700,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 20/36: Ar1s_k + Br0
   // ************************************************************
-  // std::cout << "Starting case 20/36" << std::endl;
+  std::cout << "Starting case 20/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutB, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -1433,8 +1729,15 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1s_k>,
               view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, max_val,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
                                                       max_error);
+          if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+            impl_test_axpby_mv_unification_compare<
+                tScalarA, view_stride_adapter<ViewTypeAr1s_k>,
+                view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
+                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true, max_val,
+                                                        max_error);
+          }
         }
       }
     }
@@ -1443,7 +1746,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 21/36: Ar1s_k + Br1s_1
   // ************************************************************
-  // std::cout << "Starting case 21/36" << std::endl;
+  std::cout << "Starting case 21/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1470,7 +1773,14 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
             tScalarA, view_stride_adapter<ViewTypeAr1s_k>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_mv_unification_compare<
+              tScalarA, view_stride_adapter<ViewTypeAr1s_k>,
+              view_stride_adapter<ViewTypeX>, tScalarB,
+              view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
+              Device>(a, x, b, y, N, K, true, max_val, max_error);
+        }
       }
     }
   }
@@ -1478,7 +1788,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 22/36: Ar1s_k + Br1s_k
   // ************************************************************
-  // std::cout << "Starting case 22/36" << std::endl;
+  std::cout << "Starting case 22/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1516,7 +1826,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
             tScalarA, view_stride_adapter<ViewTypeAr1s_k>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1s_k>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
       }
     }
   }
@@ -1524,7 +1834,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 23/36: Ar1s_k + Br1d,1
   // ************************************************************
-  // std::cout << "Starting case 23/36" << std::endl;
+  std::cout << "Starting case 23/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1551,7 +1861,14 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
             tScalarA, view_stride_adapter<ViewTypeAr1s_k>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_mv_unification_compare<
+              tScalarA, view_stride_adapter<ViewTypeAr1s_k>,
+              view_stride_adapter<ViewTypeX>, tScalarB,
+              view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
+              Device>(a, x, b, y, N, K, true, max_val, max_error);
+        }
       }
     }
   }
@@ -1559,7 +1876,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 24/36: Ar1s_k + Br1d,k
   // ************************************************************
-  // std::cout << "Starting case 24/36" << std::endl;
+  std::cout << "Starting case 24/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1598,7 +1915,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
             tScalarA, view_stride_adapter<ViewTypeAr1s_k>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
       }
     }
   }
@@ -1606,7 +1923,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 25/36: Ar1d,1 + Bscalar
   // ************************************************************w
-  // std::cout << "Starting case 25/36" << std::endl;
+  std::cout << "Starting case 25/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1622,8 +1939,15 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
         impl_test_axpby_mv_unification_compare<
             tScalarA, view_stride_adapter<ViewTypeAr1d>,
             view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
-            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, max_val,
+            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
                                                     max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_mv_unification_compare<
+              tScalarA, view_stride_adapter<ViewTypeAr1d>,
+              view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true, max_val,
+                                                      max_error);
+        }
       }
     }
   }
@@ -1631,7 +1955,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 26/36: Ar1d,1 + Br0
   // ************************************************************
-  // std::cout << "Starting case 26/36" << std::endl;
+  std::cout << "Starting case 26/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutB, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -1650,8 +1974,15 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1d>,
               view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, max_val,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
                                                       max_error);
+          if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+            impl_test_axpby_mv_unification_compare<
+                tScalarA, view_stride_adapter<ViewTypeAr1d>,
+                view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
+                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true, max_val,
+                                                        max_error);
+          }
         }
       }
     }
@@ -1660,7 +1991,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 27/36: Ar1d,1 + Br1s_1
   // ************************************************************
-  // std::cout << "Starting case 27/36" << std::endl;
+  std::cout << "Starting case 27/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1677,7 +2008,14 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
             tScalarA, view_stride_adapter<ViewTypeAr1d>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_mv_unification_compare<
+              tScalarA, view_stride_adapter<ViewTypeAr1d>,
+              view_stride_adapter<ViewTypeX>, tScalarB,
+              view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
+              Device>(a, x, b, y, N, K, true, max_val, max_error);
+        }
       }
     }
   }
@@ -1685,7 +2023,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 28/36: Ar1d,1 + Br1s_k
   // ************************************************************
-  // std::cout << "Starting case 28/36" << std::endl;
+  std::cout << "Starting case 28/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1712,7 +2050,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
             tScalarA, view_stride_adapter<ViewTypeAr1d>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1s_k>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
       }
     }
   }
@@ -1720,7 +2058,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 29/36: Ar1d,1 + Br1d,1
   // ************************************************************
-  // std::cout << "Starting case 29/36" << std::endl;
+  std::cout << "Starting case 29/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1737,7 +2075,14 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
             tScalarA, view_stride_adapter<ViewTypeAr1d>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_mv_unification_compare<
+              tScalarA, view_stride_adapter<ViewTypeAr1d>,
+              view_stride_adapter<ViewTypeX>, tScalarB,
+              view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
+              Device>(a, x, b, y, N, K, true, max_val, max_error);
+        }
       }
     }
   }
@@ -1745,7 +2090,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 30/36: Ar1d,1 + Br1d,k
   // ************************************************************
-  // std::cout << "Starting case 30/36" << std::endl;
+  std::cout << "Starting case 30/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1772,7 +2117,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
             tScalarA, view_stride_adapter<ViewTypeAr1d>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
       }
     }
   }
@@ -1780,7 +2125,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 31/36: Ar1d,k + Bscalar
   // ************************************************************w
-  // std::cout << "Starting case 31/36" << std::endl;
+  std::cout << "Starting case 31/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1806,8 +2151,15 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
         impl_test_axpby_mv_unification_compare<
             tScalarA, view_stride_adapter<ViewTypeAr1d>,
             view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
-            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, max_val,
+            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
                                                     max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_mv_unification_compare<
+              tScalarA, view_stride_adapter<ViewTypeAr1d>,
+              view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true, max_val,
+                                                      max_error);
+        }
       }
     }
   }
@@ -1815,7 +2167,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 32/36: Ar1d,k + Br0
   // ************************************************************
-  // std::cout << "Starting case 32/36" << std::endl;
+  std::cout << "Starting case 32/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutB, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -1844,8 +2196,15 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1d>,
               view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, max_val,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
                                                       max_error);
+          if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+            impl_test_axpby_mv_unification_compare<
+                tScalarA, view_stride_adapter<ViewTypeAr1d>,
+                view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
+                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true, max_val,
+                                                        max_error);
+          }
         }
       }
     }
@@ -1854,7 +2213,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 33/36: Ar1d,k + Br1s_1
   // ************************************************************
-  // std::cout << "Starting case 33/36" << std::endl;
+  std::cout << "Starting case 33/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1881,7 +2240,14 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
             tScalarA, view_stride_adapter<ViewTypeAr1d>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_mv_unification_compare<
+              tScalarA, view_stride_adapter<ViewTypeAr1d>,
+              view_stride_adapter<ViewTypeX>, tScalarB,
+              view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
+              Device>(a, x, b, y, N, K, true, max_val, max_error);
+        }
       }
     }
   }
@@ -1889,7 +2255,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 34/36: Ar1d,k + Br1s_k
   // ************************************************************
-  // std::cout << "Starting case 34/36" << std::endl;
+  std::cout << "Starting case 34/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1928,7 +2294,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
             tScalarA, view_stride_adapter<ViewTypeAr1d>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1s_k>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
       }
     }
   }
@@ -1936,7 +2302,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 35/36: Ar1d,k + Br1d,1
   // ************************************************************
-  // std::cout << "Starting case 35/36" << std::endl;
+  std::cout << "Starting case 35/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1963,7 +2329,14 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
             tScalarA, view_stride_adapter<ViewTypeAr1d>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
+        if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+          impl_test_axpby_mv_unification_compare<
+              tScalarA, view_stride_adapter<ViewTypeAr1d>,
+              view_stride_adapter<ViewTypeX>, tScalarB,
+              view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
+              Device>(a, x, b, y, N, K, true, max_val, max_error);
+        }
       }
     }
   }
@@ -1971,7 +2344,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 36/36: Ar1d,k + Br1d,k
   // ************************************************************
-  // std::cout << "Starting case 36/36" << std::endl;
+  std::cout << "Starting case 36/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -2010,7 +2383,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
             tScalarA, view_stride_adapter<ViewTypeAr1d>,
             view_stride_adapter<ViewTypeX>, tScalarB,
             view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
-            Device>(a, x, b, y, N, K, max_val, max_error);
+            Device>(a, x, b, y, N, K, false, max_val, max_error);
       }
     }
   }

From ee23cf735665d37e3d27e53bb55456faa80a20b8 Mon Sep 17 00:00:00 2001
From: Ernesto Prudencio <eeprude@sandia.gov>
Date: Mon, 20 Nov 2023 01:49:21 -0700
Subject: [PATCH 03/14] Backup

---
 blas/impl/KokkosBlas1_axpby_impl.hpp          |  28 ++++-
 blas/impl/KokkosBlas1_axpby_mv_impl.hpp       | 110 ++++++++++++++----
 .../Test_Blas1_axpby_unification.hpp          |  76 ++++++------
 3 files changed, 152 insertions(+), 62 deletions(-)

diff --git a/blas/impl/KokkosBlas1_axpby_impl.hpp b/blas/impl/KokkosBlas1_axpby_impl.hpp
index 29a72c19d5..dfed515368 100644
--- a/blas/impl/KokkosBlas1_axpby_impl.hpp
+++ b/blas/impl/KokkosBlas1_axpby_impl.hpp
@@ -123,7 +123,12 @@ struct Axpby_Functor {
       } else if constexpr (scalar_y == 1) {
         // Nothing to do: m_y(i) = m_y(i);
       } else if constexpr (scalar_y == 2) {
-        m_y(i) = m_b(0) * m_y(i);
+        if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+          m_y(i) = Kokkos::ArithTraits<typename BV::non_const_value_type>::zero();
+        }
+        else {
+          m_y(i) = m_b(0) * m_y(i);
+        }
       }
     }
     // **************************************************************
@@ -137,7 +142,12 @@ struct Axpby_Functor {
       } else if constexpr (scalar_y == 1) {
         m_y(i) = -m_x(i) + m_y(i);
       } else if constexpr (scalar_y == 2) {
-        m_y(i) = -m_x(i) + m_b(0) * m_y(i);
+        if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+          m_y(i) = -m_x(i);
+        }
+        else {
+          m_y(i) = -m_x(i) + m_b(0) * m_y(i);
+        }
       }
     }
     // **************************************************************
@@ -151,7 +161,12 @@ struct Axpby_Functor {
       } else if constexpr (scalar_y == 1) {
         m_y(i) = m_x(i) + m_y(i);
       } else if constexpr (scalar_y == 2) {
-        m_y(i) = m_x(i) + m_b(0) * m_y(i);
+        if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+          m_y(i) = m_x(i);
+        }
+        else {
+          m_y(i) = m_x(i) + m_b(0) * m_y(i);
+        }
       }
     }
     // **************************************************************
@@ -165,7 +180,12 @@ struct Axpby_Functor {
       } else if constexpr (scalar_y == 1) {
         m_y(i) = m_a(0) * m_x(i) + m_y(i);
       } else if constexpr (scalar_y == 2) {
-        m_y(i) = m_a(0) * m_x(i) + m_b(0) * m_y(i);
+        if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+          m_y(i) = m_a(0) * m_x(i);
+        }
+        else {
+          m_y(i) = m_a(0) * m_x(i) + m_b(0) * m_y(i);
+        }
       }
     }
   }
diff --git a/blas/impl/KokkosBlas1_axpby_mv_impl.hpp b/blas/impl/KokkosBlas1_axpby_mv_impl.hpp
index 4a9872d7d7..349a8ba8ef 100644
--- a/blas/impl/KokkosBlas1_axpby_mv_impl.hpp
+++ b/blas/impl/KokkosBlas1_axpby_mv_impl.hpp
@@ -129,8 +129,15 @@ struct Axpby_MV_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
 #pragma vector always
 #endif
-          for (size_type k = 0; k < numCols; ++k) {
-            m_y(i, k) = m_b(0) * m_y(i, k);
+          if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+            for (size_type k = 0; k < numCols; ++k) {
+              m_y(i, k) = Kokkos::ArithTraits<typename BV::non_const_value_type>::zero();
+            }
+          }
+          else {
+            for (size_type k = 0; k < numCols; ++k) {
+              m_y(i, k) = m_b(0) * m_y(i, k);
+            }
           }
         } else {
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
@@ -187,8 +194,15 @@ struct Axpby_MV_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
 #pragma vector always
 #endif
-          for (size_type k = 0; k < numCols; ++k) {
-            m_y(i, k) = -m_x(i, k) + m_b(0) * m_y(i, k);
+          if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+            for (size_type k = 0; k < numCols; ++k) {
+              m_y(i, k) = -m_x(i, k);
+            }
+          }
+          else {
+            for (size_type k = 0; k < numCols; ++k) {
+              m_y(i, k) = -m_x(i, k) + m_b(0) * m_y(i, k);
+            }
           }
         } else {
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
@@ -245,8 +259,15 @@ struct Axpby_MV_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
 #pragma vector always
 #endif
-          for (size_type k = 0; k < numCols; ++k) {
-            m_y(i, k) = m_x(i, k) + m_b(0) * m_y(i, k);
+          if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+            for (size_type k = 0; k < numCols; ++k) {
+              m_y(i, k) = m_x(i, k);
+            }
+          }
+          else {
+            for (size_type k = 0; k < numCols; ++k) {
+              m_y(i, k) = m_x(i, k) + m_b(0) * m_y(i, k);
+            }
           }
         } else {
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
@@ -340,8 +361,15 @@ struct Axpby_MV_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
 #pragma vector always
 #endif
-            for (size_type k = 0; k < numCols; ++k) {
-              m_y(i, k) = m_a(0) * m_x(i, k) + m_b(0) * m_y(i, k);
+            if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+              for (size_type k = 0; k < numCols; ++k) {
+                m_y(i, k) = m_a(0) * m_x(i, k);
+              }
+            }
+            else {
+              for (size_type k = 0; k < numCols; ++k) {
+                m_y(i, k) = m_a(0) * m_x(i, k) + m_b(0) * m_y(i, k);
+              }
             }
           } else {
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
@@ -362,8 +390,15 @@ struct Axpby_MV_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
 #pragma vector always
 #endif
-            for (size_type k = 0; k < numCols; ++k) {
-              m_y(i, k) = m_a(k) * m_x(i, k) + m_b(0) * m_y(i, k);
+            if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+              for (size_type k = 0; k < numCols; ++k) {
+                m_y(i, k) = m_a(k) * m_x(i, k);
+              }
+            }
+            else {
+              for (size_type k = 0; k < numCols; ++k) {
+                m_y(i, k) = m_a(k) * m_x(i, k) + m_b(0) * m_y(i, k);
+              }
             }
           } else {
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
@@ -718,8 +753,15 @@ struct Axpby_MV_Unroll_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
 #pragma unroll
 #endif
-          for (int k = 0; k < UNROLL; ++k) {
-            m_y(i, k) = m_b(0) * m_y(i, k);
+          if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+            for (int k = 0; k < UNROLL; ++k) {
+              m_y(i, k) = Kokkos::ArithTraits<typename BV::non_const_value_type>::zero();
+            }
+          }
+          else {
+            for (int k = 0; k < UNROLL; ++k) {
+              m_y(i, k) = m_b(0) * m_y(i, k);
+            }
           }
         } else {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
@@ -761,8 +803,15 @@ struct Axpby_MV_Unroll_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
 #pragma unroll
 #endif
-          for (int k = 0; k < UNROLL; ++k) {
-            m_y(i, k) = -m_x(i, k) + m_b(0) * m_y(i, k);
+          if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+            for (int k = 0; k < UNROLL; ++k) {
+              m_y(i, k) = -m_x(i, k);
+            }
+          }
+          else {
+            for (int k = 0; k < UNROLL; ++k) {
+              m_y(i, k) = -m_x(i, k) + m_b(0) * m_y(i, k);
+            }
           }
         } else {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
@@ -804,8 +853,15 @@ struct Axpby_MV_Unroll_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
 #pragma unroll
 #endif
-          for (int k = 0; k < UNROLL; ++k) {
-            m_y(i, k) = m_x(i, k) + m_b(0) * m_y(i, k);
+          if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+            for (int k = 0; k < UNROLL; ++k) {
+              m_y(i, k) = m_x(i, k);
+            }
+          }
+          else {
+            for (int k = 0; k < UNROLL; ++k) {
+              m_y(i, k) = m_x(i, k) + m_b(0) * m_y(i, k);
+            }
           }
         } else {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
@@ -875,8 +931,15 @@ struct Axpby_MV_Unroll_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
 #pragma unroll
 #endif
-            for (int k = 0; k < UNROLL; ++k) {
-              m_y(i, k) = m_a(0) * m_x(i, k) + m_b(0) * m_y(i, k);
+            if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+              for (int k = 0; k < UNROLL; ++k) {
+                m_y(i, k) = m_a(0) * m_x(i, k);
+              }
+            }
+            else {
+              for (int k = 0; k < UNROLL; ++k) {
+                m_y(i, k) = m_a(0) * m_x(i, k) + m_b(0) * m_y(i, k);
+              }
             }
           } else {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
@@ -891,8 +954,15 @@ struct Axpby_MV_Unroll_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
 #pragma unroll
 #endif
-            for (int k = 0; k < UNROLL; ++k) {
-              m_y(i, k) = m_a(k) * m_x(i, k) + m_b(0) * m_y(i, k);
+            if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+              for (int k = 0; k < UNROLL; ++k) {
+                m_y(i, k) = m_a(k) * m_x(i, k);
+              }
+            }
+            else {
+              for (int k = 0; k < UNROLL; ++k) {
+                m_y(i, k) = m_a(k) * m_x(i, k) + m_b(0) * m_y(i, k);
+              }
             }
           } else {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
diff --git a/blas/unit_test/Test_Blas1_axpby_unification.hpp b/blas/unit_test/Test_Blas1_axpby_unification.hpp
index 447924a5a7..ef18961645 100644
--- a/blas/unit_test/Test_Blas1_axpby_unification.hpp
+++ b/blas/unit_test/Test_Blas1_axpby_unification.hpp
@@ -394,7 +394,7 @@ void impl_test_axpby_mv_unification_compare(
           (void)valueA;  // Avoid "set but not used" error
           int a_k(a.h_view.extent(0) == 1 ? 0 : k);
           vanillaValue = static_cast<ScalarTypeY>(a.h_view(a_k) * x.h_view(i, k));
-#if 1
+#if 0
           ScalarTypeY tmp = static_cast<ScalarTypeY>(a.h_view(a_k) * x.h_view(i, k) + valueB * org_y.h_view(i, k));
           std::cout << "i = "                    << i
                     << ", k = "                  << k
@@ -410,7 +410,7 @@ void impl_test_axpby_mv_unification_compare(
 #endif
         } else {
           vanillaValue = static_cast<ScalarTypeY>(valueA * x.h_view(i, k));
-#if 1
+#if 0
           ScalarTypeY tmp = static_cast<ScalarTypeY>(valueA * x.h_view(i, k) + valueB * org_y.h_view(i, k));
           std::cout << "i = "                    << i
                     << ", k = "                  << k
@@ -1048,7 +1048,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 01/36: Ascalar + Bscalar
   // ************************************************************
-  std::cout << "Starting case 01/36" << std::endl;
+  // std::cout << "Starting case 01/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1078,7 +1078,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 02/36: Ascalar + Br0
   // ************************************************************
-  std::cout << "Starting case 02/36" << std::endl;
+  // std::cout << "Starting case 02/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutB, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -1112,7 +1112,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 03/36: Ascalar + Br1s_1
   // ************************************************************
-  std::cout << "Starting case 03/36" << std::endl;
+  // std::cout << "Starting case 03/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1142,7 +1142,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 04/36: Ascalar + Br1s_k
   // ************************************************************
-  std::cout << "Starting case 04/36" << std::endl;
+  // std::cout << "Starting case 04/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1176,7 +1176,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 05/36: Ascalar + Br1d,1
   // ************************************************************
-  std::cout << "Starting case 05/36" << std::endl;
+  // std::cout << "Starting case 05/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1206,7 +1206,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 06/36: Ascalar + Br1d,k
   // ************************************************************
-  std::cout << "Starting case 06/36" << std::endl;
+  // std::cout << "Starting case 06/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1240,7 +1240,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 07/36: Ar0 + Bscalar
   // ************************************************************w
-  std::cout << "Starting case 07/36" << std::endl;
+  // std::cout << "Starting case 07/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutA, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -1274,7 +1274,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 08/36: Ar0 + Br0
   // ************************************************************
-  std::cout << "Starting case 08/36" << std::endl;
+  // std::cout << "Starting case 08/36" << std::endl;
   if constexpr ((std::is_same_v<tLayoutA, Kokkos::LayoutStride>) ||
                 (std::is_same_v<tLayoutB, Kokkos::LayoutStride>)) {
     // Avoid the test, due to compilation errors
@@ -1309,7 +1309,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 09/36: Ar0 + Br1s_1
   // ************************************************************
-  std::cout << "Starting case 09/36" << std::endl;
+  // std::cout << "Starting case 09/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutA, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -1345,7 +1345,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 10/36: Ar0 + Br1s_k
   // ************************************************************
-  std::cout << "Starting case 10/36" << std::endl;
+  // std::cout << "Starting case 10/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutA, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -1384,7 +1384,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 11/36: Ar0 + Br1d,1
   // ************************************************************
-  std::cout << "Starting case 11/36" << std::endl;
+  // std::cout << "Starting case 11/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutA, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -1418,7 +1418,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 12/36: Ar0 + Br1d,k
   // ************************************************************
-  std::cout << "Starting case 12/36" << std::endl;
+  // std::cout << "Starting case 12/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutA, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -1456,7 +1456,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 13/36: Ar1s_1 + Bscalar
   // ************************************************************w
-  std::cout << "Starting case 13/36" << std::endl;
+  // std::cout << "Starting case 13/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1488,7 +1488,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 14/36: Ar1s_1 + Br0
   // ************************************************************
-  std::cout << "Starting case 14/36" << std::endl;
+  // std::cout << "Starting case 14/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutB, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -1524,7 +1524,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 15/36: Ar1s_1 + Br1s_1
   // ************************************************************
-  std::cout << "Starting case 15/36" << std::endl;
+  // std::cout << "Starting case 15/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1556,7 +1556,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 16/36: Ar1s_1 + Br1s_k
   // ************************************************************
-  std::cout << "Starting case 16/36" << std::endl;
+  // std::cout << "Starting case 16/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1591,7 +1591,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 17/36: Ar1s_1 + Br1d,1
   // ************************************************************
-  std::cout << "Starting case 17/36" << std::endl;
+  // std::cout << "Starting case 17/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1623,7 +1623,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 18/36: Ar1s_1 + Br1d,k
   // ************************************************************
-  std::cout << "Starting case 18/36" << std::endl;
+  // std::cout << "Starting case 18/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1658,7 +1658,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 19/36: Ar1s_k + Bscalar
   // ************************************************************
-  std::cout << "Starting case 19/36" << std::endl;
+  // std::cout << "Starting case 19/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1700,7 +1700,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 20/36: Ar1s_k + Br0
   // ************************************************************
-  std::cout << "Starting case 20/36" << std::endl;
+  // std::cout << "Starting case 20/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutB, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -1746,7 +1746,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 21/36: Ar1s_k + Br1s_1
   // ************************************************************
-  std::cout << "Starting case 21/36" << std::endl;
+  // std::cout << "Starting case 21/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1788,7 +1788,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 22/36: Ar1s_k + Br1s_k
   // ************************************************************
-  std::cout << "Starting case 22/36" << std::endl;
+  // std::cout << "Starting case 22/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1834,7 +1834,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 23/36: Ar1s_k + Br1d,1
   // ************************************************************
-  std::cout << "Starting case 23/36" << std::endl;
+  // std::cout << "Starting case 23/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1876,7 +1876,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 24/36: Ar1s_k + Br1d,k
   // ************************************************************
-  std::cout << "Starting case 24/36" << std::endl;
+  // std::cout << "Starting case 24/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1923,7 +1923,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 25/36: Ar1d,1 + Bscalar
   // ************************************************************w
-  std::cout << "Starting case 25/36" << std::endl;
+  // std::cout << "Starting case 25/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1955,7 +1955,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 26/36: Ar1d,1 + Br0
   // ************************************************************
-  std::cout << "Starting case 26/36" << std::endl;
+  // std::cout << "Starting case 26/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutB, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -1991,7 +1991,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 27/36: Ar1d,1 + Br1s_1
   // ************************************************************
-  std::cout << "Starting case 27/36" << std::endl;
+  // std::cout << "Starting case 27/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -2023,7 +2023,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 28/36: Ar1d,1 + Br1s_k
   // ************************************************************
-  std::cout << "Starting case 28/36" << std::endl;
+  // std::cout << "Starting case 28/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -2058,7 +2058,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 29/36: Ar1d,1 + Br1d,1
   // ************************************************************
-  std::cout << "Starting case 29/36" << std::endl;
+  // std::cout << "Starting case 29/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -2090,7 +2090,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 30/36: Ar1d,1 + Br1d,k
   // ************************************************************
-  std::cout << "Starting case 30/36" << std::endl;
+  // std::cout << "Starting case 30/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -2125,7 +2125,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 31/36: Ar1d,k + Bscalar
   // ************************************************************w
-  std::cout << "Starting case 31/36" << std::endl;
+  // std::cout << "Starting case 31/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -2167,7 +2167,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 32/36: Ar1d,k + Br0
   // ************************************************************
-  std::cout << "Starting case 32/36" << std::endl;
+  // std::cout << "Starting case 32/36" << std::endl;
   if constexpr (std::is_same_v<tLayoutB, Kokkos::LayoutStride>) {
     // Avoid the test, due to compilation errors
   } else {
@@ -2213,7 +2213,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 33/36: Ar1d,k + Br1s_1
   // ************************************************************
-  std::cout << "Starting case 33/36" << std::endl;
+  // std::cout << "Starting case 33/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -2255,7 +2255,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 34/36: Ar1d,k + Br1s_k
   // ************************************************************
-  std::cout << "Starting case 34/36" << std::endl;
+  // std::cout << "Starting case 34/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -2302,7 +2302,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 35/36: Ar1d,k + Br1d,1
   // ************************************************************
-  std::cout << "Starting case 35/36" << std::endl;
+  // std::cout << "Starting case 35/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -2344,7 +2344,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 36/36: Ar1d,k + Br1d,k
   // ************************************************************
-  std::cout << "Starting case 36/36" << std::endl;
+  // std::cout << "Starting case 36/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA(valuesA[i]);
     for (size_t j(0); j < valuesB.size(); ++j) {

From 931d8b43f430de241a4f4b2dc109f150dc7d5b86 Mon Sep 17 00:00:00 2001
From: Ernesto Prudencio <eeprude@sandia.gov>
Date: Mon, 20 Nov 2023 02:22:37 -0700
Subject: [PATCH 04/14] Formatting

---
 blas/impl/KokkosBlas1_axpby_impl.hpp          |  27 +--
 blas/impl/KokkosBlas1_axpby_mv_impl.hpp       |  66 +++---
 .../Test_Blas1_axpby_unification.hpp          | 211 +++++++++---------
 blas/unit_test/Test_Blas2_syr2.hpp            |   8 +-
 4 files changed, 165 insertions(+), 147 deletions(-)

diff --git a/blas/impl/KokkosBlas1_axpby_impl.hpp b/blas/impl/KokkosBlas1_axpby_impl.hpp
index dfed515368..b919d76a94 100644
--- a/blas/impl/KokkosBlas1_axpby_impl.hpp
+++ b/blas/impl/KokkosBlas1_axpby_impl.hpp
@@ -123,10 +123,11 @@ struct Axpby_Functor {
       } else if constexpr (scalar_y == 1) {
         // Nothing to do: m_y(i) = m_y(i);
       } else if constexpr (scalar_y == 2) {
-        if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
-          m_y(i) = Kokkos::ArithTraits<typename BV::non_const_value_type>::zero();
-        }
-        else {
+        if (m_b(0) ==
+            Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+          m_y(i) =
+              Kokkos::ArithTraits<typename YV::non_const_value_type>::zero();
+        } else {
           m_y(i) = m_b(0) * m_y(i);
         }
       }
@@ -142,10 +143,10 @@ struct Axpby_Functor {
       } else if constexpr (scalar_y == 1) {
         m_y(i) = -m_x(i) + m_y(i);
       } else if constexpr (scalar_y == 2) {
-        if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+        if (m_b(0) ==
+            Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
           m_y(i) = -m_x(i);
-        }
-        else {
+        } else {
           m_y(i) = -m_x(i) + m_b(0) * m_y(i);
         }
       }
@@ -161,10 +162,10 @@ struct Axpby_Functor {
       } else if constexpr (scalar_y == 1) {
         m_y(i) = m_x(i) + m_y(i);
       } else if constexpr (scalar_y == 2) {
-        if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+        if (m_b(0) ==
+            Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
           m_y(i) = m_x(i);
-        }
-        else {
+        } else {
           m_y(i) = m_x(i) + m_b(0) * m_y(i);
         }
       }
@@ -180,10 +181,10 @@ struct Axpby_Functor {
       } else if constexpr (scalar_y == 1) {
         m_y(i) = m_a(0) * m_x(i) + m_y(i);
       } else if constexpr (scalar_y == 2) {
-        if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+        if (m_b(0) ==
+            Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
           m_y(i) = m_a(0) * m_x(i);
-        }
-        else {
+        } else {
           m_y(i) = m_a(0) * m_x(i) + m_b(0) * m_y(i);
         }
       }
diff --git a/blas/impl/KokkosBlas1_axpby_mv_impl.hpp b/blas/impl/KokkosBlas1_axpby_mv_impl.hpp
index 349a8ba8ef..e81728d3ba 100644
--- a/blas/impl/KokkosBlas1_axpby_mv_impl.hpp
+++ b/blas/impl/KokkosBlas1_axpby_mv_impl.hpp
@@ -129,12 +129,13 @@ struct Axpby_MV_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
 #pragma vector always
 #endif
-          if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+          if (m_b(0) ==
+              Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
             for (size_type k = 0; k < numCols; ++k) {
-              m_y(i, k) = Kokkos::ArithTraits<typename BV::non_const_value_type>::zero();
+              m_y(i, k) = Kokkos::ArithTraits<
+                  typename YMV::non_const_value_type>::zero();
             }
-          }
-          else {
+          } else {
             for (size_type k = 0; k < numCols; ++k) {
               m_y(i, k) = m_b(0) * m_y(i, k);
             }
@@ -194,12 +195,12 @@ struct Axpby_MV_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
 #pragma vector always
 #endif
-          if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+          if (m_b(0) ==
+              Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
             for (size_type k = 0; k < numCols; ++k) {
               m_y(i, k) = -m_x(i, k);
             }
-          }
-          else {
+          } else {
             for (size_type k = 0; k < numCols; ++k) {
               m_y(i, k) = -m_x(i, k) + m_b(0) * m_y(i, k);
             }
@@ -259,12 +260,12 @@ struct Axpby_MV_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
 #pragma vector always
 #endif
-          if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+          if (m_b(0) ==
+              Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
             for (size_type k = 0; k < numCols; ++k) {
               m_y(i, k) = m_x(i, k);
             }
-          }
-          else {
+          } else {
             for (size_type k = 0; k < numCols; ++k) {
               m_y(i, k) = m_x(i, k) + m_b(0) * m_y(i, k);
             }
@@ -361,12 +362,12 @@ struct Axpby_MV_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
 #pragma vector always
 #endif
-            if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+            if (m_b(0) == Kokkos::ArithTraits<
+                              typename BV::non_const_value_type>::zero()) {
               for (size_type k = 0; k < numCols; ++k) {
                 m_y(i, k) = m_a(0) * m_x(i, k);
               }
-            }
-            else {
+            } else {
               for (size_type k = 0; k < numCols; ++k) {
                 m_y(i, k) = m_a(0) * m_x(i, k) + m_b(0) * m_y(i, k);
               }
@@ -390,12 +391,12 @@ struct Axpby_MV_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
 #pragma vector always
 #endif
-            if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+            if (m_b(0) == Kokkos::ArithTraits<
+                              typename BV::non_const_value_type>::zero()) {
               for (size_type k = 0; k < numCols; ++k) {
                 m_y(i, k) = m_a(k) * m_x(i, k);
               }
-            }
-            else {
+            } else {
               for (size_type k = 0; k < numCols; ++k) {
                 m_y(i, k) = m_a(k) * m_x(i, k) + m_b(0) * m_y(i, k);
               }
@@ -753,12 +754,13 @@ struct Axpby_MV_Unroll_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
 #pragma unroll
 #endif
-          if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+          if (m_b(0) ==
+              Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
             for (int k = 0; k < UNROLL; ++k) {
-              m_y(i, k) = Kokkos::ArithTraits<typename BV::non_const_value_type>::zero();
+              m_y(i, k) = Kokkos::ArithTraits<
+                  typename YMV::non_const_value_type>::zero();
             }
-          }
-          else {
+          } else {
             for (int k = 0; k < UNROLL; ++k) {
               m_y(i, k) = m_b(0) * m_y(i, k);
             }
@@ -803,12 +805,12 @@ struct Axpby_MV_Unroll_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
 #pragma unroll
 #endif
-          if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+          if (m_b(0) ==
+              Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
             for (int k = 0; k < UNROLL; ++k) {
               m_y(i, k) = -m_x(i, k);
             }
-          }
-          else {
+          } else {
             for (int k = 0; k < UNROLL; ++k) {
               m_y(i, k) = -m_x(i, k) + m_b(0) * m_y(i, k);
             }
@@ -853,12 +855,12 @@ struct Axpby_MV_Unroll_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
 #pragma unroll
 #endif
-          if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+          if (m_b(0) ==
+              Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
             for (int k = 0; k < UNROLL; ++k) {
               m_y(i, k) = m_x(i, k);
             }
-          }
-          else {
+          } else {
             for (int k = 0; k < UNROLL; ++k) {
               m_y(i, k) = m_x(i, k) + m_b(0) * m_y(i, k);
             }
@@ -931,12 +933,12 @@ struct Axpby_MV_Unroll_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
 #pragma unroll
 #endif
-            if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+            if (m_b(0) == Kokkos::ArithTraits<
+                              typename BV::non_const_value_type>::zero()) {
               for (int k = 0; k < UNROLL; ++k) {
                 m_y(i, k) = m_a(0) * m_x(i, k);
               }
-            }
-            else {
+            } else {
               for (int k = 0; k < UNROLL; ++k) {
                 m_y(i, k) = m_a(0) * m_x(i, k) + m_b(0) * m_y(i, k);
               }
@@ -954,12 +956,12 @@ struct Axpby_MV_Unroll_Functor {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
 #pragma unroll
 #endif
-            if (m_b(0) == Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
+            if (m_b(0) == Kokkos::ArithTraits<
+                              typename BV::non_const_value_type>::zero()) {
               for (int k = 0; k < UNROLL; ++k) {
                 m_y(i, k) = m_a(k) * m_x(i, k);
               }
-            }
-            else {
+            } else {
               for (int k = 0; k < UNROLL; ++k) {
                 m_y(i, k) = m_a(k) * m_x(i, k) + m_b(0) * m_y(i, k);
               }
diff --git a/blas/unit_test/Test_Blas1_axpby_unification.hpp b/blas/unit_test/Test_Blas1_axpby_unification.hpp
index ef18961645..0457527718 100644
--- a/blas/unit_test/Test_Blas1_axpby_unification.hpp
+++ b/blas/unit_test/Test_Blas1_axpby_unification.hpp
@@ -83,7 +83,8 @@ void impl_test_axpby_unification_compare(
     bool testWithNanY,
     typename Kokkos::ArithTraits<tScalarB>::mag_type const max_val,
     typename Kokkos::ArithTraits<tScalarB>::mag_type const max_error,
-    tScalarA const inputValueA = Kokkos::ArithTraits<tScalarA>::zero(), tScalarB const inputValueB = Kokkos::ArithTraits<tScalarB>::zero()) {
+    tScalarA const inputValueA = Kokkos::ArithTraits<tScalarA>::zero(),
+    tScalarB const inputValueB = Kokkos::ArithTraits<tScalarB>::zero()) {
   using ScalarTypeX =
       typename std::remove_const<typename tX::DView::value_type>::type;
   using ScalarTypeY =
@@ -104,8 +105,7 @@ void impl_test_axpby_unification_compare(
     Test::getRandomBounds(max_val, randStart, randEnd);
     if (testWithNanY) {
       Kokkos::deep_copy(y.d_view, Kokkos::ArithTraits<ScalarTypeY>::nan());
-    }
-    else {
+    } else {
       Kokkos::fill_random(y.d_view, rand_pool, randStart, randEnd);
     }
   }
@@ -193,8 +193,7 @@ void impl_test_axpby_unification_compare(
                                               valueB * org_y.h_view(i)),
                      y.h_view(i), 2. * max_error);
     }
-  }
-  else {
+  } else {
     // ********************************************************
     // Tests with 'Y == nan()' are called only for cases where
     // b == Kokkos::ArithTraits<tScalarB>::zero()
@@ -218,8 +217,7 @@ void impl_test_axpby_unification_compare(
         if (y.h_view(i) != -1) {
           EXPECT_NE(y.h_view(i), Kokkos::ArithTraits<ScalarTypeY>::nan());
         }
-      }
-      else {
+      } else {
         EXPECT_NE(y.h_view(i), Kokkos::ArithTraits<ScalarTypeY>::nan());
       }
       EXPECT_NEAR_KK(static_cast<ScalarTypeY>(valueA * x.h_view(i)),
@@ -235,7 +233,8 @@ void impl_test_axpby_mv_unification_compare(
     bool testWithNanY,
     typename Kokkos::ArithTraits<tScalarB>::mag_type const max_val,
     typename Kokkos::ArithTraits<tScalarB>::mag_type const max_error,
-    tScalarA const inputValueA = Kokkos::ArithTraits<tScalarA>::zero(), tScalarB const inputValueB = Kokkos::ArithTraits<tScalarB>::zero()) {
+    tScalarA const inputValueA = Kokkos::ArithTraits<tScalarA>::zero(),
+    tScalarB const inputValueB = Kokkos::ArithTraits<tScalarB>::zero()) {
   using ScalarTypeX =
       typename std::remove_const<typename tY::DView::value_type>::type;
   using ScalarTypeY =
@@ -256,8 +255,7 @@ void impl_test_axpby_mv_unification_compare(
     Test::getRandomBounds(max_val, randStart, randEnd);
     if (testWithNanY) {
       Kokkos::deep_copy(y.d_view, Kokkos::ArithTraits<ScalarTypeY>::nan());
-    }
-    else {
+    } else {
       Kokkos::fill_random(y.d_view, rand_pool, randStart, randEnd);
     }
   }
@@ -373,16 +371,15 @@ void impl_test_axpby_mv_unification_compare(
             vanillaValue = static_cast<ScalarTypeY>(
                 valueA * x.h_view(i, k) + b.h_view(b_k) * org_y.h_view(i, k));
           } else {
-            vanillaValue = static_cast<ScalarTypeY>(valueA * x.h_view(i, k) +
-                                                    valueB * org_y.h_view(i, k));
+            vanillaValue = static_cast<ScalarTypeY>(
+                valueA * x.h_view(i, k) + valueB * org_y.h_view(i, k));
           }
         }
 
         EXPECT_NEAR_KK(vanillaValue, y.h_view(i, k), 2. * max_error);
       }
     }
-  }
-  else {
+  } else {
     // ********************************************************
     // Tests with 'Y == nan()' are called only for cases where
     // b == Kokkos::ArithTraits<tScalarB>::zero()
@@ -393,7 +390,8 @@ void impl_test_axpby_mv_unification_compare(
         if constexpr (aIsRank1) {
           (void)valueA;  // Avoid "set but not used" error
           int a_k(a.h_view.extent(0) == 1 ? 0 : k);
-          vanillaValue = static_cast<ScalarTypeY>(a.h_view(a_k) * x.h_view(i, k));
+          vanillaValue =
+              static_cast<ScalarTypeY>(a.h_view(a_k) * x.h_view(i, k));
 #if 0
           ScalarTypeY tmp = static_cast<ScalarTypeY>(a.h_view(a_k) * x.h_view(i, k) + valueB * org_y.h_view(i, k));
           std::cout << "i = "                    << i
@@ -432,11 +430,10 @@ void impl_test_axpby_mv_unification_compare(
           if (y.h_view(i, k) != -1) {
             EXPECT_NE(y.h_view(i, k), Kokkos::ArithTraits<ScalarTypeY>::nan());
           }
-        }
-        else {
+        } else {
           EXPECT_NE(y.h_view(i, k), Kokkos::ArithTraits<ScalarTypeY>::nan());
         }
-	
+
         EXPECT_NEAR_KK(vanillaValue, y.h_view(i, k), 2. * max_error);
       }
     }
@@ -459,8 +456,10 @@ void impl_test_axpby_unification(int const N) {
 
   using ViewTypeY = Kokkos::View<tScalarY*, tLayoutY, Device>;
 
-  std::array<tScalarA, 4> const valuesA{-1, Kokkos::ArithTraits<tScalarA>::zero(), 1, 3};
-  std::array<tScalarB, 4> const valuesB{-1, Kokkos::ArithTraits<tScalarB>::zero(), 1, 5};
+  std::array<tScalarA, 4> const valuesA{
+      -1, Kokkos::ArithTraits<tScalarA>::zero(), 1, 3};
+  std::array<tScalarB, 4> const valuesB{
+      -1, Kokkos::ArithTraits<tScalarB>::zero(), 1, 5};
 
   // eps should probably be based on tScalarB since that is the type
   // in which the result is computed.
@@ -563,8 +562,9 @@ void impl_test_axpby_unification(int const N) {
         if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
           impl_test_axpby_unification_compare<
               tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
-              view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
-              Device>(a, x, b, y, N, true, max_val, max_error);
+              view_stride_adapter<ViewTypeBr1s_1>,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, true,
+                                                      max_val, max_error);
         }
       }
     }
@@ -691,14 +691,14 @@ void impl_test_axpby_unification(int const N) {
           impl_test_axpby_unification_compare<
               tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
               view_stride_adapter<ViewTypeBr1s_1>,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, false, max_val,
-                                                      max_error);
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, false,
+                                                      max_val, max_error);
           if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
             impl_test_axpby_unification_compare<
                 tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
                 view_stride_adapter<ViewTypeBr1s_1>,
-                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, true, max_val,
-                                                        max_error);
+                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, true,
+                                                        max_val, max_error);
           }
         }
       }
@@ -731,8 +731,9 @@ void impl_test_axpby_unification(int const N) {
           if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
             impl_test_axpby_unification_compare<
                 tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
-                view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
-                Device>(a, x, b, y, N, true, max_val, max_error);
+                view_stride_adapter<ViewTypeBr1d>,
+                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, true,
+                                                        max_val, max_error);
           }
         }
       }
@@ -758,14 +759,14 @@ void impl_test_axpby_unification(int const N) {
         impl_test_axpby_unification_compare<
             tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
             view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
-            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, false, max_val,
-                                                    max_error);
+            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, false,
+                                                    max_val, max_error);
         if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
           impl_test_axpby_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
               view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, true, max_val,
-                                                      max_error);
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, true,
+                                                      max_val, max_error);
         }
       }
     }
@@ -793,14 +794,14 @@ void impl_test_axpby_unification(int const N) {
           impl_test_axpby_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
               view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, false, max_val,
-                                                      max_error);
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, false,
+                                                      max_val, max_error);
           if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
             impl_test_axpby_unification_compare<
                 tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
                 view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
-                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, true, max_val,
-                                                        max_error);
+                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, true,
+                                                        max_val, max_error);
           }
         }
       }
@@ -832,8 +833,9 @@ void impl_test_axpby_unification(int const N) {
           impl_test_axpby_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
               view_stride_adapter<ViewTypeX>, tScalarB,
-              view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
-              Device>(a, x, b, y, N, true, max_val, max_error);
+              view_stride_adapter<ViewTypeBr1s_1>,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, true,
+                                                      max_val, max_error);
         }
       }
     }
@@ -890,14 +892,14 @@ void impl_test_axpby_unification(int const N) {
         impl_test_axpby_unification_compare<
             tScalarA, view_stride_adapter<ViewTypeAr1d>,
             view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
-            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, false, max_val,
-                                                    max_error);
+            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, false,
+                                                    max_val, max_error);
         if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
           impl_test_axpby_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1d>,
               view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, true, max_val,
-                                                      max_error);
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, true,
+                                                      max_val, max_error);
         }
       }
     }
@@ -925,14 +927,14 @@ void impl_test_axpby_unification(int const N) {
           impl_test_axpby_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1d>,
               view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, false, max_val,
-                                                      max_error);
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, false,
+                                                      max_val, max_error);
           if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
             impl_test_axpby_unification_compare<
                 tScalarA, view_stride_adapter<ViewTypeAr1d>,
                 view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
-                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, true, max_val,
-                                                        max_error);
+                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, true,
+                                                        max_val, max_error);
           }
         }
       }
@@ -964,8 +966,9 @@ void impl_test_axpby_unification(int const N) {
           impl_test_axpby_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1d>,
               view_stride_adapter<ViewTypeX>, tScalarB,
-              view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
-              Device>(a, x, b, y, N, true, max_val, max_error);
+              view_stride_adapter<ViewTypeBr1s_1>,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, true,
+                                                      max_val, max_error);
         }
       }
     }
@@ -1031,8 +1034,10 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
 
   using ViewTypeY = Kokkos::View<tScalarY**, tLayoutY, Device>;
 
-  std::array<tScalarA, 4> const valuesA{-1, Kokkos::ArithTraits<tScalarA>::zero(), 1, 3};
-  std::array<tScalarB, 4> const valuesB{-1, Kokkos::ArithTraits<tScalarB>::zero(), 1, 5};
+  std::array<tScalarA, 4> const valuesA{
+      -1, Kokkos::ArithTraits<tScalarA>::zero(), 1, 3};
+  std::array<tScalarB, 4> const valuesB{
+      -1, Kokkos::ArithTraits<tScalarB>::zero(), 1, 5};
 
   // eps should probably be based on tScalarB since that is the type
   // in which the result is computed.
@@ -1132,8 +1137,9 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
         if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, tScalarA, view_stride_adapter<ViewTypeX>, tScalarB,
-              view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
-              Device>(a, x, b, y, N, K, true, max_val, max_error);
+              view_stride_adapter<ViewTypeBr1s_1>,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true,
+                                                      max_val, max_error);
         }
       }
     }
@@ -1328,14 +1334,14 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
               view_stride_adapter<ViewTypeBr1s_1>,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
-                                                      max_error);
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false,
+                                                      max_val, max_error);
           if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
             impl_test_axpby_mv_unification_compare<
                 tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
                 view_stride_adapter<ViewTypeBr1s_1>,
-                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true, max_val,
-                                                        max_error);
+                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true,
+                                                        max_val, max_error);
           }
         }
       }
@@ -1374,8 +1380,8 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
               view_stride_adapter<ViewTypeBr1s_k>,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
-                                                      max_error);
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false,
+                                                      max_val, max_error);
         }
       }
     }
@@ -1407,8 +1413,9 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
             impl_test_axpby_mv_unification_compare<
                 tScalarA, ViewTypeAr0, view_stride_adapter<ViewTypeX>, tScalarB,
-                view_stride_adapter<ViewTypeBr1d>, view_stride_adapter<ViewTypeY>,
-                Device>(a, x, b, y, N, K, true, max_val, max_error);
+                view_stride_adapter<ViewTypeBr1d>,
+                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true,
+                                                        max_val, max_error);
           }
         }
       }
@@ -1472,14 +1479,14 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
         impl_test_axpby_mv_unification_compare<
             tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
             view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
-            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
-                                                    max_error);
+            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false,
+                                                    max_val, max_error);
         if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
               view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true, max_val,
-                                                      max_error);
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true,
+                                                      max_val, max_error);
         }
       }
     }
@@ -1507,14 +1514,14 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
               view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
-                                                      max_error);
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false,
+                                                      max_val, max_error);
           if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
             impl_test_axpby_mv_unification_compare<
                 tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
                 view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
-                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true, max_val,
-                                                        max_error);
+                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true,
+                                                        max_val, max_error);
           }
         }
       }
@@ -1546,8 +1553,9 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1s_1>,
               view_stride_adapter<ViewTypeX>, tScalarB,
-              view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
-              Device>(a, x, b, y, N, K, true, max_val, max_error);
+              view_stride_adapter<ViewTypeBr1s_1>,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true,
+                                                      max_val, max_error);
         }
       }
     }
@@ -1684,14 +1692,14 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
         impl_test_axpby_mv_unification_compare<
             tScalarA, view_stride_adapter<ViewTypeAr1s_k>,
             view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
-            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
-                                                    max_error);
+            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false,
+                                                    max_val, max_error);
         if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1s_k>,
               view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true, max_val,
-                                                      max_error);
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true,
+                                                      max_val, max_error);
         }
       }
     }
@@ -1729,14 +1737,14 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1s_k>,
               view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
-                                                      max_error);
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false,
+                                                      max_val, max_error);
           if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
             impl_test_axpby_mv_unification_compare<
                 tScalarA, view_stride_adapter<ViewTypeAr1s_k>,
                 view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
-                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true, max_val,
-                                                        max_error);
+                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true,
+                                                        max_val, max_error);
           }
         }
       }
@@ -1778,8 +1786,9 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1s_k>,
               view_stride_adapter<ViewTypeX>, tScalarB,
-              view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
-              Device>(a, x, b, y, N, K, true, max_val, max_error);
+              view_stride_adapter<ViewTypeBr1s_1>,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true,
+                                                      max_val, max_error);
         }
       }
     }
@@ -1939,14 +1948,14 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
         impl_test_axpby_mv_unification_compare<
             tScalarA, view_stride_adapter<ViewTypeAr1d>,
             view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
-            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
-                                                    max_error);
+            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false,
+                                                    max_val, max_error);
         if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1d>,
               view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true, max_val,
-                                                      max_error);
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true,
+                                                      max_val, max_error);
         }
       }
     }
@@ -1974,14 +1983,14 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1d>,
               view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
-                                                      max_error);
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false,
+                                                      max_val, max_error);
           if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
             impl_test_axpby_mv_unification_compare<
                 tScalarA, view_stride_adapter<ViewTypeAr1d>,
                 view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
-                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true, max_val,
-                                                        max_error);
+                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true,
+                                                        max_val, max_error);
           }
         }
       }
@@ -2013,8 +2022,9 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1d>,
               view_stride_adapter<ViewTypeX>, tScalarB,
-              view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
-              Device>(a, x, b, y, N, K, true, max_val, max_error);
+              view_stride_adapter<ViewTypeBr1s_1>,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true,
+                                                      max_val, max_error);
         }
       }
     }
@@ -2151,14 +2161,14 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
         impl_test_axpby_mv_unification_compare<
             tScalarA, view_stride_adapter<ViewTypeAr1d>,
             view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
-            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
-                                                    max_error);
+            view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false,
+                                                    max_val, max_error);
         if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1d>,
               view_stride_adapter<ViewTypeX>, tScalarB, tScalarB,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true, max_val,
-                                                      max_error);
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true,
+                                                      max_val, max_error);
         }
       }
     }
@@ -2196,14 +2206,14 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1d>,
               view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
-              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false, max_val,
-                                                      max_error);
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, false,
+                                                      max_val, max_error);
           if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
             impl_test_axpby_mv_unification_compare<
                 tScalarA, view_stride_adapter<ViewTypeAr1d>,
                 view_stride_adapter<ViewTypeX>, tScalarB, ViewTypeBr0,
-                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true, max_val,
-                                                        max_error);
+                view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true,
+                                                        max_val, max_error);
           }
         }
       }
@@ -2245,8 +2255,9 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
           impl_test_axpby_mv_unification_compare<
               tScalarA, view_stride_adapter<ViewTypeAr1d>,
               view_stride_adapter<ViewTypeX>, tScalarB,
-              view_stride_adapter<ViewTypeBr1s_1>, view_stride_adapter<ViewTypeY>,
-              Device>(a, x, b, y, N, K, true, max_val, max_error);
+              view_stride_adapter<ViewTypeBr1s_1>,
+              view_stride_adapter<ViewTypeY>, Device>(a, x, b, y, N, K, true,
+                                                      max_val, max_error);
         }
       }
     }
diff --git a/blas/unit_test/Test_Blas2_syr2.hpp b/blas/unit_test/Test_Blas2_syr2.hpp
index 11029b8778..a3b53129fe 100644
--- a/blas/unit_test/Test_Blas2_syr2.hpp
+++ b/blas/unit_test/Test_Blas2_syr2.hpp
@@ -207,8 +207,12 @@ Syr2Tester<ScalarX, tLayoutX, ScalarY, tLayoutY, ScalarA, tLayoutA,
       // large enough to require 'relTol' to value 5.0e-3. The same
       // calculations show no discrepancies for calculations with double.
       // ****************************************************************
-      _absTol(std::is_same<_AuxType, float>::value ? 1.0e-6 : (std::is_same<_AuxType, double>::value ? 1.0e-9 : 0)),
-      _relTol(std::is_same<_AuxType, float>::value ? 5.0e-3 : (std::is_same<_AuxType, double>::value ? 1.0e-6 : 0)),
+      _absTol(std::is_same<_AuxType, float>::value
+                  ? 1.0e-6
+                  : (std::is_same<_AuxType, double>::value ? 1.0e-9 : 0)),
+      _relTol(std::is_same<_AuxType, float>::value
+                  ? 5.0e-3
+                  : (std::is_same<_AuxType, double>::value ? 1.0e-6 : 0)),
       _M(-1),
       _N(-1),
       _useAnalyticalResults(false),

From 1624ffd2f698f5eb3ce435f80a9dde0a5878d6cb Mon Sep 17 00:00:00 2001
From: Ernesto Prudencio <eeprude@sandia.gov>
Date: Mon, 20 Nov 2023 18:09:16 -0700
Subject: [PATCH 05/14] mv_unification tests with double are failing by very
 small amounts, e.g. 5.9e-14 vs. 3.6e-14

---
 blas/unit_test/Test_Blas1_axpby_unification.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/blas/unit_test/Test_Blas1_axpby_unification.hpp b/blas/unit_test/Test_Blas1_axpby_unification.hpp
index 0457527718..73ad9653c7 100644
--- a/blas/unit_test/Test_Blas1_axpby_unification.hpp
+++ b/blas/unit_test/Test_Blas1_axpby_unification.hpp
@@ -1043,7 +1043,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // in which the result is computed.
   using MagnitudeB         = typename Kokkos::ArithTraits<tScalarB>::mag_type;
   MagnitudeB const eps     = Kokkos::ArithTraits<tScalarB>::epsilon();
-  MagnitudeB const max_val = 10;
+  MagnitudeB const max_val = 20;
   MagnitudeB const max_error =
       static_cast<MagnitudeB>(
           Kokkos::ArithTraits<tScalarA>::abs(valuesA[valuesA.size() - 1]) +

From af49d606f23bbdc2f56a5361002be0ca0703e447 Mon Sep 17 00:00:00 2001
From: Ernesto Prudencio <eeprude@sandia.gov>
Date: Tue, 21 Nov 2023 02:03:34 -0700
Subject: [PATCH 06/14] Trying one more increment on tolerance

---
 blas/unit_test/Test_Blas1_axpby_unification.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/blas/unit_test/Test_Blas1_axpby_unification.hpp b/blas/unit_test/Test_Blas1_axpby_unification.hpp
index 73ad9653c7..c75a4138cd 100644
--- a/blas/unit_test/Test_Blas1_axpby_unification.hpp
+++ b/blas/unit_test/Test_Blas1_axpby_unification.hpp
@@ -1043,7 +1043,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // in which the result is computed.
   using MagnitudeB         = typename Kokkos::ArithTraits<tScalarB>::mag_type;
   MagnitudeB const eps     = Kokkos::ArithTraits<tScalarB>::epsilon();
-  MagnitudeB const max_val = 20;
+  MagnitudeB const max_val = 40;
   MagnitudeB const max_error =
       static_cast<MagnitudeB>(
           Kokkos::ArithTraits<tScalarA>::abs(valuesA[valuesA.size() - 1]) +

From 091b3ab0899b08a77d1de257c0cb43ab9c14cebd Mon Sep 17 00:00:00 2001
From: Ernesto Prudencio <eeprude@sandia.gov>
Date: Tue, 21 Nov 2023 08:46:49 -0700
Subject: [PATCH 07/14] Putting pragma's and unrolls properly right before for
 loops (compilation warning at weaver)

---
 blas/impl/KokkosBlas1_axpby_mv_impl.hpp       | 85 ++++++++++++++-----
 .../Test_Blas1_axpby_unification.hpp          |  2 +-
 2 files changed, 66 insertions(+), 21 deletions(-)

diff --git a/blas/impl/KokkosBlas1_axpby_mv_impl.hpp b/blas/impl/KokkosBlas1_axpby_mv_impl.hpp
index e81728d3ba..7db7b0abe3 100644
--- a/blas/impl/KokkosBlas1_axpby_mv_impl.hpp
+++ b/blas/impl/KokkosBlas1_axpby_mv_impl.hpp
@@ -123,19 +123,25 @@ struct Axpby_MV_Functor {
         // Nothing to do: Y(i,j) := Y(i,j)
       } else if constexpr (scalar_y == 2) {
         if (m_b.extent(0) == 1) {
+          if (m_b(0) ==
+              Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
 #pragma ivdep
 #endif
 #ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
 #pragma vector always
 #endif
-          if (m_b(0) ==
-              Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
             for (size_type k = 0; k < numCols; ++k) {
               m_y(i, k) = Kokkos::ArithTraits<
                   typename YMV::non_const_value_type>::zero();
             }
           } else {
+#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
+#pragma ivdep
+#endif
+#ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
+#pragma vector always
+#endif
             for (size_type k = 0; k < numCols; ++k) {
               m_y(i, k) = m_b(0) * m_y(i, k);
             }
@@ -189,18 +195,24 @@ struct Axpby_MV_Functor {
         }
       } else if constexpr (scalar_y == 2) {
         if (m_b.extent(0) == 1) {
+          if (m_b(0) ==
+              Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
 #pragma ivdep
 #endif
 #ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
 #pragma vector always
 #endif
-          if (m_b(0) ==
-              Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
             for (size_type k = 0; k < numCols; ++k) {
               m_y(i, k) = -m_x(i, k);
             }
           } else {
+#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
+#pragma ivdep
+#endif
+#ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
+#pragma vector always
+#endif
             for (size_type k = 0; k < numCols; ++k) {
               m_y(i, k) = -m_x(i, k) + m_b(0) * m_y(i, k);
             }
@@ -254,18 +266,24 @@ struct Axpby_MV_Functor {
         }
       } else if constexpr (scalar_y == 2) {
         if (m_b.extent(0) == 1) {
+          if (m_b(0) ==
+              Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
 #pragma ivdep
 #endif
 #ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
 #pragma vector always
 #endif
-          if (m_b(0) ==
-              Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
             for (size_type k = 0; k < numCols; ++k) {
               m_y(i, k) = m_x(i, k);
             }
           } else {
+#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
+#pragma ivdep
+#endif
+#ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
+#pragma vector always
+#endif
             for (size_type k = 0; k < numCols; ++k) {
               m_y(i, k) = m_x(i, k) + m_b(0) * m_y(i, k);
             }
@@ -356,18 +374,24 @@ struct Axpby_MV_Functor {
       } else if constexpr (scalar_y == 2) {
         if (m_a.extent(0) == 1) {
           if (m_b.extent(0) == 1) {
+            if (m_b(0) == Kokkos::ArithTraits<
+                              typename BV::non_const_value_type>::zero()) {
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
 #pragma ivdep
 #endif
 #ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
 #pragma vector always
 #endif
-            if (m_b(0) == Kokkos::ArithTraits<
-                              typename BV::non_const_value_type>::zero()) {
               for (size_type k = 0; k < numCols; ++k) {
                 m_y(i, k) = m_a(0) * m_x(i, k);
               }
             } else {
+#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
+#pragma ivdep
+#endif
+#ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
+#pragma vector always
+#endif
               for (size_type k = 0; k < numCols; ++k) {
                 m_y(i, k) = m_a(0) * m_x(i, k) + m_b(0) * m_y(i, k);
               }
@@ -385,18 +409,24 @@ struct Axpby_MV_Functor {
           }
         } else {
           if (m_b.extent(0) == 1) {
+            if (m_b(0) == Kokkos::ArithTraits<
+                              typename BV::non_const_value_type>::zero()) {
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
 #pragma ivdep
 #endif
 #ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
 #pragma vector always
 #endif
-            if (m_b(0) == Kokkos::ArithTraits<
-                              typename BV::non_const_value_type>::zero()) {
               for (size_type k = 0; k < numCols; ++k) {
                 m_y(i, k) = m_a(k) * m_x(i, k);
               }
             } else {
+#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
+#pragma ivdep
+#endif
+#ifdef KOKKOS_ENABLE_PRAGMA_VECTOR
+#pragma vector always
+#endif
               for (size_type k = 0; k < numCols; ++k) {
                 m_y(i, k) = m_a(k) * m_x(i, k) + m_b(0) * m_y(i, k);
               }
@@ -751,16 +781,19 @@ struct Axpby_MV_Unroll_Functor {
         // Nothing to do: Y(i,j) := Y(i,j)
       } else if constexpr (scalar_y == 2) {
         if (m_b.extent(0) == 1) {
+          if (m_b(0) ==
+              Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
 #pragma unroll
 #endif
-          if (m_b(0) ==
-              Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
             for (int k = 0; k < UNROLL; ++k) {
               m_y(i, k) = Kokkos::ArithTraits<
                   typename YMV::non_const_value_type>::zero();
             }
           } else {
+#ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
+#pragma unroll
+#endif
             for (int k = 0; k < UNROLL; ++k) {
               m_y(i, k) = m_b(0) * m_y(i, k);
             }
@@ -802,15 +835,18 @@ struct Axpby_MV_Unroll_Functor {
         }
       } else if constexpr (scalar_y == 2) {
         if (m_b.extent(0) == 1) {
+          if (m_b(0) ==
+              Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
 #pragma unroll
 #endif
-          if (m_b(0) ==
-              Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
             for (int k = 0; k < UNROLL; ++k) {
               m_y(i, k) = -m_x(i, k);
             }
           } else {
+#ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
+#pragma unroll
+#endif
             for (int k = 0; k < UNROLL; ++k) {
               m_y(i, k) = -m_x(i, k) + m_b(0) * m_y(i, k);
             }
@@ -852,15 +888,18 @@ struct Axpby_MV_Unroll_Functor {
         }
       } else if constexpr (scalar_y == 2) {
         if (m_b.extent(0) == 1) {
+          if (m_b(0) ==
+              Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
 #pragma unroll
 #endif
-          if (m_b(0) ==
-              Kokkos::ArithTraits<typename BV::non_const_value_type>::zero()) {
             for (int k = 0; k < UNROLL; ++k) {
               m_y(i, k) = m_x(i, k);
             }
           } else {
+#ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
+#pragma unroll
+#endif
             for (int k = 0; k < UNROLL; ++k) {
               m_y(i, k) = m_x(i, k) + m_b(0) * m_y(i, k);
             }
@@ -930,15 +969,18 @@ struct Axpby_MV_Unroll_Functor {
       } else if constexpr (scalar_y == 2) {
         if (m_a.extent(0) == 1) {
           if (m_b.extent(0) == 1) {
+            if (m_b(0) == Kokkos::ArithTraits<
+                              typename BV::non_const_value_type>::zero()) {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
 #pragma unroll
 #endif
-            if (m_b(0) == Kokkos::ArithTraits<
-                              typename BV::non_const_value_type>::zero()) {
               for (int k = 0; k < UNROLL; ++k) {
                 m_y(i, k) = m_a(0) * m_x(i, k);
               }
             } else {
+#ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
+#pragma unroll
+#endif
               for (int k = 0; k < UNROLL; ++k) {
                 m_y(i, k) = m_a(0) * m_x(i, k) + m_b(0) * m_y(i, k);
               }
@@ -953,15 +995,18 @@ struct Axpby_MV_Unroll_Functor {
           }
         } else {
           if (m_b.extent(0) == 1) {
+            if (m_b(0) == Kokkos::ArithTraits<
+                              typename BV::non_const_value_type>::zero()) {
 #ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
 #pragma unroll
 #endif
-            if (m_b(0) == Kokkos::ArithTraits<
-                              typename BV::non_const_value_type>::zero()) {
               for (int k = 0; k < UNROLL; ++k) {
                 m_y(i, k) = m_a(k) * m_x(i, k);
               }
             } else {
+#ifdef KOKKOS_ENABLE_PRAGMA_UNROLL
+#pragma unroll
+#endif
               for (int k = 0; k < UNROLL; ++k) {
                 m_y(i, k) = m_a(k) * m_x(i, k) + m_b(0) * m_y(i, k);
               }
diff --git a/blas/unit_test/Test_Blas1_axpby_unification.hpp b/blas/unit_test/Test_Blas1_axpby_unification.hpp
index c75a4138cd..0457527718 100644
--- a/blas/unit_test/Test_Blas1_axpby_unification.hpp
+++ b/blas/unit_test/Test_Blas1_axpby_unification.hpp
@@ -1043,7 +1043,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // in which the result is computed.
   using MagnitudeB         = typename Kokkos::ArithTraits<tScalarB>::mag_type;
   MagnitudeB const eps     = Kokkos::ArithTraits<tScalarB>::epsilon();
-  MagnitudeB const max_val = 40;
+  MagnitudeB const max_val = 10;
   MagnitudeB const max_error =
       static_cast<MagnitudeB>(
           Kokkos::ArithTraits<tScalarA>::abs(valuesA[valuesA.size() - 1]) +

From fc3d24a3a4056d825bc95d37df1f8c725b8a30f9 Mon Sep 17 00:00:00 2001
From: Ernesto Prudencio <eeprude@sandia.gov>
Date: Tue, 21 Nov 2023 11:22:41 -0700
Subject: [PATCH 08/14] Giving it another try to larger tolarance, after fixing
 the warning on pragma and unroll

---
 blas/unit_test/Test_Blas1_axpby_unification.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/blas/unit_test/Test_Blas1_axpby_unification.hpp b/blas/unit_test/Test_Blas1_axpby_unification.hpp
index 0457527718..c75a4138cd 100644
--- a/blas/unit_test/Test_Blas1_axpby_unification.hpp
+++ b/blas/unit_test/Test_Blas1_axpby_unification.hpp
@@ -1043,7 +1043,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // in which the result is computed.
   using MagnitudeB         = typename Kokkos::ArithTraits<tScalarB>::mag_type;
   MagnitudeB const eps     = Kokkos::ArithTraits<tScalarB>::epsilon();
-  MagnitudeB const max_val = 10;
+  MagnitudeB const max_val = 40;
   MagnitudeB const max_error =
       static_cast<MagnitudeB>(
           Kokkos::ArithTraits<tScalarA>::abs(valuesA[valuesA.size() - 1]) +

From fbaac455a8c56000c318b38491650444f08e3cf6 Mon Sep 17 00:00:00 2001
From: Ernesto Prudencio <eeprude@sandia.gov>
Date: Wed, 22 Nov 2023 14:46:22 -0700
Subject: [PATCH 09/14] Another attempt while waiting to get access to the solo
 cluster

---
 .../Test_Blas1_axpby_unification.hpp          | 44 ++++++++++++++-----
 1 file changed, 34 insertions(+), 10 deletions(-)

diff --git a/blas/unit_test/Test_Blas1_axpby_unification.hpp b/blas/unit_test/Test_Blas1_axpby_unification.hpp
index c75a4138cd..ae04b357fa 100644
--- a/blas/unit_test/Test_Blas1_axpby_unification.hpp
+++ b/blas/unit_test/Test_Blas1_axpby_unification.hpp
@@ -356,23 +356,47 @@ void impl_test_axpby_mv_unification_compare(
             (void)valueB;  // Avoid "set but not used" error
             int a_k(a.h_view.extent(0) == 1 ? 0 : k);
             int b_k(b.h_view.extent(0) == 1 ? 0 : k);
-            vanillaValue =
-                static_cast<ScalarTypeY>(a.h_view(a_k) * x.h_view(i, k) +
-                                         b.h_view(b_k) * org_y.h_view(i, k));
+            if (b.h_view(b_k) == Kokkos::ArithTraits<tScalarB>::zero()) {
+              vanillaValue =
+                  static_cast<ScalarTypeY>(a.h_view(a_k) * x.h_view(i, k));
+            }
+            else {
+              vanillaValue =
+                  static_cast<ScalarTypeY>(a.h_view(a_k) * x.h_view(i, k) +
+                                           b.h_view(b_k) * org_y.h_view(i, k));
+            }
           } else {
             int a_k(a.h_view.extent(0) == 1 ? 0 : k);
-            vanillaValue = static_cast<ScalarTypeY>(
-                a.h_view(a_k) * x.h_view(i, k) + valueB * org_y.h_view(i, k));
+            if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+              vanillaValue = static_cast<ScalarTypeY>(
+                  a.h_view(a_k) * x.h_view(i, k));
+            }
+            else {
+              vanillaValue = static_cast<ScalarTypeY>(
+                  a.h_view(a_k) * x.h_view(i, k) + valueB * org_y.h_view(i, k));
+            }
           }
         } else {
           if constexpr (bIsRank1) {
             (void)valueB;  // Avoid "set but not used" error
             int b_k(b.h_view.extent(0) == 1 ? 0 : k);
-            vanillaValue = static_cast<ScalarTypeY>(
-                valueA * x.h_view(i, k) + b.h_view(b_k) * org_y.h_view(i, k));
+            if (b.h_view(b_k) == Kokkos::ArithTraits<tScalarB>::zero()) {
+              vanillaValue = static_cast<ScalarTypeY>(
+                  valueA * x.h_view(i, k) + b.h_view(b_k) * org_y.h_view(i, k));
+            }
+            else {
+              vanillaValue = static_cast<ScalarTypeY>(
+                  valueA * x.h_view(i, k));
+            }
           } else {
-            vanillaValue = static_cast<ScalarTypeY>(
-                valueA * x.h_view(i, k) + valueB * org_y.h_view(i, k));
+            if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
+              vanillaValue = static_cast<ScalarTypeY>(
+                  valueA * x.h_view(i, k));
+            }
+            else {
+              vanillaValue = static_cast<ScalarTypeY>(
+                  valueA * x.h_view(i, k) + valueB * org_y.h_view(i, k));
+            }
           }
         }
 
@@ -1043,7 +1067,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // in which the result is computed.
   using MagnitudeB         = typename Kokkos::ArithTraits<tScalarB>::mag_type;
   MagnitudeB const eps     = Kokkos::ArithTraits<tScalarB>::epsilon();
-  MagnitudeB const max_val = 40;
+  MagnitudeB const max_val = 100;
   MagnitudeB const max_error =
       static_cast<MagnitudeB>(
           Kokkos::ArithTraits<tScalarA>::abs(valuesA[valuesA.size() - 1]) +

From 9285b6a8ce5265426a300e1684c50b42278345b0 Mon Sep 17 00:00:00 2001
From: Ernesto Prudencio <eeprude@sandia.gov>
Date: Wed, 22 Nov 2023 14:49:09 -0700
Subject: [PATCH 10/14] Formatting

---
 .../Test_Blas1_axpby_unification.hpp          | 22 +++++++------------
 1 file changed, 8 insertions(+), 14 deletions(-)

diff --git a/blas/unit_test/Test_Blas1_axpby_unification.hpp b/blas/unit_test/Test_Blas1_axpby_unification.hpp
index ae04b357fa..615ae1602a 100644
--- a/blas/unit_test/Test_Blas1_axpby_unification.hpp
+++ b/blas/unit_test/Test_Blas1_axpby_unification.hpp
@@ -359,8 +359,7 @@ void impl_test_axpby_mv_unification_compare(
             if (b.h_view(b_k) == Kokkos::ArithTraits<tScalarB>::zero()) {
               vanillaValue =
                   static_cast<ScalarTypeY>(a.h_view(a_k) * x.h_view(i, k));
-            }
-            else {
+            } else {
               vanillaValue =
                   static_cast<ScalarTypeY>(a.h_view(a_k) * x.h_view(i, k) +
                                            b.h_view(b_k) * org_y.h_view(i, k));
@@ -368,10 +367,9 @@ void impl_test_axpby_mv_unification_compare(
           } else {
             int a_k(a.h_view.extent(0) == 1 ? 0 : k);
             if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
-              vanillaValue = static_cast<ScalarTypeY>(
-                  a.h_view(a_k) * x.h_view(i, k));
-            }
-            else {
+              vanillaValue =
+                  static_cast<ScalarTypeY>(a.h_view(a_k) * x.h_view(i, k));
+            } else {
               vanillaValue = static_cast<ScalarTypeY>(
                   a.h_view(a_k) * x.h_view(i, k) + valueB * org_y.h_view(i, k));
             }
@@ -383,17 +381,13 @@ void impl_test_axpby_mv_unification_compare(
             if (b.h_view(b_k) == Kokkos::ArithTraits<tScalarB>::zero()) {
               vanillaValue = static_cast<ScalarTypeY>(
                   valueA * x.h_view(i, k) + b.h_view(b_k) * org_y.h_view(i, k));
-            }
-            else {
-              vanillaValue = static_cast<ScalarTypeY>(
-                  valueA * x.h_view(i, k));
+            } else {
+              vanillaValue = static_cast<ScalarTypeY>(valueA * x.h_view(i, k));
             }
           } else {
             if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
-              vanillaValue = static_cast<ScalarTypeY>(
-                  valueA * x.h_view(i, k));
-            }
-            else {
+              vanillaValue = static_cast<ScalarTypeY>(valueA * x.h_view(i, k));
+            } else {
               vanillaValue = static_cast<ScalarTypeY>(
                   valueA * x.h_view(i, k) + valueB * org_y.h_view(i, k));
             }

From 88cec7bda914fb6884ec60761aa9e373ef85bdd0 Mon Sep 17 00:00:00 2001
From: Ernesto Prudencio <eeprude@sandia.gov>
Date: Wed, 22 Nov 2023 15:12:24 -0700
Subject: [PATCH 11/14] Correction error from the last commit

---
 blas/unit_test/Test_Blas1_axpby_unification.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/blas/unit_test/Test_Blas1_axpby_unification.hpp b/blas/unit_test/Test_Blas1_axpby_unification.hpp
index 615ae1602a..92b3769b8f 100644
--- a/blas/unit_test/Test_Blas1_axpby_unification.hpp
+++ b/blas/unit_test/Test_Blas1_axpby_unification.hpp
@@ -379,10 +379,10 @@ void impl_test_axpby_mv_unification_compare(
             (void)valueB;  // Avoid "set but not used" error
             int b_k(b.h_view.extent(0) == 1 ? 0 : k);
             if (b.h_view(b_k) == Kokkos::ArithTraits<tScalarB>::zero()) {
+              vanillaValue = static_cast<ScalarTypeY>(valueA * x.h_view(i, k));
+            } else {
               vanillaValue = static_cast<ScalarTypeY>(
                   valueA * x.h_view(i, k) + b.h_view(b_k) * org_y.h_view(i, k));
-            } else {
-              vanillaValue = static_cast<ScalarTypeY>(valueA * x.h_view(i, k));
             }
           } else {
             if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {

From 4450d204e181ba25a16c00fd007d923e219546ad Mon Sep 17 00:00:00 2001
From: Ernesto Prudencio <eeprude@sandia.gov>
Date: Wed, 22 Nov 2023 21:45:59 -0700
Subject: [PATCH 12/14] Fixing the error that was happening only at the solo
 cluster

---
 .../Test_Blas1_axpby_unification.hpp          | 72 +++++++++++--------
 1 file changed, 41 insertions(+), 31 deletions(-)

diff --git a/blas/unit_test/Test_Blas1_axpby_unification.hpp b/blas/unit_test/Test_Blas1_axpby_unification.hpp
index 92b3769b8f..d33cfd55ad 100644
--- a/blas/unit_test/Test_Blas1_axpby_unification.hpp
+++ b/blas/unit_test/Test_Blas1_axpby_unification.hpp
@@ -356,45 +356,48 @@ void impl_test_axpby_mv_unification_compare(
             (void)valueB;  // Avoid "set but not used" error
             int a_k(a.h_view.extent(0) == 1 ? 0 : k);
             int b_k(b.h_view.extent(0) == 1 ? 0 : k);
-            if (b.h_view(b_k) == Kokkos::ArithTraits<tScalarB>::zero()) {
-              vanillaValue =
-                  static_cast<ScalarTypeY>(a.h_view(a_k) * x.h_view(i, k));
-            } else {
-              vanillaValue =
-                  static_cast<ScalarTypeY>(a.h_view(a_k) * x.h_view(i, k) +
-                                           b.h_view(b_k) * org_y.h_view(i, k));
-            }
+#if 0
+            std::cout << "In impl_test_axpby_mv_unification_compare()"
+                      << ": i = " << i
+                      << ", k = " << k
+                      << ", a.h_view.extent(0) = " << a.h_view.extent(0)
+                      << ", a_k = "                << a_k
+                      << ", b.h_view.extent(0) = " << b.h_view.extent(0)
+                      << ", b_k = "                << b_k
+                      << ", a.h_view(a_k) = "      << a.h_view(a_k)
+                      << ", x.h_view(i, k) = "     << x.h_view(i, k)
+                      << ", b.h_view(b_k) = "      << b.h_view(b_k)
+                      << ", org_y.h_view(i, k) = " << org_y.h_view(i, k)
+                      << std::endl;
+#endif
+            vanillaValue =
+                static_cast<ScalarTypeY>(a.h_view(a_k) * x.h_view(i, k) +
+                                         b.h_view(b_k) * org_y.h_view(i, k));
           } else {
             int a_k(a.h_view.extent(0) == 1 ? 0 : k);
-            if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
-              vanillaValue =
-                  static_cast<ScalarTypeY>(a.h_view(a_k) * x.h_view(i, k));
-            } else {
-              vanillaValue = static_cast<ScalarTypeY>(
-                  a.h_view(a_k) * x.h_view(i, k) + valueB * org_y.h_view(i, k));
-            }
+            vanillaValue = static_cast<ScalarTypeY>(
+                a.h_view(a_k) * x.h_view(i, k) + valueB * org_y.h_view(i, k));
           }
         } else {
           if constexpr (bIsRank1) {
             (void)valueB;  // Avoid "set but not used" error
             int b_k(b.h_view.extent(0) == 1 ? 0 : k);
-            if (b.h_view(b_k) == Kokkos::ArithTraits<tScalarB>::zero()) {
-              vanillaValue = static_cast<ScalarTypeY>(valueA * x.h_view(i, k));
-            } else {
-              vanillaValue = static_cast<ScalarTypeY>(
-                  valueA * x.h_view(i, k) + b.h_view(b_k) * org_y.h_view(i, k));
-            }
+            vanillaValue = static_cast<ScalarTypeY>(
+                valueA * x.h_view(i, k) + b.h_view(b_k) * org_y.h_view(i, k));
           } else {
-            if (valueB == Kokkos::ArithTraits<tScalarB>::zero()) {
-              vanillaValue = static_cast<ScalarTypeY>(valueA * x.h_view(i, k));
-            } else {
-              vanillaValue = static_cast<ScalarTypeY>(
-                  valueA * x.h_view(i, k) + valueB * org_y.h_view(i, k));
-            }
+            vanillaValue = static_cast<ScalarTypeY>(
+                valueA * x.h_view(i, k) + valueB * org_y.h_view(i, k));
           }
         }
-
-        EXPECT_NEAR_KK(vanillaValue, y.h_view(i, k), 2. * max_error);
+#if 0
+        std::cout << "In impl_test_axpby_mv_unification_compare(1)"
+                  << ": i = " << i
+                  << ", k = " << k
+                  << ", y.h_view(i, k) = " << y.h_view(i, k)
+                  << ", vanillaValue = "   << vanillaValue
+                  << std::endl;
+#endif
+        EXPECT_NEAR_KK(vanillaValue, y.h_view(i, k), 3. * max_error);
       }
     }
   } else {
@@ -451,7 +454,14 @@ void impl_test_axpby_mv_unification_compare(
         } else {
           EXPECT_NE(y.h_view(i, k), Kokkos::ArithTraits<ScalarTypeY>::nan());
         }
-
+#if 0
+        std::cout << "In impl_test_axpby_mv_unification_compare(2)"
+                  << ": i = " << i
+                  << ", k = " << k
+                  << ", y.h_view(i, k) = " << y.h_view(i, k)
+                  << ", vanillaValue = "   << vanillaValue
+                  << std::endl;
+#endif
         EXPECT_NEAR_KK(vanillaValue, y.h_view(i, k), 2. * max_error);
       }
     }
@@ -1061,7 +1071,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // in which the result is computed.
   using MagnitudeB         = typename Kokkos::ArithTraits<tScalarB>::mag_type;
   MagnitudeB const eps     = Kokkos::ArithTraits<tScalarB>::epsilon();
-  MagnitudeB const max_val = 100;
+  MagnitudeB const max_val = 10;
   MagnitudeB const max_error =
       static_cast<MagnitudeB>(
           Kokkos::ArithTraits<tScalarA>::abs(valuesA[valuesA.size() - 1]) +

From 9105a8a059358a2901b92b026ce31c57982e161d Mon Sep 17 00:00:00 2001
From: Ernesto Prudencio <eeprude@sandia.gov>
Date: Wed, 22 Nov 2023 23:40:03 -0700
Subject: [PATCH 13/14] Increase tolerance a bit more

---
 blas/unit_test/Test_Blas1_axpby_unification.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/blas/unit_test/Test_Blas1_axpby_unification.hpp b/blas/unit_test/Test_Blas1_axpby_unification.hpp
index d33cfd55ad..2284f28586 100644
--- a/blas/unit_test/Test_Blas1_axpby_unification.hpp
+++ b/blas/unit_test/Test_Blas1_axpby_unification.hpp
@@ -397,7 +397,7 @@ void impl_test_axpby_mv_unification_compare(
                   << ", vanillaValue = "   << vanillaValue
                   << std::endl;
 #endif
-        EXPECT_NEAR_KK(vanillaValue, y.h_view(i, k), 3. * max_error);
+        EXPECT_NEAR_KK(vanillaValue, y.h_view(i, k), 4. * max_error);
       }
     }
   } else {

From baab6f59fe26b1860d417477051c8703daa8d8b2 Mon Sep 17 00:00:00 2001
From: Ernesto Prudencio <eeprude@sandia.gov>
Date: Thu, 23 Nov 2023 02:10:53 -0700
Subject: [PATCH 14/14] ncreasing tolerances in all 4 locations

---
 blas/unit_test/Test_Blas1_axpby_unification.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/blas/unit_test/Test_Blas1_axpby_unification.hpp b/blas/unit_test/Test_Blas1_axpby_unification.hpp
index 2284f28586..9709d580b3 100644
--- a/blas/unit_test/Test_Blas1_axpby_unification.hpp
+++ b/blas/unit_test/Test_Blas1_axpby_unification.hpp
@@ -191,7 +191,7 @@ void impl_test_axpby_unification_compare(
     for (int i(0); i < N; ++i) {
       EXPECT_NEAR_KK(static_cast<ScalarTypeY>(valueA * x.h_view(i) +
                                               valueB * org_y.h_view(i)),
-                     y.h_view(i), 2. * max_error);
+                     y.h_view(i), 4. * max_error);
     }
   } else {
     // ********************************************************
@@ -221,7 +221,7 @@ void impl_test_axpby_unification_compare(
         EXPECT_NE(y.h_view(i), Kokkos::ArithTraits<ScalarTypeY>::nan());
       }
       EXPECT_NEAR_KK(static_cast<ScalarTypeY>(valueA * x.h_view(i)),
-                     y.h_view(i), 2. * max_error);
+                     y.h_view(i), 4. * max_error);
     }
   }
 }
@@ -462,7 +462,7 @@ void impl_test_axpby_mv_unification_compare(
                   << ", vanillaValue = "   << vanillaValue
                   << std::endl;
 #endif
-        EXPECT_NEAR_KK(vanillaValue, y.h_view(i, k), 2. * max_error);
+        EXPECT_NEAR_KK(vanillaValue, y.h_view(i, k), 4. * max_error);
       }
     }
   }