Update headers for compatibility with kokkos metaphysicl

Author: lindsayad

include/numerics/dense_matrix.h

@@ -324,7 +324,7 @@ class DenseMatrix : public DenseMatrixBase<T>
    * This is the natural matrix norm that is compatible to the l1-norm
    * for vectors, i.e. \f$ |Mv|_1 \leq |M|_1 |v|_1 \f$.
    */
-  auto l1_norm () const -> decltype(std::abs(T(0)));
+  auto l1_norm () const;
 
   /**
    * \returns The linfty-norm of the matrix, that is, the max row sum:
@@ -334,7 +334,7 @@ class DenseMatrix : public DenseMatrixBase<T>
    * This is the natural matrix norm that is compatible to the
    * linfty-norm of vectors, i.e. \f$ |Mv|_\infty \leq |M|_\infty |v|_\infty \f$.
    */
-  auto linfty_norm () const -> decltype(std::abs(T(0)));
+  auto linfty_norm () const;
 
   /**
    * Left multiplies by the transpose of the matrix \p A.
@@ -1122,23 +1122,24 @@ auto DenseMatrix<T>::max () const -> decltype(libmesh_real(T(0)))
 
 template<typename T>
 inline
-auto DenseMatrix<T>::l1_norm () const -> decltype(std::abs(T(0)))
+auto DenseMatrix<T>::l1_norm () const
 {
   libmesh_assert (this->_m);
   libmesh_assert (this->_n);
 
-  auto columnsum = std::abs(T(0));
+  using std::abs;
+  auto columnsum = abs(T(0));
   for (unsigned int i=0; i!=this->_m; i++)
     {
-      columnsum += std::abs((*this)(i,0));
+      columnsum += abs((*this)(i,0));
     }
   auto my_max = columnsum;
   for (unsigned int j=1; j!=this->_n; j++)
     {
       columnsum = 0.;
       for (unsigned int i=0; i!=this->_m; i++)
         {
-          columnsum += std::abs((*this)(i,j));
+          columnsum += abs((*this)(i,j));
         }
       my_max = (my_max > columnsum? my_max : columnsum);
     }
@@ -1149,23 +1150,24 @@ auto DenseMatrix<T>::l1_norm () const -> decltype(std::abs(T(0)))
 
 template<typename T>
 inline
-auto DenseMatrix<T>::linfty_norm () const -> decltype(std::abs(T(0)))
+auto DenseMatrix<T>::linfty_norm () const
 {
   libmesh_assert (this->_m);
   libmesh_assert (this->_n);
+  using std::abs;
 
-  auto rowsum = std::abs(T(0));
+  auto rowsum = abs(T(0));
   for (unsigned int j=0; j!=this->_n; j++)
     {
-      rowsum += std::abs((*this)(0,j));
+      rowsum += abs((*this)(0,j));
     }
   auto my_max = rowsum;
   for (unsigned int i=1; i!=this->_m; i++)
     {
       rowsum = 0.;
       for (unsigned int j=0; j!=this->_n; j++)
         {
-          rowsum += std::abs((*this)(i,j));
+          rowsum += abs((*this)(i,j));
         }
       my_max = (my_max > rowsum? my_max : rowsum);
     }

include/numerics/dense_matrix_impl.h

@@ -630,6 +630,8 @@ void DenseMatrix<T>::_lu_back_substitute (const DenseVector<T> & b,
 template<typename T>
 void DenseMatrix<T>::_lu_decompose ()
 {
+  using std::abs;
+
   // If this function was called, there better not be any
   // previous decomposition of the matrix.
   libmesh_assert_equal_to (this->_decomposition_type, NONE);
@@ -648,11 +650,11 @@ void DenseMatrix<T>::_lu_decompose ()
       // Find the pivot row by searching down the i'th column
       _pivots[i] = i;
 
-      // std::abs(complex) must return a Real!
-      auto the_max = std::abs( A(i,i) );
+      // abs(complex) must return a Real!
+      auto the_max = abs( A(i,i) );
       for (unsigned int j=i+1; j<n_rows; ++j)
         {
-          auto candidate_max = std::abs( A(j,i) );
+          auto candidate_max = abs( A(j,i) );
           if (the_max < candidate_max)
             {
               the_max = candidate_max;
@@ -872,6 +874,8 @@ void DenseMatrix<T>::cholesky_solve (const DenseVector<T2> & b,
 template<typename T>
 void DenseMatrix<T>::_cholesky_decompose ()
 {
+  using std::sqrt;
+
   // If we called this function, there better not be any
   // previous decomposition of the matrix.
   libmesh_assert_equal_to (this->_decomposition_type, NONE);
@@ -901,7 +905,7 @@ void DenseMatrix<T>::_cholesky_decompose ()
                                    "Error! Can only use Cholesky decomposition with symmetric positive definite matrices.");
 #endif
 
-              A(i,i) = std::sqrt(A(i,j));
+              A(i,i) = sqrt(A(i,j));
             }
           else
             A(j,i) = A(i,j) / A(i,i);

include/numerics/tensor_tools.h

@@ -71,61 +71,61 @@ inner_product(const TypeNTensor<N,T> & a, const TypeNTensor<N,T2> & b)
 
 template<typename T>
 inline
-auto norm(const T & a) -> decltype(std::abs(a))
-{ return std::abs(a); }
+auto norm(const T & a)
+{ using std::abs; return abs(a); }
 
 template<typename T>
 inline
-T norm(std::complex<T> a) { return std::abs(a); }
+T norm(std::complex<T> a) { using std::abs; return abs(a); }
 
 template <typename T>
 inline
 auto norm(const TypeVector<T> & a) -> decltype(TensorTools::norm(T()))
-{return std::sqrt(a.norm_sq());}
+{using std::sqrt; return sqrt(a.norm_sq());}
 
 template <typename T>
 inline
 auto norm(const VectorValue<T> & a) -> decltype(TensorTools::norm(T()))
-{return std::sqrt(a.norm_sq());}
+{using std::sqrt; return sqrt(a.norm_sq());}
 
 template <typename T>
 inline
 auto norm(const TypeTensor<T> & a) -> decltype(TensorTools::norm(T()))
-{return std::sqrt(a.norm_sq());}
+{using std::sqrt; return sqrt(a.norm_sq());}
 
 template <typename T>
 inline
 auto norm(const TensorValue<T> & a) -> decltype(TensorTools::norm(T()))
-{return std::sqrt(a.norm_sq());}
+{using std::sqrt; return sqrt(a.norm_sq());}
 
 
 template<typename T>
 inline
-auto norm_sq(const T & a) -> decltype(std::norm(a))
-{ return std::norm(a); }
+auto norm_sq(const T & a)
+{ using std::norm; return norm(a); }
 
 template<typename T>
 inline
-T norm_sq(std::complex<T> a) { return std::norm(a); }
+T norm_sq(std::complex<T> a) { using std::norm; return norm(a); }
 
 template <typename T>
 inline
-auto norm_sq(const TypeVector<T> & a) -> decltype(std::norm(T()))
+auto norm_sq(const TypeVector<T> & a)
 {return a.norm_sq();}
 
 template <typename T>
 inline
-auto norm_sq(const VectorValue<T> & a) -> decltype(std::norm(T()))
+auto norm_sq(const VectorValue<T> & a)
 {return a.norm_sq();}
 
 template <typename T>
 inline
-auto norm_sq(const TypeTensor<T> & a) -> decltype(std::norm(T()))
+auto norm_sq(const TypeTensor<T> & a)
 {return a.norm_sq();}
 
 template <typename T>
 inline
-auto norm_sq(const TensorValue<T> & a) -> decltype(std::norm(T()))
+auto norm_sq(const TensorValue<T> & a)
 {return a.norm_sq();}
 
 

include/numerics/type_n_tensor.h

@@ -218,7 +218,7 @@ class TypeNTensor
    * \returns The Frobenius norm of the tensor, i.e. the square-root of
    * the sum of the elements squared.
    */
-  auto norm() const -> decltype(std::norm(T()))
+  auto norm() const
   {
     libmesh_not_implemented();
     return 0.;
@@ -228,7 +228,7 @@ class TypeNTensor
    * \returns The Frobenius norm of the tensor squared, i.e. the sum of the
    * entry magnitudes squared.
    */
-  auto norm_sq() const -> decltype(std::norm(T()))
+  auto norm_sq() const
   {
     libmesh_not_implemented();
     return 0.;

include/numerics/type_tensor.h

@@ -364,13 +364,13 @@ class TypeTensor
    * \returns The Frobenius norm of the tensor, i.e. the square-root of
    * the sum of the elements squared.
    */
-  auto norm() const -> decltype(std::norm(T()));
+  auto norm() const;
 
   /**
    * \returns The Frobenius norm of the tensor squared, i.e. sum of the
    * element magnitudes squared.
    */
-  auto norm_sq() const -> decltype(std::norm(T()));
+  auto norm_sq() const;
 
   /**
    * \returns True if all values in the tensor are zero
@@ -1277,9 +1277,10 @@ TypeTensor<T>::contract (const TypeTensor<T2> & t) const
 
 template <typename T>
 inline
-auto TypeTensor<T>::norm() const -> decltype(std::norm(T()))
+auto TypeTensor<T>::norm() const
 {
-  return std::sqrt(this->norm_sq());
+  using std::sqrt;
+  return sqrt(this->norm_sq());
 }
 
 
@@ -1345,7 +1346,7 @@ void TypeTensor<T>::zero()
 
 template <typename T>
 inline
-auto TypeTensor<T>::norm_sq () const -> decltype(std::norm(T()))
+auto TypeTensor<T>::norm_sq () const
 {
   Real sum = 0.;
   for (unsigned int i=0; i<LIBMESH_DIM*LIBMESH_DIM; i++)

include/numerics/type_vector.h

@@ -298,13 +298,13 @@ class TypeVector
    * \returns The magnitude of the vector, i.e. the square-root of the
    * sum of the elements squared.
    */
-  auto norm() const -> decltype(std::norm(T()));
+  auto norm() const;
 
   /**
    * \returns The magnitude of the vector squared, i.e. the sum of the
    * element magnitudes squared.
    */
-  auto norm_sq() const -> decltype(std::norm(T()));
+  auto norm_sq() const;
 
   /**
    * \returns The L1 norm of the vector
@@ -904,9 +904,10 @@ TypeVector<T>::cross(const TypeVector<T2> & p) const
 
 template <typename T>
 inline
-auto TypeVector<T>::norm() const -> decltype(std::norm(T()))
+auto TypeVector<T>::norm() const
 {
-  return std::sqrt(this->norm_sq());
+  using std::sqrt;
+  return sqrt(this->norm_sq());
 }
 
 
@@ -923,7 +924,7 @@ void TypeVector<T>::zero()
 
 template <typename T>
 inline
-auto TypeVector<T>::norm_sq() const -> decltype(std::norm(T()))
+auto TypeVector<T>::norm_sq() const
 {
 #if LIBMESH_DIM == 1
   return (TensorTools::norm_sq(_coords[0]));