emit warnings when attempting to detect non-finite values in fast math mode

include/armadillo_bits/BaseCube_meat.hpp

@@ -308,13 +308,15 @@ BaseCube<elem_type,derived>::is_finite() const
   {
   arma_extra_debug_sigprint();
   
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "is_finite(): detection of non-finite values is not reliable in fast math mode"); }
+  
   const ProxyCube<derived> P( (*this).get_ref() );
   
   if(is_Cube<typename ProxyCube<derived>::stored_type>::value)
     {
     const unwrap_cube<typename ProxyCube<derived>::stored_type> U(P.Q);
     
-    return arrayops::is_finite( U.M.memptr(), U.M.n_elem );
+    return U.M.internal_is_finite();
     }
   
   const uword n_r = P.get_n_rows();
@@ -340,13 +342,15 @@ BaseCube<elem_type,derived>::has_inf() const
   {
   arma_extra_debug_sigprint();
   
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "has_inf(): detection of non-finite values is not reliable in fast math mode"); }
+  
   const ProxyCube<derived> P( (*this).get_ref() );
   
   if(is_Cube<typename ProxyCube<derived>::stored_type>::value)
     {
     const unwrap_cube<typename ProxyCube<derived>::stored_type> U(P.Q);
     
-    return arrayops::has_inf( U.M.memptr(), U.M.n_elem );
+    return U.M.internal_has_inf();
     }
   
   const uword n_r = P.get_n_rows();
@@ -372,13 +376,15 @@ BaseCube<elem_type,derived>::has_nan() const
   {
   arma_extra_debug_sigprint();
   
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "has_nan(): detection of non-finite values is not reliable in fast math mode"); }
+  
   const ProxyCube<derived> P( (*this).get_ref() );
   
   if(is_Cube<typename ProxyCube<derived>::stored_type>::value)
     {
     const unwrap_cube<typename ProxyCube<derived>::stored_type> U(P.Q);
     
-    return arrayops::has_nan( U.M.memptr(), U.M.n_elem );
+    return U.M.internal_has_nan();
     }
   
   const uword n_r = P.get_n_rows();

include/armadillo_bits/Base_meat.hpp

@@ -665,13 +665,15 @@ Base<elem_type,derived>::is_finite() const
   {
   arma_extra_debug_sigprint();
   
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "is_finite(): detection of non-finite values is not reliable in fast math mode"); }
+  
   const Proxy<derived> P( (*this).get_ref() );
   
   if(is_Mat<typename Proxy<derived>::stored_type>::value)
     {
     const quasi_unwrap<typename Proxy<derived>::stored_type> U(P.Q);
     
-    return arrayops::is_finite( U.M.memptr(), U.M.n_elem );
+    return U.M.internal_is_finite();
     }
   
   if(Proxy<derived>::use_at == false)
@@ -709,13 +711,15 @@ Base<elem_type,derived>::has_inf() const
   {
   arma_extra_debug_sigprint();
   
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "has_inf(): detection of non-finite values is not reliable in fast math mode"); }
+  
   const Proxy<derived> P( (*this).get_ref() );
   
   if(is_Mat<typename Proxy<derived>::stored_type>::value)
     {
     const quasi_unwrap<typename Proxy<derived>::stored_type> U(P.Q);
     
-    return arrayops::has_inf( U.M.memptr(), U.M.n_elem );
+    return U.M.internal_has_inf();
     }
   
   if(Proxy<derived>::use_at == false)
@@ -753,13 +757,15 @@ Base<elem_type,derived>::has_nan() const
   {
   arma_extra_debug_sigprint();
   
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "has_nan(): detection of non-finite values is not reliable in fast math mode"); }
+  
   const Proxy<derived> P( (*this).get_ref() );
   
   if(is_Mat<typename Proxy<derived>::stored_type>::value)
     {
     const quasi_unwrap<typename Proxy<derived>::stored_type> U(P.Q);
     
-    return arrayops::has_nan( U.M.memptr(), U.M.n_elem );
+    return U.M.internal_has_nan();
     }
   
   if(Proxy<derived>::use_at == false)

include/armadillo_bits/Cube_bones.hpp

@@ -317,6 +317,11 @@ class Cube : public BaseCube< eT, Cube<eT> >
   arma_warn_unused inline bool has_nan()       const;
   arma_warn_unused inline bool has_nonfinite() const;
   
+  arma_warn_unused inline bool internal_is_finite()     const;
+  arma_warn_unused inline bool internal_has_inf()       const;
+  arma_warn_unused inline bool internal_has_nan()       const;
+  arma_warn_unused inline bool internal_has_nonfinite() const;
+  
   arma_warn_unused arma_inline bool in_range(const uword i) const;
   arma_warn_unused arma_inline bool in_range(const span& x) const;
   

include/armadillo_bits/Cube_meat.hpp

@@ -3638,7 +3638,9 @@ Cube<eT>::is_finite() const
   {
   arma_extra_debug_sigprint();
   
-  return arrayops::is_finite(memptr(), n_elem);
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "is_finite(): detection of non-finite values is not reliable in fast math mode"); }
+  
+  return (*this).internal_is_finite();
   }
 
 
@@ -3661,7 +3663,9 @@ Cube<eT>::has_inf() const
   {
   arma_extra_debug_sigprint();
   
-  return arrayops::has_inf(memptr(), n_elem);
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "has_inf(): detection of non-finite values is not reliable in fast math mode"); }
+  
+  return (*this).internal_has_inf();
   }
 
 
@@ -3673,7 +3677,9 @@ Cube<eT>::has_nan() const
   {
   arma_extra_debug_sigprint();
   
-  return arrayops::has_nan(memptr(), n_elem);
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "has_nan(): detection of non-finite values is not reliable in fast math mode"); }
+  
+  return (*this).internal_has_nan();
   }
 
 
@@ -3685,6 +3691,56 @@ Cube<eT>::has_nonfinite() const
   {
   arma_extra_debug_sigprint();
   
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "has_nonfinite(): detection of non-finite values is not reliable in fast math mode"); }
+  
+  return (*this).internal_has_nonfinite();
+  }
+
+
+
+template<typename eT>
+inline
+bool
+Cube<eT>::internal_is_finite() const
+  {
+  arma_extra_debug_sigprint();
+  
+  return arrayops::is_finite(memptr(), n_elem);
+  }
+
+
+
+template<typename eT>
+inline
+bool
+Cube<eT>::internal_has_inf() const
+  {
+  arma_extra_debug_sigprint();
+  
+  return arrayops::has_inf(memptr(), n_elem);
+  }
+
+
+
+template<typename eT>
+inline
+bool
+Cube<eT>::internal_has_nan() const
+  {
+  arma_extra_debug_sigprint();
+  
+  return arrayops::has_nan(memptr(), n_elem);
+  }
+
+
+
+template<typename eT>
+inline
+bool
+Cube<eT>::internal_has_nonfinite() const
+  {
+  arma_extra_debug_sigprint();
+  
   return (arrayops::is_finite(memptr(), n_elem) == false);
   }
 

include/armadillo_bits/Mat_bones.hpp

@@ -430,6 +430,11 @@ class Mat : public Base< eT, Mat<eT> >
   arma_warn_unused inline bool has_nan()       const;
   arma_warn_unused inline bool has_nonfinite() const;
   
+  arma_warn_unused inline bool internal_is_finite()     const;
+  arma_warn_unused inline bool internal_has_inf()       const;
+  arma_warn_unused inline bool internal_has_nan()       const;
+  arma_warn_unused inline bool internal_has_nonfinite() const;
+  
   arma_warn_unused inline bool is_sorted(const char* direction = "ascend")       const;
   arma_warn_unused inline bool is_sorted(const char* direction, const uword dim) const;
   

include/armadillo_bits/Mat_meat.hpp

@@ -6251,7 +6251,11 @@ inline
 bool
 Mat<eT>::is_finite() const
   {
-  return arrayops::is_finite(memptr(), n_elem);
+  arma_extra_debug_sigprint();
+  
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "is_finite(): detection of non-finite values is not reliable in fast math mode"); }
+  
+  return (*this).internal_is_finite();
   }
 
 
@@ -6263,7 +6267,9 @@ Mat<eT>::has_inf() const
   {
   arma_extra_debug_sigprint();
   
-  return arrayops::has_inf(memptr(), n_elem);
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "has_inf(): detection of non-finite values is not reliable in fast math mode"); }
+  
+  return (*this).internal_has_inf();
   }
 
 
@@ -6275,7 +6281,9 @@ Mat<eT>::has_nan() const
   {
   arma_extra_debug_sigprint();
   
-  return arrayops::has_nan(memptr(), n_elem);
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "has_nan(): detection of non-finite values is not reliable in fast math mode"); }
+  
+  return (*this).internal_has_nan();
   }
 
 
@@ -6287,6 +6295,56 @@ Mat<eT>::has_nonfinite() const
   {
   arma_extra_debug_sigprint();
   
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "has_nonfinite(): detection of non-finite values is not reliable in fast math mode"); }
+  
+  return (*this).internal_has_nonfinite();
+  }
+
+
+
+template<typename eT>
+inline
+bool
+Mat<eT>::internal_is_finite() const
+  {
+  arma_extra_debug_sigprint();
+  
+  return arrayops::is_finite(memptr(), n_elem);
+  }
+
+
+
+template<typename eT>
+inline
+bool
+Mat<eT>::internal_has_inf() const
+  {
+  arma_extra_debug_sigprint();
+  
+  return arrayops::has_inf(memptr(), n_elem);
+  }
+
+
+
+template<typename eT>
+inline
+bool
+Mat<eT>::internal_has_nan() const
+  {
+  arma_extra_debug_sigprint();
+  
+  return arrayops::has_nan(memptr(), n_elem);
+  }
+
+
+
+template<typename eT>
+inline
+bool
+Mat<eT>::internal_has_nonfinite() const
+  {
+  arma_extra_debug_sigprint();
+  
   return (arrayops::is_finite(memptr(), n_elem) == false);
   }
 

include/armadillo_bits/SpBase_meat.hpp

@@ -731,13 +731,15 @@ SpBase<elem_type,derived>::is_finite() const
   {
   arma_extra_debug_sigprint();
   
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "is_finite(): detection of non-finite values is not reliable in fast math mode"); }
+  
   const SpProxy<derived> P( (*this).get_ref() );
   
   if(is_SpMat<typename SpProxy<derived>::stored_type>::value)
     {
     const unwrap_spmat<typename SpProxy<derived>::stored_type> U(P.Q);
     
-    return U.M.is_finite();
+    return U.M.internal_is_finite();
     }
   else
     {
@@ -763,13 +765,15 @@ SpBase<elem_type,derived>::has_inf() const
   {
   arma_extra_debug_sigprint();
   
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "has_inf(): detection of non-finite values is not reliable in fast math mode"); }
+  
   const SpProxy<derived> P( (*this).get_ref() );
   
   if(is_SpMat<typename SpProxy<derived>::stored_type>::value)
     {
     const unwrap_spmat<typename SpProxy<derived>::stored_type> U(P.Q);
     
-    return U.M.has_inf();
+    return U.M.internal_has_inf();
     }
   else
     {
@@ -795,13 +799,15 @@ SpBase<elem_type,derived>::has_nan() const
   {
   arma_extra_debug_sigprint();
   
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "has_nan(): detection of non-finite values is not reliable in fast math mode"); }
+  
   const SpProxy<derived> P( (*this).get_ref() );
   
   if(is_SpMat<typename SpProxy<derived>::stored_type>::value)
     {
     const unwrap_spmat<typename SpProxy<derived>::stored_type> U(P.Q);
     
-    return U.M.has_nan();
+    return U.M.internal_has_nan();
     }
   else
     {

include/armadillo_bits/SpMat_bones.hpp

@@ -313,6 +313,11 @@ class SpMat : public SpBase< eT, SpMat<eT> >
   arma_warn_unused inline bool has_nan()       const;
   arma_warn_unused inline bool has_nonfinite() const;
   
+  arma_warn_unused inline bool internal_is_finite()     const;
+  arma_warn_unused inline bool internal_has_inf()       const;
+  arma_warn_unused inline bool internal_has_nan()       const;
+  arma_warn_unused inline bool internal_has_nonfinite() const;
+  
   arma_warn_unused arma_inline bool in_range(const uword i) const;
   arma_warn_unused arma_inline bool in_range(const span& x) const;
   

include/armadillo_bits/SpMat_meat.hpp

@@ -3403,9 +3403,9 @@ SpMat<eT>::is_finite() const
   {
   arma_extra_debug_sigprint();
   
-  sync_csc();
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "is_finite(): detection of non-finite values is not reliable in fast math mode"); }
   
-  return arrayops::is_finite(values, n_nonzero);
+  return (*this).internal_is_finite();
   }
 
 
@@ -3509,6 +3509,62 @@ SpMat<eT>::has_inf() const
   {
   arma_extra_debug_sigprint();
   
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "has_inf(): detection of non-finite values is not reliable in fast math mode"); }
+  
+  return (*this).internal_has_inf();
+  }
+
+
+
+template<typename eT>
+inline
+bool
+SpMat<eT>::has_nan() const
+  {
+  arma_extra_debug_sigprint();
+  
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "has_nan(): detection of non-finite values is not reliable in fast math mode"); }
+  
+  return (*this).internal_has_nan();
+  }
+
+
+
+template<typename eT>
+inline
+bool
+SpMat<eT>::has_nonfinite() const
+  {
+  arma_extra_debug_sigprint();
+  
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "has_nonfinite(): detection of non-finite values is not reliable in fast math mode"); }
+  
+  return (*this).internal_has_nonfinite();
+  }
+
+
+
+template<typename eT>
+inline
+bool
+SpMat<eT>::internal_is_finite() const
+  {
+  arma_extra_debug_sigprint();
+  
+  sync_csc();
+  
+  return arrayops::is_finite(values, n_nonzero);
+  }
+
+
+
+template<typename eT>
+inline
+bool
+SpMat<eT>::internal_has_inf() const
+  {
+  arma_extra_debug_sigprint();
+  
   sync_csc();
   
   return arrayops::has_inf(values, n_nonzero);
@@ -3519,7 +3575,7 @@ SpMat<eT>::has_inf() const
 template<typename eT>
 inline
 bool
-SpMat<eT>::has_nan() const
+SpMat<eT>::internal_has_nan() const
   {
   arma_extra_debug_sigprint();
   
@@ -3533,7 +3589,7 @@ SpMat<eT>::has_nan() const
 template<typename eT>
 inline
 bool
-SpMat<eT>::has_nonfinite() const
+SpMat<eT>::internal_has_nonfinite() const
   {
   arma_extra_debug_sigprint();
   

include/armadillo_bits/arma_config.hpp

@@ -223,6 +223,13 @@ struct arma_config
   #endif
   
   
+  #if (defined(__FAST_MATH__) || (defined(__FINITE_MATH_ONLY__) && (__FINITE_MATH_ONLY__ > 0)) || defined(_M_FP_FAST))
+    static constexpr bool fast_math = true;
+  #else
+    static constexpr bool fast_math = false;
+  #endif
+  
+  
   static constexpr uword warn_level = (sword(ARMA_WARN_LEVEL) > 0) ? uword(ARMA_WARN_LEVEL) : 0;
   };
 

include/armadillo_bits/auxlib_meat.hpp

@@ -810,7 +810,7 @@ auxlib::eig_gen
     
     if(X.is_empty())  { vals.reset(); vecs.reset(); return true; }
     
-    if(arma_config::check_nonfinite && X.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && X.internal_has_nonfinite())  { return false; }
     
     vals.set_size(X.n_rows, 1);
     
@@ -918,7 +918,7 @@ auxlib::eig_gen
     
     if(X.is_empty())  { vals.reset(); vecs.reset(); return true; }
     
-    if(arma_config::check_nonfinite && X.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && X.internal_has_nonfinite())  { return false; }
     
     vals.set_size(X.n_rows, 1);
     
@@ -985,7 +985,7 @@ auxlib::eig_gen_balance
     
     if(X.is_empty())  { vals.reset(); vecs.reset(); return true; }
     
-    if(arma_config::check_nonfinite && X.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && X.internal_has_nonfinite())  { return false; }
     
     vals.set_size(X.n_rows, 1);
     
@@ -1109,7 +1109,7 @@ auxlib::eig_gen_balance
     
     if(X.is_empty())  { vals.reset(); vecs.reset(); return true; }
     
-    if(arma_config::check_nonfinite && X.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && X.internal_has_nonfinite())  { return false; }
     
     vals.set_size(X.n_rows, 1);
     
@@ -1185,7 +1185,7 @@ auxlib::eig_gen_twosided
     
     if(X.is_empty())  { vals.reset(); lvecs.reset(); rvecs.reset(); return true; }
     
-    if(arma_config::check_nonfinite && X.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && X.internal_has_nonfinite())  { return false; }
     
     vals.set_size(X.n_rows, 1);
     
@@ -1286,7 +1286,7 @@ auxlib::eig_gen_twosided
     
     if(X.is_empty())  { vals.reset(); lvecs.reset(); rvecs.reset(); return true; }
     
-    if(arma_config::check_nonfinite && X.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && X.internal_has_nonfinite())  { return false; }
     
     vals.set_size(X.n_rows, 1);
     
@@ -1350,7 +1350,7 @@ auxlib::eig_gen_twosided_balance
     
     if(X.is_empty())  { vals.reset(); lvecs.reset(); rvecs.reset(); return true; }
     
-    if(arma_config::check_nonfinite && X.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && X.internal_has_nonfinite())  { return false; }
     
     vals.set_size(X.n_rows, 1);
     
@@ -1467,7 +1467,7 @@ auxlib::eig_gen_twosided_balance
     
     if(X.is_empty())  { vals.reset(); lvecs.reset(); rvecs.reset(); return true; }
     
-    if(arma_config::check_nonfinite && X.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && X.internal_has_nonfinite())  { return false; }
     
     vals.set_size(X.n_rows, 1);
     
@@ -1545,8 +1545,8 @@ auxlib::eig_pair
     
     if(A.is_empty())  { vals.reset(); vecs.reset(); return true; }
     
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
-    if(arma_config::check_nonfinite && B.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && B.internal_has_nonfinite())  { return false; }
     
     vals.set_size(A.n_rows, 1);
     
@@ -1683,8 +1683,8 @@ auxlib::eig_pair
     
     if(A.is_empty())  { vals.reset(); vecs.reset(); return true; }
     
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
-    if(arma_config::check_nonfinite && B.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && B.internal_has_nonfinite())  { return false; }
     
     vals.set_size(A.n_rows, 1);
     
@@ -1780,8 +1780,8 @@ auxlib::eig_pair_twosided
     
     if(A.is_empty())  { vals.reset(); lvecs.reset(); rvecs.reset(); return true; }
     
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
-    if(arma_config::check_nonfinite && B.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && B.internal_has_nonfinite())  { return false; }
     
     vals.set_size(A.n_rows, 1);
     
@@ -1911,8 +1911,8 @@ auxlib::eig_pair_twosided
     
     if(A.is_empty())  { vals.reset(); lvecs.reset(); rvecs.reset(); return true; }
     
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
-    if(arma_config::check_nonfinite && B.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && B.internal_has_nonfinite())  { return false; }
     
     vals.set_size(A.n_rows, 1);
     
@@ -2974,7 +2974,7 @@ auxlib::svd(Col<eT>& S, Mat<eT>& A)
     {
     if(A.is_empty())  { S.reset(); return true; }
     
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
     
     arma_debug_assert_blas_size(A);
     
@@ -3044,7 +3044,7 @@ auxlib::svd(Col<T>& S, Mat< std::complex<T> >& A)
     
     if(A.is_empty())  { S.reset(); return true; }
     
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
     
     arma_debug_assert_blas_size(A);
     
@@ -3114,7 +3114,7 @@ auxlib::svd(Mat<eT>& U, Col<eT>& S, Mat<eT>& V, Mat<eT>& A)
     {
     if(A.is_empty())  { U.eye(A.n_rows, A.n_rows); S.reset(); V.eye(A.n_cols, A.n_cols); return true; }
     
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
     
     arma_debug_assert_blas_size(A);
     
@@ -3191,7 +3191,7 @@ auxlib::svd(Mat< std::complex<T> >& U, Col<T>& S, Mat< std::complex<T> >& V, Mat
     
     if(A.is_empty())  { U.eye(A.n_rows, A.n_rows); S.reset(); V.eye(A.n_cols, A.n_cols); return true; }
     
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
     
     arma_debug_assert_blas_size(A);
     
@@ -3267,7 +3267,7 @@ auxlib::svd_econ(Mat<eT>& U, Col<eT>& S, Mat<eT>& V, Mat<eT>& A, const char mode
     {
     if(A.is_empty())  { U.eye(); S.reset(); V.eye(); return true; }
     
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
     
     arma_debug_assert_blas_size(A);
     
@@ -3380,7 +3380,7 @@ auxlib::svd_econ(Mat< std::complex<T> >& U, Col<T>& S, Mat< std::complex<T> >& V
     
     if(A.is_empty())  { U.eye(); S.reset(); V.eye(); return true; }
     
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
     
     arma_debug_assert_blas_size(A);
     
@@ -3492,7 +3492,7 @@ auxlib::svd_dc(Col<eT>& S, Mat<eT>& A)
     {
     if(A.is_empty())  { S.reset(); return true; }
     
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
     
     arma_debug_assert_blas_size(A);
     
@@ -3564,7 +3564,7 @@ auxlib::svd_dc(Col<T>& S, Mat< std::complex<T> >& A)
     
     if(A.is_empty())  { S.reset(); return true; }
     
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
     
     arma_debug_assert_blas_size(A);
     
@@ -3635,7 +3635,7 @@ auxlib::svd_dc(Mat<eT>& U, Col<eT>& S, Mat<eT>& V, Mat<eT>& A)
     {
     if(A.is_empty())  { U.eye(A.n_rows, A.n_rows); S.reset(); V.eye(A.n_cols, A.n_cols); return true; }
     
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
     
     arma_debug_assert_blas_size(A);
     
@@ -3715,7 +3715,7 @@ auxlib::svd_dc(Mat< std::complex<T> >& U, Col<T>& S, Mat< std::complex<T> >& V,
     
     if(A.is_empty())  { U.eye(A.n_rows, A.n_rows); S.reset(); V.eye(A.n_cols, A.n_cols); return true; }
     
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
     
     arma_debug_assert_blas_size(A);
     
@@ -3791,7 +3791,7 @@ auxlib::svd_dc_econ(Mat<eT>& U, Col<eT>& S, Mat<eT>& V, Mat<eT>& A)
   
   #if defined(ARMA_USE_LAPACK)
     {
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
     
     arma_debug_assert_blas_size(A);
     
@@ -3878,7 +3878,7 @@ auxlib::svd_dc_econ(Mat< std::complex<T> >& U, Col<T>& S, Mat< std::complex<T> >
     {
     typedef std::complex<T> eT;
     
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
     
     arma_debug_assert_blas_size(A);
     
@@ -4888,8 +4888,8 @@ auxlib::solve_approx_svd(Mat<typename T1::pod_type>& out, Mat<typename T1::pod_t
     
     if(A.is_empty() || B.is_empty())  { out.zeros(A.n_cols, B.n_cols); return true; }
     
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
-    if(arma_config::check_nonfinite && B.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && B.internal_has_nonfinite())  { return false; }
     
     arma_debug_assert_blas_size(A,B);
     
@@ -5009,8 +5009,8 @@ auxlib::solve_approx_svd(Mat< std::complex<typename T1::pod_type> >& out, Mat< s
     
     if(A.is_empty() || B.is_empty())  { out.zeros(A.n_cols, B.n_cols); return true; }
     
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
-    if(arma_config::check_nonfinite && B.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && B.internal_has_nonfinite())  { return false; }
     
     arma_debug_assert_blas_size(A,B);
     
@@ -5925,8 +5925,8 @@ auxlib::qz(Mat<T>& A, Mat<T>& B, Mat<T>& vsl, Mat<T>& vsr, const Base<T,T1>& X_e
     
     if(A.is_empty())  { A.reset();  B.reset();  vsl.reset(); vsr.reset(); return true; }
     
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
-    if(arma_config::check_nonfinite && B.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && B.internal_has_nonfinite())  { return false; }
     
     arma_debug_assert_blas_size(A);
     
@@ -6012,8 +6012,8 @@ auxlib::qz(Mat< std::complex<T> >& A, Mat< std::complex<T> >& B, Mat< std::compl
     
     if(A.is_empty())  { A.reset(); B.reset(); vsl.reset(); vsr.reset(); return true; }
     
-    if(arma_config::check_nonfinite && A.has_nonfinite())  { return false; }
-    if(arma_config::check_nonfinite && B.has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && A.internal_has_nonfinite())  { return false; }
+    if(arma_config::check_nonfinite && B.internal_has_nonfinite())  { return false; }
     
     arma_debug_assert_blas_size(A);
     

include/armadillo_bits/debug.hpp

@@ -1445,6 +1445,7 @@ arma_assert_atlas_size(const T1& A, const T2& B)
         out << "@ arma_config::optimise_invexpr = " << arma_config::optimise_invexpr << '\n';
         out << "@ arma_config::check_nonfinite  = " << arma_config::check_nonfinite  << '\n';
         out << "@ arma_config::zero_init        = " << arma_config::zero_init        << '\n';
+        out << "@ arma_config::fast_math        = " << arma_config::fast_math        << '\n';
         out << "@ sizeof(void*)    = " << sizeof(void*)    << '\n';
         out << "@ sizeof(int)      = " << sizeof(int)      << '\n';
         out << "@ sizeof(long)     = " << sizeof(long)     << '\n';

include/armadillo_bits/glue_quantile_meat.hpp

@@ -178,7 +178,7 @@ glue_quantile::apply(Mat<typename T2::elem_type>& out, const mtGlue<typename T2:
   const quasi_unwrap<T1> UA(expr.A);
   const quasi_unwrap<T2> UB(expr.B);
   
-  arma_debug_check((UA.M.has_nan() || UB.M.has_nan()), "quantile(): detected NaN");
+  arma_debug_check((UA.M.internal_has_nan() || UB.M.internal_has_nan()), "quantile(): detected NaN");
   
   if(UA.is_alias(out) || UB.is_alias(out))
     {
@@ -210,7 +210,7 @@ glue_quantile_default::apply(Mat<typename T2::elem_type>& out, const mtGlue<type
   
   const uword dim = (T1::is_xvec) ? uword(UA.M.is_rowvec() ? 1 : 0) : uword((T1::is_row) ? 1 : 0);
   
-  arma_debug_check((UA.M.has_nan() || UB.M.has_nan()), "quantile(): detected NaN");
+  arma_debug_check((UA.M.internal_has_nan() || UB.M.internal_has_nan()), "quantile(): detected NaN");
   
   if(UA.is_alias(out) || UB.is_alias(out))
     {

include/armadillo_bits/gmm_diag_meat.hpp

@@ -151,9 +151,9 @@ gmm_diag<eT>::set_params(const Base<eT,T1>& in_means_expr, const Base<eT,T2>& in
     "gmm_diag::set_params(): given parameters have inconsistent and/or wrong sizes"
     );
   
-  arma_debug_check( (in_means.is_finite() == false), "gmm_diag::set_params(): given means have non-finite values" );
-  arma_debug_check( (in_dcovs.is_finite() == false), "gmm_diag::set_params(): given dcovs have non-finite values" );
-  arma_debug_check( (in_hefts.is_finite() == false), "gmm_diag::set_params(): given hefts have non-finite values" );
+  arma_debug_check( (in_means.internal_has_nonfinite()), "gmm_diag::set_params(): given means have non-finite values" );
+  arma_debug_check( (in_dcovs.internal_has_nonfinite()), "gmm_diag::set_params(): given dcovs have non-finite values" );
+  arma_debug_check( (in_hefts.internal_has_nonfinite()), "gmm_diag::set_params(): given hefts have non-finite values" );
   
   arma_debug_check( (any(vectorise(in_dcovs) <= eT(0))), "gmm_diag::set_params(): given dcovs have negative or zero values" );
   arma_debug_check( (any(vectorise(in_hefts) <  eT(0))), "gmm_diag::set_params(): given hefts have negative values"         );
@@ -184,7 +184,7 @@ gmm_diag<eT>::set_means(const Base<eT,T1>& in_means_expr)
   const Mat<eT>& in_means = tmp.M;
   
   arma_debug_check( (arma::size(in_means) != arma::size(means)), "gmm_diag::set_means(): given means have incompatible size" );
-  arma_debug_check( (in_means.is_finite() == false),             "gmm_diag::set_means(): given means have non-finite values" );
+  arma_debug_check( (in_means.internal_has_nonfinite()),         "gmm_diag::set_means(): given means have non-finite values" );
   
   access::rw(means) = in_means;
   }
@@ -204,7 +204,7 @@ gmm_diag<eT>::set_dcovs(const Base<eT,T1>& in_dcovs_expr)
   const Mat<eT>& in_dcovs = tmp.M;
   
   arma_debug_check( (arma::size(in_dcovs) != arma::size(dcovs)), "gmm_diag::set_dcovs(): given dcovs have incompatible size"       );
-  arma_debug_check( (in_dcovs.is_finite() == false),             "gmm_diag::set_dcovs(): given dcovs have non-finite values"       );
+  arma_debug_check( (in_dcovs.internal_has_nonfinite()),         "gmm_diag::set_dcovs(): given dcovs have non-finite values"       );
   arma_debug_check( (any(vectorise(in_dcovs) <= eT(0))),         "gmm_diag::set_dcovs(): given dcovs have negative or zero values" );
   
   access::rw(dcovs) = in_dcovs;
@@ -227,7 +227,7 @@ gmm_diag<eT>::set_hefts(const Base<eT,T1>& in_hefts_expr)
   const Mat<eT>& in_hefts = tmp.M;
   
   arma_debug_check( (arma::size(in_hefts) != arma::size(hefts)), "gmm_diag::set_hefts(): given hefts have incompatible size" );
-  arma_debug_check( (in_hefts.is_finite() == false),             "gmm_diag::set_hefts(): given hefts have non-finite values" );
+  arma_debug_check( (in_hefts.internal_has_nonfinite()),         "gmm_diag::set_hefts(): given hefts have non-finite values" );
   arma_debug_check( (any(vectorise(in_hefts) <  eT(0))),         "gmm_diag::set_hefts(): given hefts have negative values"   );
   
   const eT s = accu(in_hefts);
@@ -690,8 +690,8 @@ gmm_diag<eT>::learn
   const unwrap<T1>   tmp_X(data.get_ref());
   const Mat<eT>& X = tmp_X.M;
   
-  if(X.is_empty()          )  { arma_debug_warn_level(3, "gmm_diag::learn(): given matrix is empty"             ); return false; }
-  if(X.is_finite() == false)  { arma_debug_warn_level(3, "gmm_diag::learn(): given matrix has non-finite values"); return false; }
+  if(X.is_empty()              )  { arma_debug_warn_level(3, "gmm_diag::learn(): given matrix is empty"             ); return false; }
+  if(X.internal_has_nonfinite())  { arma_debug_warn_level(3, "gmm_diag::learn(): given matrix has non-finite values"); return false; }
   
   if(N_gaus == 0)  { reset(); return true; }
   
@@ -818,8 +818,8 @@ gmm_diag<eT>::kmeans_wrapper
   const unwrap<T1>   tmp_X(data.get_ref());
   const Mat<eT>& X = tmp_X.M;
   
-  if(X.is_empty()          )  { arma_debug_warn_level(3, "kmeans(): given matrix is empty"             ); return false; }
-  if(X.is_finite() == false)  { arma_debug_warn_level(3, "kmeans(): given matrix has non-finite values"); return false; }
+  if(X.is_empty()              )  { arma_debug_warn_level(3, "kmeans(): given matrix is empty"             ); return false; }
+  if(X.internal_has_nonfinite())  { arma_debug_warn_level(3, "kmeans(): given matrix has non-finite values"); return false; }
   
   if(N_gaus == 0)  { reset(); return true; }
   
@@ -2277,7 +2277,7 @@ gmm_diag<eT>::km_iterate(const Mat<eT>& X, const uword max_iter, const bool verb
   
   access::rw(means) = old_means;
   
-  if(means.is_finite() == false)  { return false; }
+  if(means.internal_has_nonfinite())  { return false; }
   
   return true;
   }
@@ -2371,9 +2371,9 @@ gmm_diag<eT>::em_iterate(const Mat<eT>& X, const uword max_iter, const eT var_fl
   
   
   if(any(vectorise(dcovs) <= eT(0)))  { return false; }
-  if(means.is_finite() == false    )  { return false; }
-  if(dcovs.is_finite() == false    )  { return false; }
-  if(hefts.is_finite() == false    )  { return false; }
+  if(means.internal_has_nonfinite())  { return false; }
+  if(dcovs.internal_has_nonfinite())  { return false; }
+  if(hefts.internal_has_nonfinite())  { return false; }
   
   return true;
   }

include/armadillo_bits/gmm_full_meat.hpp

@@ -151,9 +151,9 @@ gmm_full<eT>::set_params(const Base<eT,T1>& in_means_expr, const BaseCube<eT,T2>
     "gmm_full::set_params(): given parameters have inconsistent and/or wrong sizes"
     );
   
-  arma_debug_check( (in_means.is_finite() == false), "gmm_full::set_params(): given means have non-finite values" );
-  arma_debug_check( (in_fcovs.is_finite() == false), "gmm_full::set_params(): given fcovs have non-finite values" );
-  arma_debug_check( (in_hefts.is_finite() == false), "gmm_full::set_params(): given hefts have non-finite values" );
+  arma_debug_check( (in_means.internal_has_nonfinite()), "gmm_full::set_params(): given means have non-finite values" );
+  arma_debug_check( (in_fcovs.internal_has_nonfinite()), "gmm_full::set_params(): given fcovs have non-finite values" );
+  arma_debug_check( (in_hefts.internal_has_nonfinite()), "gmm_full::set_params(): given hefts have non-finite values" );
   
   for(uword g=0; g < in_fcovs.n_slices; ++g)
     {
@@ -188,7 +188,7 @@ gmm_full<eT>::set_means(const Base<eT,T1>& in_means_expr)
   const Mat<eT>& in_means = tmp.M;
   
   arma_debug_check( (arma::size(in_means) != arma::size(means)), "gmm_full::set_means(): given means have incompatible size" );
-  arma_debug_check( (in_means.is_finite() == false),             "gmm_full::set_means(): given means have non-finite values" );
+  arma_debug_check( (in_means.internal_has_nonfinite()),         "gmm_full::set_means(): given means have non-finite values" );
   
   access::rw(means) = in_means;
   }
@@ -208,7 +208,7 @@ gmm_full<eT>::set_fcovs(const BaseCube<eT,T1>& in_fcovs_expr)
   const Cube<eT>& in_fcovs = tmp.M;
   
   arma_debug_check( (arma::size(in_fcovs) != arma::size(fcovs)), "gmm_full::set_fcovs(): given fcovs have incompatible size" );
-  arma_debug_check( (in_fcovs.is_finite() == false),             "gmm_full::set_fcovs(): given fcovs have non-finite values" );
+  arma_debug_check( (in_fcovs.internal_has_nonfinite()),         "gmm_full::set_fcovs(): given fcovs have non-finite values" );
   
   for(uword i=0; i < in_fcovs.n_slices; ++i)
     {
@@ -235,7 +235,7 @@ gmm_full<eT>::set_hefts(const Base<eT,T1>& in_hefts_expr)
   const Mat<eT>& in_hefts = tmp.M;
   
   arma_debug_check( (arma::size(in_hefts) != arma::size(hefts)), "gmm_full::set_hefts(): given hefts have incompatible size" );
-  arma_debug_check( (in_hefts.is_finite() == false),             "gmm_full::set_hefts(): given hefts have non-finite values" );
+  arma_debug_check( (in_hefts.internal_has_nonfinite()),         "gmm_full::set_hefts(): given hefts have non-finite values" );
   arma_debug_check( (any(vectorise(in_hefts) <  eT(0))),         "gmm_full::set_hefts(): given hefts have negative values"   );
   
   const eT s = accu(in_hefts);
@@ -729,8 +729,8 @@ gmm_full<eT>::learn
   const unwrap<T1>   tmp_X(data.get_ref());
   const Mat<eT>& X = tmp_X.M;
   
-  if(X.is_empty()          )  { arma_debug_warn_level(3, "gmm_full::learn(): given matrix is empty"             ); return false; }
-  if(X.is_finite() == false)  { arma_debug_warn_level(3, "gmm_full::learn(): given matrix has non-finite values"); return false; }
+  if(X.is_empty()              )  { arma_debug_warn_level(3, "gmm_full::learn(): given matrix is empty"             ); return false; }
+  if(X.internal_has_nonfinite())  { arma_debug_warn_level(3, "gmm_full::learn(): given matrix has non-finite values"); return false; }
   
   if(N_gaus == 0)  { reset(); return true; }
   
@@ -2308,7 +2308,7 @@ gmm_full<eT>::km_iterate(const Mat<eT>& X, const uword max_iter, const bool verb
   
   access::rw(means) = old_means;
   
-  if(means.is_finite() == false)  { return false; }
+  if(means.internal_has_nonfinite())  { return false; }
   
   return true;
   }
@@ -2408,9 +2408,9 @@ gmm_full<eT>::em_iterate(const Mat<eT>& X, const uword max_iter, const eT var_fl
     if(any(vectorise(fcov.diag()) <= eT(0)))  { return false; }
     }
   
-  if(means.is_finite() == false)  { return false; }
-  if(fcovs.is_finite() == false)  { return false; }
-  if(hefts.is_finite() == false)  { return false; }
+  if(means.internal_has_nonfinite())  { return false; }
+  if(fcovs.internal_has_nonfinite())  { return false; }
+  if(hefts.internal_has_nonfinite())  { return false; }
   
   return true;
   }
@@ -2541,7 +2541,7 @@ gmm_full<eT>::em_update_params
       if(val < var_floor)  { val = var_floor; }
       }
     
-    if(acc_fcov.is_finite() == false)  { continue; }
+    if(acc_fcov.internal_has_nonfinite())  { continue; }
     
     eT log_det_val  = eT(0);
     eT log_det_sign = eT(0);

include/armadillo_bits/op_expmat_meat.hpp

@@ -152,7 +152,7 @@ op_expmat::apply_direct(Mat<typename T1::elem_type>& out, const Base<typename T1
     positive = (positive) ? false : true;
     }
   
-  if( (D.is_finite() == false) || (E.is_finite() == false) )  { return false; }
+  if( (D.internal_has_nonfinite()) || (E.internal_has_nonfinite()) )  { return false; }
   
   const bool status = solve(out, D, E, solve_opts::no_approx);
   

include/armadillo_bits/op_find_meat.hpp

@@ -520,6 +520,8 @@ op_find_finite::apply(Mat<uword>& out, const mtOp<uword, T1, op_find_finite>& X)
   {
   arma_extra_debug_sigprint();
   
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "find_finite(): detection of non-finite values is not reliable in fast math mode"); }
+  
   const Proxy<T1> P(X.m);
   
   const uword n_elem = P.get_n_elem();
@@ -566,6 +568,8 @@ op_find_nonfinite::apply(Mat<uword>& out, const mtOp<uword, T1, op_find_nonfinit
   {
   arma_extra_debug_sigprint();
   
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "find_nonfinite(): detection of non-finite values is not reliable in fast math mode"); }
+  
   const Proxy<T1> P(X.m);
   
   const uword n_elem = P.get_n_elem();
@@ -612,6 +616,8 @@ op_find_nan::apply(Mat<uword>& out, const mtOp<uword, T1, op_find_nan>& X)
   {
   arma_extra_debug_sigprint();
   
+  if(arma_config::fast_math)  { arma_debug_warn_level(2, "find_nan(): detection of non-finite values is not reliable in fast math mode"); }
+  
   const Proxy<T1> P(X.m);
   
   const uword n_elem = P.get_n_elem();

include/armadillo_bits/op_logmat_meat.hpp

@@ -426,7 +426,7 @@ op_logmat_cx::helper(Mat<eT>& A, const uword m)
   {
   arma_extra_debug_sigprint();
   
-  if(A.is_finite() == false)  { return false; }
+  if(A.internal_has_nonfinite())  { return false; }
   
   const vec indices = regspace<vec>(1,m-1);
   

include/armadillo_bits/op_mean_meat.hpp

@@ -194,7 +194,7 @@ op_mean::apply_noalias_proxy(Mat<typename T1::elem_type>& out, const Proxy<T1>&
     out /= T(P_n_cols);
     }
   
-  if(out.is_finite() == false)
+  if(out.internal_has_nonfinite())
     {
     // TODO: replace with dedicated handling to avoid unwrapping
     op_mean::apply_noalias_unwrap(out, P, dim);

include/armadillo_bits/op_median_meat.hpp

@@ -34,8 +34,8 @@ op_median::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_median>& expr)
   
   const uword dim = expr.aux_uword_a;
   
-  arma_debug_check( U.M.has_nan(), "median(): detected NaN"                   );
-  arma_debug_check( (dim > 1),     "median(): parameter 'dim' must be 0 or 1" );
+  arma_debug_check( U.M.internal_has_nan(), "median(): detected NaN"                   );
+  arma_debug_check( (dim > 1),              "median(): parameter 'dim' must be 0 or 1" );
   
   if(U.is_alias(out))
     {
@@ -202,7 +202,7 @@ op_median::median_vec
     return Datum<eT>::nan;
     }
   
-  arma_debug_check( U.M.has_nan(), "median(): detected NaN" );
+  arma_debug_check( U.M.internal_has_nan(), "median(): detected NaN" );
   
   std::vector<eT> tmp_vec(n_elem);
   
@@ -239,7 +239,7 @@ op_median::median_vec
     return Datum<eT>::nan;
     }
   
-  arma_debug_check( U.M.has_nan(), "median(): detected NaN" );
+  arma_debug_check( U.M.internal_has_nan(), "median(): detected NaN" );
   
   std::vector< arma_cx_median_packet<T> > tmp_vec(n_elem);
   

include/armadillo_bits/op_norm2est_meat.hpp

@@ -116,7 +116,7 @@ op_norm2est::norm2est
   
   if(A.n_elem == 0)  { return T(0); }
   
-  if(A.is_finite() == false)  { arma_debug_warn_level(1, "norm2est(): given matrix has non-finite elements"); }
+  if(A.internal_has_nonfinite())  { arma_debug_warn_level(1, "norm2est(): given matrix has non-finite elements"); }
   
   if((A.n_rows == 1) || (A.n_cols == 1))  { return op_norm::vec_norm_2( Proxy< Mat<eT> >(A) ); }
   
@@ -138,7 +138,7 @@ op_norm2est::norm2est
     
     T x_norm = op_norm::vec_norm_2( Proxy< Col<eT> >(x) );
     
-    if(x_norm == T(0) || (arma_isfinite(x_norm) == false) || (x.is_finite() == false))
+    if(x_norm == T(0) || (arma_isfinite(x_norm) == false) || (x.internal_has_nonfinite()))
       {
       randu_filler.fill(x.memptr(), x.n_elem);
       
@@ -196,7 +196,7 @@ op_norm2est::norm2est
   
   if(A.n_nonzero == 0)  { return T(0); }
   
-  if(A.is_finite() == false)  { arma_debug_warn_level(1, "norm2est(): given matrix has non-finite elements"); }
+  if(A.internal_has_nonfinite())  { arma_debug_warn_level(1, "norm2est(): given matrix has non-finite elements"); }
   
   if((A.n_rows == 1) || (A.n_cols == 1))  { return spop_norm::vec_norm_k(A.values, A.n_nonzero, 2); }
   
@@ -218,7 +218,7 @@ op_norm2est::norm2est
     
     T x_norm = op_norm::vec_norm_2( Proxy< Mat<eT> >(x) );
     
-    if(x_norm == T(0) || (arma_isfinite(x_norm) == false) || (x.is_finite() == false))
+    if(x_norm == T(0) || (arma_isfinite(x_norm) == false) || (x.internal_has_nonfinite()))
       {
       randu_filler.fill(x.memptr(), x.n_elem);
       

include/armadillo_bits/op_norm_meat.hpp

@@ -879,7 +879,7 @@ op_norm::mat_norm_2(const Mat<eT>& X)
   
   typedef typename get_pod_type<eT>::result T;
   
-  if(X.is_finite() == false)  { arma_debug_warn_level(1, "norm(): given matrix has non-finite elements"); }
+  if(X.internal_has_nonfinite())  { arma_debug_warn_level(1, "norm(): given matrix has non-finite elements"); }
   
   Col<T> S;
   svd(S, X);

include/armadillo_bits/op_roots_meat.hpp

@@ -83,7 +83,7 @@ op_roots::apply_noalias(Mat< std::complex<typename get_pod_type<eT>::result> >&
   
   arma_debug_check( (X.is_vec() == false), "roots(): given object must be a vector" );
   
-  if(X.is_finite() == false)  { return false; }
+  if(X.internal_has_nonfinite())  { return false; }
   
   // treat X as a column vector
   

include/armadillo_bits/op_sort_meat.hpp

@@ -177,9 +177,9 @@ op_sort::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_sort>& in)
   const uword sort_type = in.aux_uword_a;
   const uword dim       = in.aux_uword_b;
   
-  arma_debug_check( (sort_type > 1), "sort(): parameter 'sort_type' must be 0 or 1" );
-  arma_debug_check( (dim > 1),       "sort(): parameter 'dim' must be 0 or 1"       );
-  arma_debug_check( (X.has_nan()),   "sort(): detected NaN"                         );
+  arma_debug_check( (sort_type > 1),        "sort(): parameter 'sort_type' must be 0 or 1" );
+  arma_debug_check( (dim > 1),              "sort(): parameter 'dim' must be 0 or 1"       );
+  arma_debug_check( (X.internal_has_nan()), "sort(): detected NaN"                         );
   
   if(U.is_alias(out))
     {
@@ -211,8 +211,8 @@ op_sort_vec::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_sort_vec>& i
   
   const uword sort_type = in.aux_uword_a;
   
-  arma_debug_check( (sort_type > 1), "sort(): parameter 'sort_type' must be 0 or 1" );
-  arma_debug_check( (X.has_nan()),   "sort(): detected NaN"                         );
+  arma_debug_check( (sort_type > 1),        "sort(): parameter 'sort_type' must be 0 or 1" );
+  arma_debug_check( (X.internal_has_nan()), "sort(): detected NaN"                         );
   
   out = X;  // not checking for aliasing, to allow inplace sorting of vectors
   

include/armadillo_bits/running_stat_vec_meat.hpp

@@ -98,7 +98,7 @@ running_stat_vec<obj_type>::operator() (const Base<typename running_stat_vec<obj
     return;
     }
   
-  if( sample.is_finite() == false )
+  if( sample.internal_has_nonfinite() )
     {
     arma_debug_warn_level(3, "running_stat_vec: sample ignored as it has non-finite elements");
     return;
@@ -126,7 +126,7 @@ running_stat_vec<obj_type>::operator() (const Base< std::complex<typename runnin
     return;
     }
   
-  if( sample.is_finite() == false )
+  if( sample.internal_has_nonfinite() )
     {
     arma_debug_warn_level(3, "running_stat_vec: sample ignored as it has non-finite elements");
     return;

include/armadillo_bits/sp_auxlib_meat.hpp

@@ -73,7 +73,7 @@ sp_auxlib::eigs_sym(Col<eT>& eigval, Mat<eT>& eigvec, const SpBase<eT, T1>& X, c
     if(is_cx<eT>::yes)  { arma_debug_warn_level(1, "eigs_sym(): given matrix is not hermitian"); }
     }
   
-  if(arma_config::check_nonfinite && U.M.has_nonfinite())
+  if(arma_config::check_nonfinite && U.M.internal_has_nonfinite())
     {
     arma_debug_warn_level(3, "eigs_sym(): detected non-finite elements");
     return false;
@@ -126,7 +126,7 @@ sp_auxlib::eigs_sym(Col<eT>& eigval, Mat<eT>& eigvec, const SpBase<eT, T1>& X, c
     if(is_cx<eT>::yes)  { arma_debug_warn_level(1, "eigs_sym(): given matrix is not hermitian"); }
     }
   
-  if(arma_config::check_nonfinite && U.M.has_nonfinite())
+  if(arma_config::check_nonfinite && U.M.internal_has_nonfinite())
     {
     arma_debug_warn_level(3, "eigs_sym(): detected non-finite elements");
     return false;
@@ -534,7 +534,7 @@ sp_auxlib::eigs_gen(Col< std::complex<T> >& eigval, Mat< std::complex<T> >& eigv
   
   arma_debug_check( (U.M.is_square() == false), "eigs_gen(): given matrix must be square sized" );
   
-  if(arma_config::check_nonfinite && U.M.has_nonfinite())
+  if(arma_config::check_nonfinite && U.M.internal_has_nonfinite())
     {
     arma_debug_warn_level(3, "eigs_gen(): detected non-finite elements");
     return false;
@@ -581,7 +581,7 @@ sp_auxlib::eigs_gen(Col< std::complex<T> >& eigval, Mat< std::complex<T> >& eigv
   
   arma_debug_check( (U.M.is_square() == false), "eigs_gen(): given matrix must be square sized" );
   
-  if(arma_config::check_nonfinite && U.M.has_nonfinite())
+  if(arma_config::check_nonfinite && U.M.internal_has_nonfinite())
     {
     arma_debug_warn_level(3, "eigs_gen(): detected non-finite elements");
     return false;
@@ -961,7 +961,7 @@ sp_auxlib::eigs_gen(Col< std::complex<T> >& eigval, Mat< std::complex<T> >& eigv
   
   arma_debug_check( (U.M.is_square() == false), "eigs_gen(): given matrix must be square sized" );
   
-  if(arma_config::check_nonfinite && U.M.has_nonfinite())
+  if(arma_config::check_nonfinite && U.M.internal_has_nonfinite())
     {
     arma_debug_warn_level(3, "eigs_gen(): detected non-finite elements");
     return false;
@@ -986,7 +986,7 @@ sp_auxlib::eigs_gen(Col< std::complex<T> >& eigval, Mat< std::complex<T> >& eigv
   
   arma_debug_check( (U.M.is_square() == false), "eigs_gen(): given matrix must be square sized" );
   
-  if(arma_config::check_nonfinite && U.M.has_nonfinite())
+  if(arma_config::check_nonfinite && U.M.internal_has_nonfinite())
     {
     arma_debug_warn_level(3, "eigs_gen(): detected non-finite elements");
     return false;
@@ -1190,7 +1190,7 @@ sp_auxlib::spsolve_simple(Mat<typename T1::elem_type>& X, const SpBase<typename
     
     if(A.n_nonzero == uword(0))  { X.soft_reset(); return false; }
     
-    if(arma_config::check_nonfinite && (A.has_nonfinite() || X.has_nonfinite()))
+    if(arma_config::check_nonfinite && (A.internal_has_nonfinite() || X.internal_has_nonfinite()))
       {
       arma_debug_warn_level(3, "spsolve(): detected non-finite elements");
       return false;
@@ -1315,7 +1315,7 @@ sp_auxlib::spsolve_refine(Mat<typename T1::elem_type>& X, typename T1::pod_type&
     
     if(A.n_nonzero == uword(0))  { X.soft_reset(); return false; }
     
-    if(arma_config::check_nonfinite && (A.has_nonfinite() || X.has_nonfinite()))
+    if(arma_config::check_nonfinite && (A.internal_has_nonfinite() || X.internal_has_nonfinite()))
       {
       arma_debug_warn_level(3, "spsolve(): detected non-finite elements");
       return false;

include/armadillo_bits/spop_mean_meat.hpp

@@ -125,7 +125,7 @@ spop_mean::apply_noalias_fast
     out = acc;
     }
   
-  if(out.is_finite() == false)
+  if(out.internal_has_nonfinite())
     {
     spop_mean::apply_noalias_slow(out, p, dim);
     }