arma_hot inline void arma_check(const bool state, const T1& x) { if(state) { arma_stop_logic_error(arma_str::str_wrapper(x)); } }
arma_hot inline void arma_check(const bool state, const T1& x, const T2& y) { if(state) { arma_stop_logic_error( std::string(x) + std::string(y) ); } }
inline typename T1::pod_type op_norm::mat_norm_2(const SpProxy<T1>& P, const typename arma_cx_only<typename T1::elem_type>::result* junk) { arma_extra_debug_sigprint(); arma_ignore(junk); typedef typename T1::elem_type eT; typedef typename T1::pod_type T; // we're calling eigs_gen(), which currently requires ARPACK #if !defined(ARMA_USE_ARPACK) { arma_stop_logic_error("norm(): use of ARPACK must be enabled for norm of complex matrices"); return T(0); } #endif const unwrap_spmat<typename SpProxy<T1>::stored_type> tmp(P.Q); const SpMat<eT>& A = tmp.M; const SpMat<eT> B = trans(A); const SpMat<eT> C = (A.n_rows <= A.n_cols) ? (A*B) : (B*A); Col<eT> eigval; eigs_gen(eigval, C, 1); return (eigval.n_elem > 0) ? std::sqrt(std::real(eigval[0])) : T(0); }
arma_inline static typename get_pod_type<eT>::result get(const eT& val) { arma_ignore(val); arma_stop_logic_error("newarp::SortingTarget: incompatible selection rule"); typedef typename get_pod_type<eT>::result out_T; return out_T(0); }
arma_hot inline void arma_assert_same_size(const uword A_n_rows, const uword A_n_cols, const uword A_n_slices, const uword B_n_rows, const uword B_n_cols, const uword B_n_slices, const char* x) { if( (A_n_rows != B_n_rows) || (A_n_cols != B_n_cols) || (A_n_slices != B_n_slices) ) { arma_stop_logic_error( arma_incompat_size_string(A_n_rows, A_n_cols, A_n_slices, B_n_rows, B_n_cols, B_n_slices, x) ); } }
arma_hot inline void arma_assert_mul_size(const subview<eT1>& A, const subview<eT2>& B, const char* x) { if(A.n_cols != B.n_rows) { arma_stop_logic_error( arma_incompat_size_string(A.n_rows, A.n_cols, B.n_rows, B.n_cols, x) ); } }
arma_hot inline void arma_assert_same_size(const Mat<eT1>& A, const subview_cube<eT2>& B, const char* x) { if( (A.n_rows != B.n_rows) || (A.n_cols != B.n_cols) || (1 != B.n_slices) ) { arma_stop_logic_error( arma_incompat_size_string(A.n_rows, A.n_cols, 1, B.n_rows, B.n_cols, B.n_slices, x) ); } }
inline void subview_cube_each_common<eT>::check_size(const Mat<eT>& A) const { if(arma_config::debug) { if( (A.n_rows != P.n_rows) || (A.n_cols != P.n_cols) ) { arma_stop_logic_error( incompat_size_string(A) ); } } }
arma_hot inline void arma_assert_mul_size(const Mat<eT1>& A, const Mat<eT2>& B, const char* x) { const uword A_n_cols = A.n_cols; const uword B_n_rows = B.n_rows; if(A_n_cols != B_n_rows) { arma_stop_logic_error( arma_incompat_size_string(A.n_rows, A_n_cols, B_n_rows, B.n_cols, x) ); } }
arma_hot inline void arma_assert_mul_size(const Mat<eT1>& A, const Mat<eT2>& B, const bool do_trans_A, const bool do_trans_B, const char* x) { const uword final_A_n_cols = (do_trans_A == false) ? A.n_cols : A.n_rows; const uword final_B_n_rows = (do_trans_B == false) ? B.n_rows : B.n_cols; if(final_A_n_cols != final_B_n_rows) { const uword final_A_n_rows = (do_trans_A == false) ? A.n_rows : A.n_cols; const uword final_B_n_cols = (do_trans_B == false) ? B.n_cols : B.n_rows; arma_stop_logic_error( arma_incompat_size_string(final_A_n_rows, final_A_n_cols, final_B_n_rows, final_B_n_cols, x) ); } }
arma_hot inline void arma_assert_trans_mul_size(const uword A_n_rows, const uword A_n_cols, const uword B_n_rows, const uword B_n_cols, const char* x) { const uword final_A_n_cols = (do_trans_A == false) ? A_n_cols : A_n_rows; const uword final_B_n_rows = (do_trans_B == false) ? B_n_rows : B_n_cols; if(final_A_n_cols != final_B_n_rows) { const uword final_A_n_rows = (do_trans_A == false) ? A_n_rows : A_n_cols; const uword final_B_n_cols = (do_trans_B == false) ? B_n_cols : B_n_rows; arma_stop_logic_error( arma_incompat_size_string(final_A_n_rows, final_A_n_cols, final_B_n_rows, final_B_n_cols, x) ); } }
arma_hot inline void arma_assert_same_size(const subview<eT1>& A, const Proxy<eT2>& B, const char* x) { const uword A_n_rows = A.n_rows; const uword A_n_cols = A.n_cols; const uword B_n_rows = B.get_n_rows(); const uword B_n_cols = B.get_n_cols(); if( (A_n_rows != B_n_rows) || (A_n_cols != B_n_cols) ) { arma_stop_logic_error( arma_incompat_size_string(A_n_rows, A_n_cols, B_n_rows, B_n_cols, x) ); } }
inline bool op_sqrtmat_sympd::apply_direct(Mat<typename T1::elem_type>& out, const Base<typename T1::elem_type,T1>& expr) { arma_extra_debug_sigprint(); #if defined(ARMA_USE_LAPACK) { typedef typename T1::pod_type T; typedef typename T1::elem_type eT; const unwrap<T1> U(expr.get_ref()); const Mat<eT>& X = U.M; arma_debug_check( (X.is_square() == false), "sqrtmat_sympd(): given matrix must be square sized" ); Col< T> eigval; Mat<eT> eigvec; const bool status = auxlib::eig_sym_dc(eigval, eigvec, X); if(status == false) { return false; } const uword N = eigval.n_elem; const T* eigval_mem = eigval.memptr(); bool all_pos = true; for(uword i=0; i<N; ++i) { all_pos = (eigval_mem[i] < T(0)) ? false : all_pos; } if(all_pos == false) { return false; } eigval = sqrt(eigval); out = eigvec * diagmat(eigval) * eigvec.t(); return true; } #else { arma_ignore(out); arma_ignore(expr); arma_stop_logic_error("sqrtmat_sympd(): use of LAPACK must be enabled"); return false; } #endif }
static inline eT eval(const eT x) { #if defined(ARMA_USE_CXX11) { return eT( std::arg(x) ); } #else { arma_ignore(x); arma_stop_logic_error("arg(): need C++11 compiler"); return eT(0); } #endif }
arma_inline std::complex<T> arma_atanh(const std::complex<T>& x) { #if defined(ARMA_USE_CXX11) { return std::atanh(x); } #elif defined(ARMA_HAVE_TR1) { return std::tr1::atanh(x); } #else { arma_ignore(x); arma_stop_logic_error("atanh(): need C++11 compiler"); return std::complex<T>(0); } #endif }
inline arma_warn_unused typename enable_if2< is_arma_type<T1>::value, typename T1::pod_type >::result norm ( const T1& X, const char* method, const typename arma_real_or_cx_only<typename T1::elem_type>::result* junk = 0 ) { arma_extra_debug_sigprint(); arma_ignore(junk); typedef typename T1::pod_type T; const Proxy<T1> P(X); if(P.get_n_elem() == 0) { return T(0); } const char sig = (method != NULL) ? method[0] : char(0); const bool is_vec = (T1::is_row) || (T1::is_col) || (P.get_n_rows() == 1) || (P.get_n_cols() == 1); if(is_vec) { if( (sig == 'i') || (sig == 'I') || (sig == '+') ) // max norm { return op_norm::vec_norm_max(P); } else if(sig == '-') // min norm { return op_norm::vec_norm_min(P); } else if( (sig == 'f') || (sig == 'F') ) { return op_norm::vec_norm_2(P); } else { arma_stop_logic_error("norm(): unsupported vector norm type"); return T(0); } } else { if( (sig == 'i') || (sig == 'I') || (sig == '+') ) // inf norm { return op_norm::mat_norm_inf(P); } else if( (sig == 'f') || (sig == 'F') ) { return op_norm::vec_norm_2(P); } else { arma_stop_logic_error("norm(): unsupported matrix norm type"); return T(0); } } }
inline arma_warn_unused typename enable_if2< is_arma_sparse_type<T1>::value, typename T1::pod_type >::result norm ( const T1& X, const char* method, const typename arma_real_or_cx_only<typename T1::elem_type>::result* junk = 0 ) { arma_extra_debug_sigprint(); arma_ignore(junk); typedef typename T1::elem_type eT; typedef typename T1::pod_type T; const SpProxy<T1> P(X); if(P.get_n_nonzero() == 0) { return T(0); } const unwrap_spmat<typename SpProxy<T1>::stored_type> tmp(P.Q); const SpMat<eT>& A = tmp.M; // create a fake dense vector to allow reuse of code for dense vectors Col<eT> fake_vector( access::rwp(A.values), A.n_nonzero, false ); const Proxy< Col<eT> > P_fake_vector(fake_vector); const char sig = (method != NULL) ? method[0] : char(0); const bool is_vec = (P.get_n_rows() == 1) || (P.get_n_cols() == 1); // TODO: (T1::is_row) || (T1::is_col) || ... if(is_vec == true) { if( (sig == 'i') || (sig == 'I') || (sig == '+') ) // max norm { return op_norm::vec_norm_max(P_fake_vector); } else if(sig == '-') // min norm { const T val = op_norm::vec_norm_min(P_fake_vector); if( P.get_n_nonzero() < P.get_n_elem() ) { return (std::min)(T(0), val); } else { return val; } } else if( (sig == 'f') || (sig == 'F') ) { return op_norm::vec_norm_2(P_fake_vector); } else { arma_stop_logic_error("norm(): unsupported vector norm type"); return T(0); } } else { if( (sig == 'i') || (sig == 'I') || (sig == '+') ) // inf norm { return op_norm::mat_norm_inf(P); } else if( (sig == 'f') || (sig == 'F') ) { return op_norm::vec_norm_2(P_fake_vector); } else { arma_stop_logic_error("norm(): unsupported matrix norm type"); return T(0); } } }
inline arma_warn_unused typename enable_if2< is_arma_type<T1>::value, typename T1::pod_type >::result norm ( const T1& X, const uword k = uword(2), const typename arma_real_or_cx_only<typename T1::elem_type>::result* junk = 0 ) { arma_extra_debug_sigprint(); arma_ignore(junk); typedef typename T1::pod_type T; const Proxy<T1> P(X); if(P.get_n_elem() == 0) { return T(0); } const bool is_vec = (T1::is_row) || (T1::is_col) || (P.get_n_rows() == 1) || (P.get_n_cols() == 1); if(is_vec) { switch(k) { case 1: return op_norm::vec_norm_1(P); break; case 2: return op_norm::vec_norm_2(P); break; default: { arma_debug_check( (k == 0), "norm(): k must be greater than zero" ); return op_norm::vec_norm_k(P, int(k)); } } } else { switch(k) { case 1: return op_norm::mat_norm_1(P); break; case 2: return op_norm::mat_norm_2(P); break; default: arma_stop_logic_error("norm(): unsupported matrix norm type"); return T(0); } } return T(0); // prevent erroneous compiler warnings }
inline arma_warn_unused typename enable_if2< is_arma_sparse_type<T1>::value, typename T1::pod_type >::result norm ( const T1& X, const uword k = uword(2), const typename arma_real_or_cx_only<typename T1::elem_type>::result* junk = 0 ) { arma_extra_debug_sigprint(); arma_ignore(junk); typedef typename T1::elem_type eT; typedef typename T1::pod_type T; const SpProxy<T1> P(X); if(P.get_n_nonzero() == 0) { return T(0); } const bool is_vec = (P.get_n_rows() == 1) || (P.get_n_cols() == 1); if(is_vec == true) { const unwrap_spmat<typename SpProxy<T1>::stored_type> tmp(P.Q); const SpMat<eT>& A = tmp.M; // create a fake dense vector to allow reuse of code for dense vectors Col<eT> fake_vector( access::rwp(A.values), A.n_nonzero, false ); const Proxy< Col<eT> > P_fake_vector(fake_vector); switch(k) { case 1: return op_norm::vec_norm_1(P_fake_vector); break; case 2: return op_norm::vec_norm_2(P_fake_vector); break; default: { arma_debug_check( (k == 0), "norm(): k must be greater than zero" ); return op_norm::vec_norm_k(P_fake_vector, int(k)); } } } else { switch(k) { case 1: return op_norm::mat_norm_1(P); break; case 2: return op_norm::mat_norm_2(P); break; default: arma_stop_logic_error("norm(): unsupported or unimplemented norm type for sparse matrices"); return T(0); } } }
arma_warn_unused inline obj_type randg(const uword n_rows, const uword n_cols, const distr_param& param = distr_param(), const typename arma_Mat_Col_Row_only<obj_type>::result* junk = 0) { arma_extra_debug_sigprint(); arma_ignore(junk); #if defined(ARMA_USE_CXX11) { if(is_Col<obj_type>::value == true) { arma_debug_check( (n_cols != 1), "randg(): incompatible size" ); } else if(is_Row<obj_type>::value == true) { arma_debug_check( (n_rows != 1), "randg(): incompatible size" ); } obj_type out(n_rows, n_cols); double a; double b; if(param.state == 0) { a = double(1); b = double(1); } else if(param.state == 1) { a = double(param.a_int); b = double(param.b_int); } else { a = param.a_double; b = param.b_double; } arma_debug_check( ((a <= double(0)) || (b <= double(0))), "randg(): a and b must be greater than zero" ); #if defined(ARMA_USE_EXTERN_CXX11_RNG) { arma_rng_cxx11_instance.randg_fill(out.memptr(), out.n_elem, a, b); } #else { arma_rng_cxx11 local_arma_rng_cxx11_instance; typedef typename arma_rng_cxx11::seed_type seed_type; local_arma_rng_cxx11_instance.set_seed( seed_type(arma_rng::randi<seed_type>()) ); local_arma_rng_cxx11_instance.randg_fill(out.memptr(), out.n_elem, a, b); } #endif return out; } #else { arma_ignore(n_rows); arma_ignore(n_cols); arma_ignore(param); arma_stop_logic_error("randg(): C++11 compiler required"); return obj_type(); } #endif }
inline typename T1::elem_type op_median::median_vec ( const T1& X, const typename arma_cx_only<typename T1::elem_type>::result* junk ) { arma_extra_debug_sigprint(); arma_ignore(junk); typedef typename T1::elem_type eT; typedef typename T1::pod_type T; const Proxy<T1> P(X); const uword n_elem = P.get_n_elem(); if(n_elem == 0) { arma_debug_check(true, "median(): object has no elements"); return Datum<eT>::nan; } std::vector< arma_cx_median_packet<T> > tmp_vec(n_elem); if(Proxy<T1>::use_at == false) { typedef typename Proxy<T1>::ea_type ea_type; ea_type A = P.get_ea(); for(uword i=0; i<n_elem; ++i) { tmp_vec[i].val = std::abs( A[i] ); tmp_vec[i].index = i; } uword index1; uword index2; op_median::direct_cx_median_index(index1, index2, tmp_vec); return op_mean::robust_mean( A[index1], A[index2] ); } else { const uword n_rows = P.get_n_rows(); const uword n_cols = P.get_n_cols(); if(n_cols == 1) { for(uword row=0; row < n_rows; ++row) { tmp_vec[row].val = std::abs( P.at(row,0) ); tmp_vec[row].index = row; } uword index1; uword index2; op_median::direct_cx_median_index(index1, index2, tmp_vec); return op_mean::robust_mean( P.at(index1,0), P.at(index2,0) ); } else if(n_rows == 1) { for(uword col=0; col < n_cols; ++col) { tmp_vec[col].val = std::abs( P.at(0,col) ); tmp_vec[col].index = col; } uword index1; uword index2; op_median::direct_cx_median_index(index1, index2, tmp_vec); return op_mean::robust_mean( P.at(0,index1), P.at(0,index2) ); } else { arma_stop_logic_error("op_median::median_vec(): expected a vector" ); return eT(0); } } }
inline typename T1::elem_type op_median::median_vec ( const T1& X, const typename arma_not_cx<typename T1::elem_type>::result* junk ) { arma_extra_debug_sigprint(); arma_ignore(junk); typedef typename T1::elem_type eT; typedef typename Proxy<T1>::stored_type P_stored_type; const Proxy<T1> P(X); const uword n_elem = P.get_n_elem(); if(n_elem == 0) { arma_debug_check(true, "median(): object has no elements"); return Datum<eT>::nan; } std::vector<eT> tmp_vec(n_elem); if(is_Mat<P_stored_type>::value == true) { const unwrap<P_stored_type> tmp(P.Q); const typename unwrap<P_stored_type>::stored_type& Y = tmp.M; arrayops::copy( &(tmp_vec[0]), Y.memptr(), n_elem ); } else { if(Proxy<T1>::use_at == false) { typedef typename Proxy<T1>::ea_type ea_type; ea_type A = P.get_ea(); for(uword i=0; i<n_elem; ++i) { tmp_vec[i] = A[i]; } } else { const uword n_rows = P.get_n_rows(); const uword n_cols = P.get_n_cols(); if(n_cols == 1) { for(uword row=0; row < n_rows; ++row) { tmp_vec[row] = P.at(row,0); } } else if(n_rows == 1) { for(uword col=0; col < n_cols; ++col) { tmp_vec[col] = P.at(0,col); } } else { arma_stop_logic_error("op_median::median_vec(): expected a vector" ); } } } return op_median::direct_median(tmp_vec); }
inline void arma_assert_cube_as_mat(const Mat<eT>& M, const T1& Q, const char* x, const bool check_compat_size) { const uword Q_n_rows = Q.n_rows; const uword Q_n_cols = Q.n_cols; const uword Q_n_slices = Q.n_slices; const uword M_vec_state = M.vec_state; if(M_vec_state == 0) { if( ( (Q_n_rows == 1) || (Q_n_cols == 1) || (Q_n_slices == 1) ) == false ) { std::stringstream tmp; tmp << x << ": can't interpret cube with dimensions " << Q_n_rows << 'x' << Q_n_cols << 'x' << Q_n_slices << " as a matrix; one of the dimensions must be 1"; arma_stop_logic_error( tmp.str() ); } } else { if(Q_n_slices == 1) { if( (M_vec_state == 1) && (Q_n_cols != 1) ) { std::stringstream tmp; tmp << x << ": can't interpret cube with dimensions " << Q_n_rows << 'x' << Q_n_cols << 'x' << Q_n_slices << " as a column vector"; arma_stop_logic_error( tmp.str() ); } if( (M_vec_state == 2) && (Q_n_rows != 1) ) { std::stringstream tmp; tmp << x << ": can't interpret cube with dimensions " << Q_n_rows << 'x' << Q_n_cols << 'x' << Q_n_slices << " as a row vector"; arma_stop_logic_error( tmp.str() ); } } else { if( (Q_n_cols != 1) && (Q_n_rows != 1) ) { std::stringstream tmp; tmp << x << ": can't interpret cube with dimensions " << Q_n_rows << 'x' << Q_n_cols << 'x' << Q_n_slices << " as a vector"; arma_stop_logic_error( tmp.str() ); } } } if(check_compat_size == true) { const uword M_n_rows = M.n_rows; const uword M_n_cols = M.n_cols; if(M_vec_state == 0) { if( ( ( (Q_n_rows == M_n_rows) && (Q_n_cols == M_n_cols) ) || ( (Q_n_rows == M_n_rows) && (Q_n_slices == M_n_cols) ) || ( (Q_n_cols == M_n_rows) && (Q_n_slices == M_n_cols) ) ) == false ) { std::stringstream tmp; tmp << x << ": can't interpret cube with dimensions " << Q_n_rows << 'x' << Q_n_cols << 'x' << Q_n_slices << " as a matrix with dimensions " << M_n_rows << 'x' << M_n_cols; arma_stop_logic_error( tmp.str() ); } } else { if(Q_n_slices == 1) { if( (M_vec_state == 1) && (Q_n_rows != M_n_rows) ) { std::stringstream tmp; tmp << x << ": can't interpret cube with dimensions " << Q_n_rows << 'x' << Q_n_cols << 'x' << Q_n_slices << " as a column vector with dimensions " << M_n_rows << 'x' << M_n_cols; arma_stop_logic_error( tmp.str() ); } if( (M_vec_state == 2) && (Q_n_cols != M_n_cols) ) { std::stringstream tmp; tmp << x << ": can't interpret cube with dimensions " << Q_n_rows << 'x' << Q_n_cols << 'x' << Q_n_slices << " as a row vector with dimensions " << M_n_rows << 'x' << M_n_cols; arma_stop_logic_error( tmp.str() ); } } else { if( ( (M_n_cols == Q_n_slices) || (M_n_rows == Q_n_slices) ) == false ) { std::stringstream tmp; tmp << x << ": can't interpret cube with dimensions " << Q_n_rows << 'x' << Q_n_cols << 'x' << Q_n_slices << " as a vector with dimensions " << M_n_rows << 'x' << M_n_cols; arma_stop_logic_error( tmp.str() ); } } } } }