tpetra: update ArithTraits namespace for KOKKOS_VERSION > 40799

Compatibility update corresponding to kokkos/kokkos-kernels#2771

Signed-off-by: Nathan Ellingwood <ndellin@sandia.gov>

Author: ndellingwood

packages/tpetra/core/example/advanced/Benchmarks/blockCrsMatrixMatVec.cpp

@@ -44,7 +44,11 @@ void localApplyBlockNoTrans(Tpetra::BlockCrsMatrix<Scalar, LO, GO, Node>& A,
   typedef Tpetra::BlockCrsMatrix<Scalar, LO, GO, Node>
       block_crs_matrix_type;
   typedef typename block_crs_matrix_type::impl_scalar_type IST;
+#if KOKKOS_VERSION > 40799
+  typedef KokkosKernels::ArithTraits<IST> KAT;
+#else
   typedef Kokkos::ArithTraits<IST> KAT;
+#endif
   typedef typename block_crs_matrix_type::little_vec_type little_vec_type;
   typedef typename block_crs_matrix_type::little_block_type little_blk_type;
 
@@ -449,7 +453,11 @@ getTpetraBlockCrsMatrix(Teuchos::FancyOStream& out,
   using Teuchos::rcp;
   typedef Tpetra::BlockCrsMatrix<> matrix_type;
   typedef matrix_type::impl_scalar_type SC;
+#if KOKKOS_VERSION > 40799
+  typedef KokkosKernels::ArithTraits<SC> KAT;
+#else
   typedef Kokkos::ArithTraits<SC> KAT;
+#endif
   typedef Tpetra::Map<>::local_ordinal_type LO;
 
   // mfh 02 Jun 2016: Prefer Kokkos::Serial to the host_mirror_type as the

packages/tpetra/core/inout/Tpetra_Details_CooMatrix.hpp

@@ -621,13 +621,21 @@ class CooMatrix : public ::Tpetra::DistObject<char, LO, GO, NT> {
   void
   buildCrs(::Kokkos::View<OffsetType*, device_type>& rowOffsets,
            ::Kokkos::View<GO*, device_type>& gblColInds,
+#if KOKKOS_VERSION > 40799
+           ::Kokkos::View<typename ::KokkosKernels::ArithTraits<SC>::val_type*, device_type>& vals) {
+#else
            ::Kokkos::View<typename ::Kokkos::ArithTraits<SC>::val_type*, device_type>& vals) {
+#endif
     static_assert(std::is_integral<OffsetType>::value,
                   "OffsetType must be a built-in integer type.");
     using ::Kokkos::create_mirror_view;
     using ::Kokkos::deep_copy;
     using ::Kokkos::View;
+#if KOKKOS_VERSION > 40799
+    typedef typename ::KokkosKernels::ArithTraits<SC>::val_type ISC;
+#else
     typedef typename ::Kokkos::ArithTraits<SC>::val_type ISC;
+#endif
 
     const std::size_t numEnt = this->getLclNumEntries();
 

packages/tpetra/core/inout/Tpetra_Details_ReadTriples.hpp

@@ -21,7 +21,11 @@
 
 #include "TpetraCore_config.h"
 #include "Tpetra_Details_PackTriples.hpp"
+#if KOKKOS_VERSION > 40799
+#include "KokkosKernels_ArithTraits.hpp"
+#else
 #include "Kokkos_ArithTraits.hpp"
+#endif
 #include "Teuchos_MatrixMarket_generic.hpp"
 #include "Teuchos_CommHelpers.hpp"
 #include <iostream>
@@ -133,7 +137,11 @@ bool readComplexData(std::istream& istr,
 /// \tparam isComplex Whether SC is a complex-valued type.
 template <class SC,
           class GO,
+#if KOKKOS_VERSION > 40799
+          const bool isComplex = ::KokkosKernels::ArithTraits<SC>::is_complex>
+#else
           const bool isComplex = ::Kokkos::ArithTraits<SC>::is_complex>
+#endif
 struct ReadLine {
   /// \brief Take a line from the Matrix Market file or input stream,
   ///   and process the sparse matrix entry in that line.
@@ -201,7 +209,11 @@ struct ReadLine<SC, GO, true> {
            std::ostream* errStrm = NULL,
            const bool debug      = false) {
     using ::Teuchos::MatrixMarket::checkCommentLine;
+#if KOKKOS_VERSION > 40799
+    typedef typename ::KokkosKernels::ArithTraits<SC>::mag_type real_type;
+#else
     typedef typename ::Kokkos::ArithTraits<SC>::mag_type real_type;
+#endif
     using std::endl;
 
     GO rowInd, colInd;
@@ -530,7 +542,11 @@ int readAndSendOneBatchOfTriples(std::istream& inputStream,
   using ::Tpetra::Details::packTriples;
   using ::Tpetra::Details::packTriplesCount;
 
+#if KOKKOS_VERSION > 40799
+  using ::KokkosKernels::ArithTraits;
+#else
   using ::Kokkos::ArithTraits;
+#endif
   // constexpr int sizeTag = 42 + (ArithTraits<SC>::is_complex ? 100 : 0);
   // constexpr int msgTag = 43 + (ArithTraits<SC>::is_complex ? 100 : 0);
   constexpr int sizeTag = 42;
@@ -764,7 +780,11 @@ int recvOneBatchOfTriples(std::vector<GO>& rowInds,
                           const bool tolerant   = false,
                           std::ostream* errStrm = NULL,
                           const bool debug      = false) {
+#if KOKKOS_VERSION > 40799
+  using ::KokkosKernels::ArithTraits;
+#else
   using ::Kokkos::ArithTraits;
+#endif
   using ::Tpetra::Details::unpackTriples;
   using ::Tpetra::Details::unpackTriplesCount;
 
@@ -886,7 +906,11 @@ int readAndDealOutTriples(std::istream& inputStream,     // only valid on Proc 0
                           const bool tolerant   = false,
                           std::ostream* errStrm = NULL,
                           const bool debug      = false) {
+#if KOKKOS_VERSION > 40799
+  using KokkosKernels::ArithTraits;
+#else
   using Kokkos::ArithTraits;
+#endif
   using std::endl;
   using std::size_t;
 

packages/tpetra/core/src/Tpetra_BlockCrsMatrix_Helpers_def.hpp

@@ -814,8 +814,16 @@ unfillFormerBlockCrs(const Tpetra::CrsMatrix<Scalar, LO, GO, Node> &pointMatrix)
   using dev_row_view_t  = typename crs_t::local_graph_device_type::row_map_type::non_const_type;
   using dev_col_view_t  = typename crs_t::local_graph_device_type::entries_type::non_const_type;
   using dev_val_view_t  = typename crs_t::local_matrix_device_type::values_type::non_const_type;
+#if KOKKOS_VERSION > 40799
+  using impl_scalar_t   = typename KokkosKernels::ArithTraits<Scalar>::val_type;
+#else
   using impl_scalar_t   = typename Kokkos::ArithTraits<Scalar>::val_type;
+#endif
+#if KOKKOS_VERSION > 40799
+  using STS             = KokkosKernels::ArithTraits<impl_scalar_t>;
+#else
   using STS             = Kokkos::ArithTraits<impl_scalar_t>;
+#endif
   using Ordinal         = typename dev_row_view_t::non_const_value_type;
   using execution_space = typename Node::execution_space;
   using range_type      = Kokkos::RangePolicy<execution_space, size_t>;

packages/tpetra/core/src/Tpetra_BlockMultiVector_def.hpp

@@ -528,7 +528,11 @@ struct BlockWiseMultiply {
 
   KOKKOS_INLINE_FUNCTION
   void operator()(const Size k) const {
+#if KOKKOS_VERSION > 40799
+    const auto zero     = KokkosKernels::ArithTraits<Scalar>::zero();
+#else
     const auto zero     = Kokkos::ArithTraits<Scalar>::zero();
+#endif
     auto D_curBlk       = Kokkos::subview(D_, k, Kokkos::ALL(), Kokkos::ALL());
     const auto num_vecs = X_.extent(1);
     for (Size i = 0; i < num_vecs; ++i) {
@@ -606,7 +610,11 @@ class BlockJacobiUpdate {
     using Kokkos::ALL;
     using Kokkos::subview;
     typedef Kokkos::pair<LO, LO> range_type;
+#if KOKKOS_VERSION > 40799
+    typedef KokkosKernels::ArithTraits<Scalar> KAT;
+#else
     typedef Kokkos::ArithTraits<Scalar> KAT;
+#endif
 
     // We only have to implement the alpha != 0 case.
 

packages/tpetra/core/src/Tpetra_BlockView.hpp

@@ -19,7 +19,11 @@
 /// Tpetra::BlockCrsMatrix.
 
 #include "TpetraCore_config.h"
+#if KOKKOS_VERSION > 40799
+#include "KokkosKernels_ArithTraits.hpp"
+#else
 #include "Kokkos_ArithTraits.hpp"
+#endif
 #include "Kokkos_Complex.hpp"
 
 namespace Tpetra {
@@ -64,7 +68,11 @@ struct AbsMax<ViewType1, ViewType2, 2> {
     typedef typename std::decay<decltype(X(0, 0))>::type STX;
     static_assert(std::is_same<STX, STY>::value,
                   "AbsMax: The type of each entry of X and Y must be the same.");
+#if KOKKOS_VERSION > 40799
+    typedef KokkosKernels::ArithTraits<STY> KAT;
+#else
     typedef Kokkos::ArithTraits<STY> KAT;
+#endif
 
     const int numCols = Y.extent(1);
     const int numRows = Y.extent(0);
@@ -102,7 +110,11 @@ struct AbsMax<ViewType1, ViewType2, 1> {
     typedef typename std::remove_const<typename std::remove_reference<decltype(X(0))>::type>::type STX;
     static_assert(std::is_same<STX, STY>::value,
                   "AbsMax: The type of each entry of X and Y must be the same.");
+#if KOKKOS_VERSION > 40799
+    typedef KokkosKernels::ArithTraits<STY> KAT;
+#else
     typedef Kokkos::ArithTraits<STY> KAT;
+#endif
 
     const int numRows = Y.extent(0);
     for (int i = 0; i < numRows; ++i) {
@@ -288,12 +300,20 @@ struct AXPY<CoefficientType, ViewType1, ViewType2, IndexType, false, 1> {
   run(const CoefficientType& alpha,
       const ViewType1& x,
       const ViewType2& y) {
+#if KOKKOS_VERSION > 40799
+    using KokkosKernels::ArithTraits;
+#else
     using Kokkos::ArithTraits;
+#endif
     static_assert(static_cast<int>(ViewType1::rank) == static_cast<int>(ViewType2::rank),
                   "AXPY: x and y must have the same rank.");
 
     const IndexType numRows = static_cast<IndexType>(y.extent(0));
+#if KOKKOS_VERSION > 40799
+    if (alpha !Kernels= ArithTraits<CoefficientType>::zero()) {
+#else
     if (alpha != ArithTraits<CoefficientType>::zero()) {
+#endif
       /// general case
       for (IndexType i = 0; i < numRows; ++i)
         y(i) += alpha * x(i);
@@ -313,13 +333,21 @@ struct AXPY<CoefficientType, ViewType1, ViewType2, IndexType, false, 2> {
   run(const CoefficientType& alpha,
       const ViewType1& X,
       const ViewType2& Y) {
+#if KOKKOS_VERSION > 40799
+    using KokkosKernels::ArithTraits;
+#else
     using Kokkos::ArithTraits;
+#endif
     static_assert(static_cast<int>(ViewType1::rank) == static_cast<int>(ViewType2::rank),
                   "AXPY: X and Y must have the same rank.");
     const IndexType numRows = static_cast<IndexType>(Y.extent(0));
     const IndexType numCols = static_cast<IndexType>(Y.extent(1));
 
+#if KOKKOS_VERSION > 40799
+    if (alpha !Kernels= ArithTraits<CoefficientType>::zero()) {
+#else
     if (alpha != ArithTraits<CoefficientType>::zero()) {
+#endif
       for (IndexType j = 0; j < numCols; ++j)
         for (IndexType i = 0; i < numRows; ++i)
           Y(i, j) += alpha * X(i, j);
@@ -338,11 +366,19 @@ struct AXPY<CoefficientType, ViewType1, ViewType2, IndexType, true, rank> {
   run(const CoefficientType& alpha,
       const ViewType1& x,
       const ViewType2& y) {
+#if KOKKOS_VERSION > 40799
+    using KokkosKernels::ArithTraits;
+#else
     using Kokkos::ArithTraits;
+#endif
     static_assert(static_cast<int>(ViewType1::rank) == static_cast<int>(ViewType2::rank),
                   "AXPY: x and y must have the same rank.");
 
+#if KOKKOS_VERSION > 40799
+    if (alpha !Kernels= ArithTraits<CoefficientType>::zero()) {
+#else
     if (alpha != ArithTraits<CoefficientType>::zero()) {
+#endif
       using x_value_type   = typename std::decay<decltype(*x.data())>::type;
       using y_value_type   = typename std::decay<decltype(*y.data())>::type;
       const IndexType span = static_cast<IndexType>(y.span());
@@ -677,7 +713,11 @@ GEMM(const char transA[],
   static_assert(ViewType3::rank == 2, "GEMM: C must have rank 2 (be a matrix).");
 
   typedef typename std::remove_reference<decltype(A(0, 0))>::type Scalar;
+#if KOKKOS_VERSION > 40799
+  typedef KokkosKernels::ArithTraits<Scalar> STS;
+#else
   typedef Kokkos::ArithTraits<Scalar> STS;
+#endif
   const Scalar ZERO = STS::zero();
   const Scalar ONE  = STS::one();
 
@@ -804,7 +844,11 @@ GETF2(const LittleBlockType& A, const LittleVectorType& ipiv, int& info) {
   static_assert(!std::is_const<std::remove_reference<decltype(ipiv(0))>>::value,
                 "GETF2: ipiv must not be a const View (or LittleBlock).");
   static_assert(LittleBlockType::rank == 2, "GETF2: A must have rank 2 (be a matrix).");
+#if KOKKOS_VERSION > 40799
+  typedef KokkosKernels::ArithTraits<Scalar> STS;
+#else
   typedef Kokkos::ArithTraits<Scalar> STS;
+#endif
   const Scalar ZERO = STS::zero();
 
   const IndexType numRows = static_cast<IndexType>(A.extent(0));
@@ -901,7 +945,11 @@ struct GETRS<LittleBlockType, LittleIntVectorType, LittleScalarVectorType, 1> {
     static_assert(LittleIntVectorType::rank == 1, "GETRS: ipiv must have rank 1.");
     static_assert(LittleScalarVectorType::rank == 1, "GETRS: For this specialization, B must have rank 1.");
 
+#if KOKKOS_VERSION > 40799
+    typedef KokkosKernels::ArithTraits<Scalar> STS;
+#else
     typedef Kokkos::ArithTraits<Scalar> STS;
+#endif
     const Scalar ZERO       = STS::zero();
     const IndexType numRows = static_cast<IndexType>(A.extent(0));
     const IndexType numCols = static_cast<IndexType>(A.extent(1));
@@ -1059,7 +1107,11 @@ GETRI(const LittleBlockType& A,
   static_assert(!std::is_const<std::remove_reference<decltype(work(0))>>::value,
                 "GETRI: work must not be a const View (or LittleBlock).");
   static_assert(LittleBlockType::rank == 2, "GETRI: A must have rank 2 (be a matrix).");
+#if KOKKOS_VERSION > 40799
+  typedef KokkosKernels::ArithTraits<Scalar> STS;
+#else
   typedef Kokkos::ArithTraits<Scalar> STS;
+#endif
   const Scalar ZERO = STS::zero();
   const Scalar ONE  = STS::one();
 

packages/tpetra/core/src/Tpetra_CrsGraphTransposer_def.hpp

@@ -78,7 +78,11 @@ struct SortedNumericIndicesOnlyFunctor {
     , Ccolinds(Ccolinds_) {}
 
   KOKKOS_INLINE_FUNCTION void operator()(const ordinal_type i) const {
+#if KOKKOS_VERSION > 40799
+    const ordinal_type ORDINAL_MAX = KokkosKernels::ArithTraits<ordinal_type>::max();
+#else
     const ordinal_type ORDINAL_MAX = Kokkos::ArithTraits<ordinal_type>::max();
+#endif
 
     // count the union of nonzeros in Arow and Brow
     size_type ai        = 0;

packages/tpetra/core/src/Tpetra_CrsMatrix_decl.hpp

@@ -453,7 +453,11 @@ class CrsMatrix : public RowMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>,
   /// This is usually the same as the type of the magnitude
   /// (absolute value) of <tt>Scalar</tt>, but may differ for
   /// certain <tt>Scalar</tt> types.
+#if KOKKOS_VERSION > 40799
+  using mag_type = typename KokkosKernels::ArithTraits<impl_scalar_type>::mag_type;
+#else
   using mag_type = typename Kokkos::ArithTraits<impl_scalar_type>::mag_type;
+#endif
 
   //! The CrsGraph specialization suitable for this CrsMatrix specialization.
   using crs_graph_type = CrsGraph<LocalOrdinal, GlobalOrdinal, Node>;
@@ -3695,8 +3699,16 @@ class CrsMatrix : public RowMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node>,
  protected:
   // useful typedefs
   typedef Teuchos::OrdinalTraits<LocalOrdinal> OTL;
+#if KOKKOS_VERSION > 40799
+  typedef KokkosKernels::ArithTraits<impl_scalar_type> STS;
+#else
   typedef Kokkos::ArithTraits<impl_scalar_type> STS;
+#endif
+#if KOKKOS_VERSION > 40799
+  typedef KokkosKernels::ArithTraits<mag_type> STM;
+#else
   typedef Kokkos::ArithTraits<mag_type> STM;
+#endif
   typedef MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> MV;
   typedef Vector<Scalar, LocalOrdinal, GlobalOrdinal, Node> V;
   typedef crs_graph_type Graph;

packages/tpetra/core/src/Tpetra_Details_EquilibrationInfo.hpp

@@ -14,7 +14,11 @@
 /// \brief Declaration of Tpetra::Details::EquilibrationInfo
 
 #include "TpetraCore_config.h"
+#if KOKKOS_VERSION > 40799
+#include "KokkosKernels_ArithTraits.hpp"
+#else
 #include "Kokkos_ArithTraits.hpp"
+#endif
 #include "Kokkos_Core.hpp"
 
 namespace Tpetra {
@@ -45,8 +49,16 @@ namespace Details {
 /// over an MPI communicator.
 template <class ScalarType, class DeviceType>
 struct EquilibrationInfo {
+#if KOKKOS_VERSION > 40799
+  using val_type         = typename KokkosKernels::ArithTraits<ScalarType>::val_type;
+#else
   using val_type         = typename Kokkos::ArithTraits<ScalarType>::val_type;
+#endif
+#if KOKKOS_VERSION > 40799
+  using mag_type         = typename KokkosKernels::ArithTraits<val_type>::mag_type;
+#else
   using mag_type         = typename Kokkos::ArithTraits<val_type>::mag_type;
+#endif
   using device_type      = typename DeviceType::device_type;
   using host_device_type = typename Kokkos::View<mag_type*, device_type>::host_mirror_type::device_type;
   using HostMirror       = EquilibrationInfo<val_type, host_device_type>;