From cf6fa0ea3bebca4dd81e08256e3a9bfd77845c09 Mon Sep 17 00:00:00 2001 From: conrad Date: Sat, 10 Jun 2023 12:00:08 +1000 Subject: [PATCH] emit warnings when attempting to detect non-finite values in fast math mode --- include/armadillo_bits/BaseCube_meat.hpp | 12 +++- include/armadillo_bits/Base_meat.hpp | 12 +++- include/armadillo_bits/Cube_bones.hpp | 5 ++ include/armadillo_bits/Cube_meat.hpp | 62 +++++++++++++++- include/armadillo_bits/Mat_bones.hpp | 5 ++ include/armadillo_bits/Mat_meat.hpp | 64 ++++++++++++++++- include/armadillo_bits/SpBase_meat.hpp | 12 +++- include/armadillo_bits/SpMat_bones.hpp | 5 ++ include/armadillo_bits/SpMat_meat.hpp | 64 +++++++++++++++-- include/armadillo_bits/arma_config.hpp | 7 ++ include/armadillo_bits/auxlib_meat.hpp | 72 +++++++++---------- include/armadillo_bits/debug.hpp | 1 + include/armadillo_bits/glue_quantile_meat.hpp | 4 +- include/armadillo_bits/gmm_diag_meat.hpp | 28 ++++---- include/armadillo_bits/gmm_full_meat.hpp | 26 +++---- include/armadillo_bits/op_expmat_meat.hpp | 2 +- include/armadillo_bits/op_find_meat.hpp | 6 ++ include/armadillo_bits/op_logmat_meat.hpp | 2 +- include/armadillo_bits/op_mean_meat.hpp | 2 +- include/armadillo_bits/op_median_meat.hpp | 8 +-- include/armadillo_bits/op_norm2est_meat.hpp | 8 +-- include/armadillo_bits/op_norm_meat.hpp | 2 +- include/armadillo_bits/op_roots_meat.hpp | 2 +- include/armadillo_bits/op_sort_meat.hpp | 10 +-- .../armadillo_bits/running_stat_vec_meat.hpp | 4 +- include/armadillo_bits/sp_auxlib_meat.hpp | 16 ++--- include/armadillo_bits/spop_mean_meat.hpp | 2 +- 27 files changed, 330 insertions(+), 113 deletions(-) diff --git a/include/armadillo_bits/BaseCube_meat.hpp b/include/armadillo_bits/BaseCube_meat.hpp index eaf06a0c..1655534a 100644 --- a/include/armadillo_bits/BaseCube_meat.hpp +++ b/include/armadillo_bits/BaseCube_meat.hpp @@ -308,13 +308,15 @@ BaseCube::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 P( (*this).get_ref() ); if(is_Cube::stored_type>::value) { const unwrap_cube::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::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 P( (*this).get_ref() ); if(is_Cube::stored_type>::value) { const unwrap_cube::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::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 P( (*this).get_ref() ); if(is_Cube::stored_type>::value) { const unwrap_cube::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(); diff --git a/include/armadillo_bits/Base_meat.hpp b/include/armadillo_bits/Base_meat.hpp index 77a7e30b..b4ea0b8c 100644 --- a/include/armadillo_bits/Base_meat.hpp +++ b/include/armadillo_bits/Base_meat.hpp @@ -665,13 +665,15 @@ Base::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 P( (*this).get_ref() ); if(is_Mat::stored_type>::value) { const quasi_unwrap::stored_type> U(P.Q); - return arrayops::is_finite( U.M.memptr(), U.M.n_elem ); + return U.M.internal_is_finite(); } if(Proxy::use_at == false) @@ -709,13 +711,15 @@ Base::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 P( (*this).get_ref() ); if(is_Mat::stored_type>::value) { const quasi_unwrap::stored_type> U(P.Q); - return arrayops::has_inf( U.M.memptr(), U.M.n_elem ); + return U.M.internal_has_inf(); } if(Proxy::use_at == false) @@ -753,13 +757,15 @@ Base::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 P( (*this).get_ref() ); if(is_Mat::stored_type>::value) { const quasi_unwrap::stored_type> U(P.Q); - return arrayops::has_nan( U.M.memptr(), U.M.n_elem ); + return U.M.internal_has_nan(); } if(Proxy::use_at == false) diff --git a/include/armadillo_bits/Cube_bones.hpp b/include/armadillo_bits/Cube_bones.hpp index 4e8630f1..86782e57 100644 --- a/include/armadillo_bits/Cube_bones.hpp +++ b/include/armadillo_bits/Cube_bones.hpp @@ -317,6 +317,11 @@ class Cube : public BaseCube< eT, Cube > 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; diff --git a/include/armadillo_bits/Cube_meat.hpp b/include/armadillo_bits/Cube_meat.hpp index 4fbc3dcf..4182356d 100644 --- a/include/armadillo_bits/Cube_meat.hpp +++ b/include/armadillo_bits/Cube_meat.hpp @@ -3638,7 +3638,9 @@ Cube::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::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::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::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 +inline +bool +Cube::internal_is_finite() const + { + arma_extra_debug_sigprint(); + + return arrayops::is_finite(memptr(), n_elem); + } + + + +template +inline +bool +Cube::internal_has_inf() const + { + arma_extra_debug_sigprint(); + + return arrayops::has_inf(memptr(), n_elem); + } + + + +template +inline +bool +Cube::internal_has_nan() const + { + arma_extra_debug_sigprint(); + + return arrayops::has_nan(memptr(), n_elem); + } + + + +template +inline +bool +Cube::internal_has_nonfinite() const + { + arma_extra_debug_sigprint(); + return (arrayops::is_finite(memptr(), n_elem) == false); } diff --git a/include/armadillo_bits/Mat_bones.hpp b/include/armadillo_bits/Mat_bones.hpp index b0c47f9c..03e7b1ce 100644 --- a/include/armadillo_bits/Mat_bones.hpp +++ b/include/armadillo_bits/Mat_bones.hpp @@ -430,6 +430,11 @@ class Mat : public Base< eT, Mat > 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; diff --git a/include/armadillo_bits/Mat_meat.hpp b/include/armadillo_bits/Mat_meat.hpp index 77f69637..67edb440 100644 --- a/include/armadillo_bits/Mat_meat.hpp +++ b/include/armadillo_bits/Mat_meat.hpp @@ -6251,7 +6251,11 @@ inline bool Mat::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::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::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::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 +inline +bool +Mat::internal_is_finite() const + { + arma_extra_debug_sigprint(); + + return arrayops::is_finite(memptr(), n_elem); + } + + + +template +inline +bool +Mat::internal_has_inf() const + { + arma_extra_debug_sigprint(); + + return arrayops::has_inf(memptr(), n_elem); + } + + + +template +inline +bool +Mat::internal_has_nan() const + { + arma_extra_debug_sigprint(); + + return arrayops::has_nan(memptr(), n_elem); + } + + + +template +inline +bool +Mat::internal_has_nonfinite() const + { + arma_extra_debug_sigprint(); + return (arrayops::is_finite(memptr(), n_elem) == false); } diff --git a/include/armadillo_bits/SpBase_meat.hpp b/include/armadillo_bits/SpBase_meat.hpp index eced75ac..c8c545bc 100644 --- a/include/armadillo_bits/SpBase_meat.hpp +++ b/include/armadillo_bits/SpBase_meat.hpp @@ -731,13 +731,15 @@ SpBase::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 P( (*this).get_ref() ); if(is_SpMat::stored_type>::value) { const unwrap_spmat::stored_type> U(P.Q); - return U.M.is_finite(); + return U.M.internal_is_finite(); } else { @@ -763,13 +765,15 @@ SpBase::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 P( (*this).get_ref() ); if(is_SpMat::stored_type>::value) { const unwrap_spmat::stored_type> U(P.Q); - return U.M.has_inf(); + return U.M.internal_has_inf(); } else { @@ -795,13 +799,15 @@ SpBase::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 P( (*this).get_ref() ); if(is_SpMat::stored_type>::value) { const unwrap_spmat::stored_type> U(P.Q); - return U.M.has_nan(); + return U.M.internal_has_nan(); } else { diff --git a/include/armadillo_bits/SpMat_bones.hpp b/include/armadillo_bits/SpMat_bones.hpp index 63b9810b..050134ad 100644 --- a/include/armadillo_bits/SpMat_bones.hpp +++ b/include/armadillo_bits/SpMat_bones.hpp @@ -313,6 +313,11 @@ class SpMat : public SpBase< eT, SpMat > 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; diff --git a/include/armadillo_bits/SpMat_meat.hpp b/include/armadillo_bits/SpMat_meat.hpp index 47c9a864..dda8c1db 100644 --- a/include/armadillo_bits/SpMat_meat.hpp +++ b/include/armadillo_bits/SpMat_meat.hpp @@ -3403,9 +3403,9 @@ SpMat::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::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 +inline +bool +SpMat::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 +inline +bool +SpMat::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 +inline +bool +SpMat::internal_is_finite() const + { + arma_extra_debug_sigprint(); + + sync_csc(); + + return arrayops::is_finite(values, n_nonzero); + } + + + +template +inline +bool +SpMat::internal_has_inf() const + { + arma_extra_debug_sigprint(); + sync_csc(); return arrayops::has_inf(values, n_nonzero); @@ -3519,7 +3575,7 @@ SpMat::has_inf() const template inline bool -SpMat::has_nan() const +SpMat::internal_has_nan() const { arma_extra_debug_sigprint(); @@ -3533,7 +3589,7 @@ SpMat::has_nan() const template inline bool -SpMat::has_nonfinite() const +SpMat::internal_has_nonfinite() const { arma_extra_debug_sigprint(); diff --git a/include/armadillo_bits/arma_config.hpp b/include/armadillo_bits/arma_config.hpp index 703b06e1..3f7b7f9d 100644 --- a/include/armadillo_bits/arma_config.hpp +++ b/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; }; diff --git a/include/armadillo_bits/auxlib_meat.hpp b/include/armadillo_bits/auxlib_meat.hpp index 9b68c587..7e6b5135 100644 --- a/include/armadillo_bits/auxlib_meat.hpp +++ b/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& S, Mat& 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& S, Mat< std::complex >& 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& U, Col& S, Mat& V, Mat& 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 >& U, Col& S, Mat< std::complex >& 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& U, Col& S, Mat& V, Mat& 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 >& U, Col& S, Mat< std::complex >& 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& S, Mat& 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& S, Mat< std::complex >& 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& U, Col& S, Mat& V, Mat& 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 >& U, Col& S, Mat< std::complex >& 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& U, Col& S, Mat& V, Mat& 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 >& U, Col& S, Mat< std::complex > { typedef std::complex 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& out, Mat >& 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& A, Mat& B, Mat& vsl, Mat& vsr, const Base& 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 >& A, Mat< std::complex >& 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); diff --git a/include/armadillo_bits/debug.hpp b/include/armadillo_bits/debug.hpp index 362c0eb5..4fed90e5 100644 --- a/include/armadillo_bits/debug.hpp +++ b/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'; diff --git a/include/armadillo_bits/glue_quantile_meat.hpp b/include/armadillo_bits/glue_quantile_meat.hpp index 6f456c62..370e432a 100644 --- a/include/armadillo_bits/glue_quantile_meat.hpp +++ b/include/armadillo_bits/glue_quantile_meat.hpp @@ -178,7 +178,7 @@ glue_quantile::apply(Mat& out, const mtGlue UA(expr.A); const quasi_unwrap 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& out, const mtGlue::set_params(const Base& in_means_expr, const Base& 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::set_means(const Base& in_means_expr) const Mat& 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::set_dcovs(const Base& in_dcovs_expr) const Mat& 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::set_hefts(const Base& in_hefts_expr) const Mat& 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::learn const unwrap tmp_X(data.get_ref()); const Mat& 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::kmeans_wrapper const unwrap tmp_X(data.get_ref()); const Mat& 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::km_iterate(const Mat& 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::em_iterate(const Mat& 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; } diff --git a/include/armadillo_bits/gmm_full_meat.hpp b/include/armadillo_bits/gmm_full_meat.hpp index 3e3abc5c..5bbcce06 100644 --- a/include/armadillo_bits/gmm_full_meat.hpp +++ b/include/armadillo_bits/gmm_full_meat.hpp @@ -151,9 +151,9 @@ gmm_full::set_params(const Base& in_means_expr, const BaseCube "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::set_means(const Base& in_means_expr) const Mat& 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::set_fcovs(const BaseCube& in_fcovs_expr) const Cube& 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::set_hefts(const Base& in_hefts_expr) const Mat& 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::learn const unwrap tmp_X(data.get_ref()); const Mat& 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::km_iterate(const Mat& 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::em_iterate(const Mat& 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::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); diff --git a/include/armadillo_bits/op_expmat_meat.hpp b/include/armadillo_bits/op_expmat_meat.hpp index 0f03412c..d45fb36d 100644 --- a/include/armadillo_bits/op_expmat_meat.hpp +++ b/include/armadillo_bits/op_expmat_meat.hpp @@ -152,7 +152,7 @@ op_expmat::apply_direct(Mat& out, const Base& out, const mtOp& 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 P(X.m); const uword n_elem = P.get_n_elem(); @@ -566,6 +568,8 @@ op_find_nonfinite::apply(Mat& out, const mtOp P(X.m); const uword n_elem = P.get_n_elem(); @@ -612,6 +616,8 @@ op_find_nan::apply(Mat& out, const mtOp& 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 P(X.m); const uword n_elem = P.get_n_elem(); diff --git a/include/armadillo_bits/op_logmat_meat.hpp b/include/armadillo_bits/op_logmat_meat.hpp index 2edd1ca6..494f747a 100644 --- a/include/armadillo_bits/op_logmat_meat.hpp +++ b/include/armadillo_bits/op_logmat_meat.hpp @@ -426,7 +426,7 @@ op_logmat_cx::helper(Mat& 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(1,m-1); diff --git a/include/armadillo_bits/op_mean_meat.hpp b/include/armadillo_bits/op_mean_meat.hpp index 6c216f14..7e7a49d3 100644 --- a/include/armadillo_bits/op_mean_meat.hpp +++ b/include/armadillo_bits/op_mean_meat.hpp @@ -194,7 +194,7 @@ op_mean::apply_noalias_proxy(Mat& out, const Proxy& 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); diff --git a/include/armadillo_bits/op_median_meat.hpp b/include/armadillo_bits/op_median_meat.hpp index 8ea6bacb..ae805153 100644 --- a/include/armadillo_bits/op_median_meat.hpp +++ b/include/armadillo_bits/op_median_meat.hpp @@ -34,8 +34,8 @@ op_median::apply(Mat& out, const Op& 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::nan; } - arma_debug_check( U.M.has_nan(), "median(): detected NaN" ); + arma_debug_check( U.M.internal_has_nan(), "median(): detected NaN" ); std::vector tmp_vec(n_elem); @@ -239,7 +239,7 @@ op_median::median_vec return Datum::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 > tmp_vec(n_elem); diff --git a/include/armadillo_bits/op_norm2est_meat.hpp b/include/armadillo_bits/op_norm2est_meat.hpp index fd3971ff..b809d134 100644 --- a/include/armadillo_bits/op_norm2est_meat.hpp +++ b/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 >(A) ); } @@ -138,7 +138,7 @@ op_norm2est::norm2est T x_norm = op_norm::vec_norm_2( Proxy< Col >(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 >(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); diff --git a/include/armadillo_bits/op_norm_meat.hpp b/include/armadillo_bits/op_norm_meat.hpp index 463075e1..8c6f8c49 100644 --- a/include/armadillo_bits/op_norm_meat.hpp +++ b/include/armadillo_bits/op_norm_meat.hpp @@ -879,7 +879,7 @@ op_norm::mat_norm_2(const Mat& X) typedef typename get_pod_type::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 S; svd(S, X); diff --git a/include/armadillo_bits/op_roots_meat.hpp b/include/armadillo_bits/op_roots_meat.hpp index c6b8d938..1e091205 100644 --- a/include/armadillo_bits/op_roots_meat.hpp +++ b/include/armadillo_bits/op_roots_meat.hpp @@ -83,7 +83,7 @@ op_roots::apply_noalias(Mat< std::complex::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 diff --git a/include/armadillo_bits/op_sort_meat.hpp b/include/armadillo_bits/op_sort_meat.hpp index c8e18641..7a0ec6bf 100644 --- a/include/armadillo_bits/op_sort_meat.hpp +++ b/include/armadillo_bits/op_sort_meat.hpp @@ -177,9 +177,9 @@ op_sort::apply(Mat& out, const Op& 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& out, const Op& 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 diff --git a/include/armadillo_bits/running_stat_vec_meat.hpp b/include/armadillo_bits/running_stat_vec_meat.hpp index 9a725b1f..370fcf73 100644 --- a/include/armadillo_bits/running_stat_vec_meat.hpp +++ b/include/armadillo_bits/running_stat_vec_meat.hpp @@ -98,7 +98,7 @@ running_stat_vec::operator() (const Base::operator() (const Base< std::complex& eigval, Mat& eigvec, const SpBase& X, c if(is_cx::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& eigval, Mat& eigvec, const SpBase& X, c if(is_cx::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 >& eigval, Mat< std::complex >& 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 >& eigval, Mat< std::complex >& 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 >& eigval, Mat< std::complex >& 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 >& eigval, Mat< std::complex >& 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& X, const SpBase& 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; diff --git a/include/armadillo_bits/spop_mean_meat.hpp b/include/armadillo_bits/spop_mean_meat.hpp index e1413ace..dd979166 100644 --- a/include/armadillo_bits/spop_mean_meat.hpp +++ b/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); }