inline const Col<eT>& Col<eT>::fixed<fixed_n_elem>::operator=(const eGlue<T1, T2, eglue_type>& X) { arma_extra_debug_sigprint(); arma_type_check(( is_same_type< eT, typename T1::elem_type >::no )); arma_type_check(( is_same_type< eT, typename T2::elem_type >::no )); const bool bad_alias = ( (eGlue<T1, T2, eglue_type>::proxy1_type::has_subview && X.P1.is_alias(*this)) || (eGlue<T1, T2, eglue_type>::proxy2_type::has_subview && X.P2.is_alias(*this)) ); if(bad_alias == false) { arma_debug_assert_same_size(fixed_n_elem, uword(1), X.get_n_rows(), X.get_n_cols(), "Col::fixed::operator="); eglue_type::apply(*this, X); } else { arma_extra_debug_print("bad_alias = true"); Col<eT> tmp(X); (*this) = tmp; } return *this; }
arma_inline eT cblas_cx_dot(const int N, const eT* X, const eT* Y) { arma_type_check((is_supported_blas_type<eT>::value == false)); if(is_supported_complex_float<eT>::value) { typedef typename std::complex<float> T; T out; arma_wrapper(cblas_cdotu_sub)(N, (const T*)X, 1, (const T*)Y, 1, &out); return eT(out); } else if(is_supported_complex_double<eT>::value) { typedef typename std::complex<double> T; T out; arma_wrapper(cblas_zdotu_sub)(N, (const T*)X, 1, (const T*)Y, 1, &out); return eT(out); } return eT(0); }
inline void gssv(superlu_options_t* options, SuperMatrix* A, int* perm_c, int* perm_r, SuperMatrix* L, SuperMatrix* U, SuperMatrix* B, SuperLUStat_t* stat, int* info) { arma_type_check(( is_supported_blas_type<eT>::value == false )); if(is_float<eT>::value) { arma_wrapper(sgssv)(options, A, perm_c, perm_r, L, U, B, stat, info); } else if(is_double<eT>::value) { arma_wrapper(dgssv)(options, A, perm_c, perm_r, L, U, B, stat, info); } else if(is_supported_complex_float<eT>::value) { arma_wrapper(cgssv)(options, A, perm_c, perm_r, L, U, B, stat, info); } else if(is_supported_complex_double<eT>::value) { arma_wrapper(zgssv)(options, A, perm_c, perm_r, L, U, B, stat, info); } }
inline int clapack_posv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const int NRHS, eT *A, const int lda, eT *B, const int ldb) { arma_type_check((is_supported_blas_type<eT>::value == false)); if(is_float<eT>::value) { typedef float T; return arma_wrapper(clapack_sposv)(Order, Uplo, N, NRHS, (T*)A, lda, (T*)B, ldb); } else if(is_double<eT>::value) { typedef double T; return arma_wrapper(clapack_dposv)(Order, Uplo, N, NRHS, (T*)A, lda, (T*)B, ldb); } else if(is_supported_complex_float<eT>::value) { typedef std::complex<float> T; return arma_wrapper(clapack_cposv)(Order, Uplo, N, NRHS, (T*)A, lda, (T*)B, ldb); } else if(is_supported_complex_double<eT>::value) { typedef std::complex<double> T; return arma_wrapper(clapack_zposv)(Order, Uplo, N, NRHS, (T*)A, lda, (T*)B, ldb); } return -1; }
inline void gemv(const char* transA, const blas_int* m, const blas_int* n, const eT* alpha, const eT* A, const blas_int* ldA, const eT* x, const blas_int* incx, const eT* beta, eT* y, const blas_int* incy) { arma_type_check((is_supported_blas_type<eT>::value == false)); if(is_float<eT>::value == true) { typedef float T; arma_fortran(arma_sgemv)(transA, m, n, (const T*)alpha, (const T*)A, ldA, (const T*)x, incx, (const T*)beta, (T*)y, incy); } else if(is_double<eT>::value == true) { typedef double T; arma_fortran(arma_dgemv)(transA, m, n, (const T*)alpha, (const T*)A, ldA, (const T*)x, incx, (const T*)beta, (T*)y, incy); } else if(is_supported_complex_float<eT>::value == true) { typedef std::complex<float> T; arma_fortran(arma_cgemv)(transA, m, n, (const T*)alpha, (const T*)A, ldA, (const T*)x, incx, (const T*)beta, (T*)y, incy); } else if(is_supported_complex_double<eT>::value == true) { typedef std::complex<double> T; arma_fortran(arma_zgemv)(transA, m, n, (const T*)alpha, (const T*)A, ldA, (const T*)x, incx, (const T*)beta, (T*)y, incy); } }
inline void gemm(const char* transA, const char* transB, const blas_int* m, const blas_int* n, const blas_int* k, const eT* alpha, const eT* A, const blas_int* ldA, const eT* B, const blas_int* ldB, const eT* beta, eT* C, const blas_int* ldC) { arma_type_check((is_supported_blas_type<eT>::value == false)); if(is_float<eT>::value == true) { typedef float T; arma_fortran(arma_sgemm)(transA, transB, m, n, k, (const T*)alpha, (const T*)A, ldA, (const T*)B, ldB, (const T*)beta, (T*)C, ldC); } else if(is_double<eT>::value == true) { typedef double T; arma_fortran(arma_dgemm)(transA, transB, m, n, k, (const T*)alpha, (const T*)A, ldA, (const T*)B, ldB, (const T*)beta, (T*)C, ldC); } else if(is_supported_complex_float<eT>::value == true) { typedef std::complex<float> T; arma_fortran(arma_cgemm)(transA, transB, m, n, k, (const T*)alpha, (const T*)A, ldA, (const T*)B, ldB, (const T*)beta, (T*)C, ldC); } else if(is_supported_complex_double<eT>::value == true) { typedef std::complex<double> T; arma_fortran(arma_zgemm)(transA, transB, m, n, k, (const T*)alpha, (const T*)A, ldA, (const T*)B, ldB, (const T*)beta, (T*)C, ldC); } }
inline void cblas_herk ( const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const T alpha, const std::complex<T>* A, const int lda, const T beta, std::complex<T>* C, const int ldc ) { arma_type_check((is_supported_blas_type<T>::value == false)); if(is_float<T>::value) { typedef float TT; typedef std::complex<float> cx_TT; arma_wrapper(cblas_cherk)(Order, Uplo, Trans, N, K, (const TT)alpha, (const cx_TT*)A, lda, (const TT)beta, (cx_TT*)C, ldc); } else if(is_double<T>::value) { typedef double TT; typedef std::complex<double> cx_TT; arma_wrapper(cblas_zherk)(Order, Uplo, Trans, N, K, (const TT)alpha, (const cx_TT*)A, lda, (const TT)beta, (cx_TT*)C, ldc); } }
inline const Row<eT>& Row<eT>::fixed<fixed_n_elem>::operator=(const eOp<T1, eop_type>& X) { arma_extra_debug_sigprint(); arma_type_check(( is_same_type< eT, typename T1::elem_type >::no )); const bool bad_alias = (eOp<T1, eop_type>::proxy_type::has_subview && X.P.is_alias(*this)); if(bad_alias == false) { arma_debug_assert_same_size(uword(1), fixed_n_elem, X.get_n_rows(), X.get_n_cols(), "Row::fixed::operator="); eop_type::apply(*this, X); } else { arma_extra_debug_print("bad_alias = true"); Row<eT> tmp(X); (*this) = tmp; } return *this; }
inline unwrap_cube_check(const T1& A, const Cube<eT>&) : M(A) { arma_extra_debug_sigprint(); arma_type_check(( is_arma_cube_type<T1>::value == false )); }
inline void syrk(const char* uplo, const char* transA, const blas_int* n, const blas_int* k, const eT* alpha, const eT* A, const blas_int* ldA, const eT* beta, eT* C, const blas_int* ldC) { arma_type_check((is_supported_blas_type<eT>::value == false)); if(is_float<eT>::value == true) { typedef float T; arma_fortran(arma_ssyrk)(uplo, transA, n, k, (const T*)alpha, (const T*)A, ldA, (const T*)beta, (T*)C, ldC); } else if(is_double<eT>::value == true) { typedef double T; arma_fortran(arma_dsyrk)(uplo, transA, n, k, (const T*)alpha, (const T*)A, ldA, (const T*)beta, (T*)C, ldC); } }
inline void gssvx( superlu_options_t* opts, SuperMatrix* A, int* perm_c, int* perm_r, int* etree, char* equed, typename get_pod_type<eT>::result* R, typename get_pod_type<eT>::result* C, SuperMatrix* L, SuperMatrix* U, void* work, int lwork, SuperMatrix* B, SuperMatrix* X, typename get_pod_type<eT>::result* rpg, typename get_pod_type<eT>::result* rcond, typename get_pod_type<eT>::result* ferr, typename get_pod_type<eT>::result* berr, mem_usage_t* mu, SuperLUStat_t* stat, int* info ) { arma_type_check(( is_supported_blas_type<eT>::value == false )); if(is_float<eT>::value) { typedef float T; arma_wrapper(sgssvx)(opts, A, perm_c, perm_r, etree, equed, (T*)R, (T*)C, L, U, work, lwork, B, X, (T*)rpg, (T*)rcond, (T*)ferr, (T*)berr, mu, stat, info); } else if(is_double<eT>::value) { typedef double T; arma_wrapper(dgssvx)(opts, A, perm_c, perm_r, etree, equed, (T*)R, (T*)C, L, U, work, lwork, B, X, (T*)rpg, (T*)rcond, (T*)ferr, (T*)berr, mu, stat, info); } else if(is_supported_complex_float<eT>::value) { typedef float T; arma_wrapper(cgssvx)(opts, A, perm_c, perm_r, etree, equed, (T*)R, (T*)C, L, U, work, lwork, B, X, (T*)rpg, (T*)rcond, (T*)ferr, (T*)berr, mu, stat, info); } else if(is_supported_complex_double<eT>::value) { typedef double T; arma_wrapper(zgssvx)(opts, A, perm_c, perm_r, etree, equed, (T*)R, (T*)C, L, U, work, lwork, B, X, (T*)rpg, (T*)rcond, (T*)ferr, (T*)berr, mu, stat, info); } }
arma_inline eT cblas_dot(const int N, const eT* X, const eT* Y) { arma_type_check((is_supported_blas_type<eT>::value == false)); if(is_float<eT>::value) { typedef float T; return eT( arma_wrapper(cblas_sdot)(N, (const T*)X, 1, (const T*)Y, 1) ); } else if(is_double<eT>::value) { typedef double T; return eT( arma_wrapper(cblas_ddot)(N, (const T*)X, 1, (const T*)Y, 1) ); } return eT(0); }
inline void herk(const char* uplo, const char* transA, const blas_int* n, const blas_int* k, const T* alpha, const std::complex<T>* A, const blas_int* ldA, const T* beta, std::complex<T>* C, const blas_int* ldC) { arma_type_check((is_supported_blas_type<T>::value == false)); if(is_float<T>::value == true) { typedef float TT; typedef std::complex<float> cx_TT; arma_fortran(arma_cherk)(uplo, transA, n, k, (const TT*)alpha, (const cx_TT*)A, ldA, (const TT*)beta, (cx_TT*)C, ldC); } else if(is_double<T>::value == true) { typedef double TT; typedef std::complex<double> cx_TT; arma_fortran(arma_zherk)(uplo, transA, n, k, (const TT*)alpha, (const cx_TT*)A, ldA, (const TT*)beta, (cx_TT*)C, ldC); } }
inline void cblas_gemv ( const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const eT alpha, const eT *A, const int lda, const eT *X, const int incX, const eT beta, eT *Y, const int incY ) { arma_type_check((is_supported_blas_type<eT>::value == false)); if(is_float<eT>::value) { typedef float T; arma_wrapper(cblas_sgemv)(Order, TransA, M, N, (const T)tmp_real(alpha), (const T*)A, lda, (const T*)X, incX, (const T)tmp_real(beta), (T*)Y, incY); } else if(is_double<eT>::value) { typedef double T; arma_wrapper(cblas_dgemv)(Order, TransA, M, N, (const T)tmp_real(alpha), (const T*)A, lda, (const T*)X, incX, (const T)tmp_real(beta), (T*)Y, incY); } else if(is_supported_complex_float<eT>::value) { typedef std::complex<float> T; arma_wrapper(cblas_cgemv)(Order, TransA, M, N, (const T*)&alpha, (const T*)A, lda, (const T*)X, incX, (const T*)&beta, (T*)Y, incY); } else if(is_supported_complex_double<eT>::value) { typedef std::complex<double> T; arma_wrapper(cblas_zgemv)(Order, TransA, M, N, (const T*)&alpha, (const T*)A, lda, (const T*)X, incX, (const T*)&beta, (T*)Y, incY); } }
inline umat sort_index(const Base<typename T1::elem_type,T1>& X, const uword sort_type = 0) { arma_extra_debug_sigprint(); typedef typename T1::elem_type eT; arma_type_check(( is_complex<eT>::value == true )); const unwrap<T1> tmp(X.get_ref()); const Mat<eT>& A = tmp.M; if(A.is_empty() == true) { return umat(); } arma_debug_check( (A.is_vec() == false), "sort_index(): currently only handles vectors"); typedef typename umat::elem_type out_elem_type; umat out(A.n_rows, A.n_cols); if(sort_type == 0) { std::vector< arma_sort_index_packet_ascend<eT,out_elem_type> > packet_vec(A.n_elem); sort_index_helper(out.memptr(), packet_vec, A.mem); } else { std::vector< arma_sort_index_packet_descend<eT,out_elem_type> > packet_vec(A.n_elem); sort_index_helper(out.memptr(), packet_vec, A.mem); } return out; }
inline void cblas_syrk ( const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const eT alpha, const eT* A, const int lda, const eT beta, eT* C, const int ldc ) { arma_type_check((is_supported_blas_type<eT>::value == false)); if(is_float<eT>::value) { typedef float T; arma_wrapper(cblas_ssyrk)(Order, Uplo, Trans, N, K, (const T)alpha, (const T*)A, lda, (const T)beta, (T*)C, ldc); } else if(is_double<eT>::value) { typedef double T; arma_wrapper(cblas_dsyrk)(Order, Uplo, Trans, N, K, (const T)alpha, (const T*)A, lda, (const T)beta, (T*)C, ldc); } }
inline int clapack_getri ( const enum CBLAS_ORDER Order, const int N, eT *A, const int lda, const int *ipiv ) { arma_type_check((is_supported_blas_type<eT>::value == false)); if(is_float<eT>::value) { typedef float T; return arma_wrapper(clapack_sgetri)(Order, N, (T*)A, lda, ipiv); } else if(is_double<eT>::value) { typedef double T; return arma_wrapper(clapack_dgetri)(Order, N, (T*)A, lda, ipiv); } else if(is_supported_complex_float<eT>::value) { typedef std::complex<float> T; return arma_wrapper(clapack_cgetri)(Order, N, (T*)A, lda, ipiv); } else if(is_supported_complex_double<eT>::value) { typedef std::complex<double> T; return arma_wrapper(clapack_zgetri)(Order, N, (T*)A, lda, ipiv); } return -1; }
inline static void check() { arma_type_check(( is_promotable<T1,T2>::value == false )); }
inline eT dot(const uword n_elem, const eT* x, const eT* y) { arma_type_check((is_supported_blas_type<eT>::value == false)); if(is_float<eT>::value == true) { #if defined(ARMA_BLAS_SDOT_BUG) { if(n_elem == 0) { return eT(0); } const char trans = 'T'; const blas_int m = blas_int(n_elem); const blas_int n = 1; //const blas_int lda = (n_elem > 0) ? blas_int(n_elem) : blas_int(1); const blas_int inc = 1; const eT alpha = eT(1); const eT beta = eT(0); eT result[2]; // paranoia: using two elements instead of one //blas::gemv(&trans, &m, &n, &alpha, x, &lda, y, &inc, &beta, &result[0], &inc); blas::gemv(&trans, &m, &n, &alpha, x, &m, y, &inc, &beta, &result[0], &inc); return result[0]; } #else { blas_int n = blas_int(n_elem); blas_int inc = 1; typedef float T; return arma_fortran(arma_sdot)(&n, (const T*)x, &inc, (const T*)y, &inc); } #endif } else if(is_double<eT>::value == true) { blas_int n = blas_int(n_elem); blas_int inc = 1; typedef double T; return arma_fortran(arma_ddot)(&n, (const T*)x, &inc, (const T*)y, &inc); } else if( (is_supported_complex_float<eT>::value == true) || (is_supported_complex_double<eT>::value == true) ) { if(n_elem == 0) { return eT(0); } // using gemv() workaround due to compatibility issues with cdotu() and zdotu() const char trans = 'T'; const blas_int m = blas_int(n_elem); const blas_int n = 1; //const blas_int lda = (n_elem > 0) ? blas_int(n_elem) : blas_int(1); const blas_int inc = 1; const eT alpha = eT(1); const eT beta = eT(0); eT result[2]; // paranoia: using two elements instead of one //blas::gemv(&trans, &m, &n, &alpha, x, &lda, y, &inc, &beta, &result[0], &inc); blas::gemv(&trans, &m, &n, &alpha, x, &m, y, &inc, &beta, &result[0], &inc); return result[0]; } else { return eT(0); } }
inline ProxyCube(const T1&) { arma_type_check(( is_arma_cube_type<T1>::value == false )); }
inline void op_median::apply(Mat< std::complex<T> >& out, const Op<T1,op_median>& in) { arma_extra_debug_sigprint(); typedef typename std::complex<T> eT; arma_type_check(( is_same_type<eT, typename T1::elem_type>::value == false )); const unwrap_check<T1> tmp(in.m, out); const Mat<eT>& X = tmp.M; const uword X_n_rows = X.n_rows; const uword X_n_cols = X.n_cols; const uword dim = in.aux_uword_a; arma_debug_check( (dim > 1), "median(): incorrect usage. dim must be 0 or 1"); if(dim == 0) // in each column { arma_extra_debug_print("op_median::apply(), dim = 0"); arma_debug_check( (X_n_rows == 0), "median(): given object has zero rows" ); out.set_size(1, X_n_cols); std::vector< arma_cx_median_packet<T> > tmp_vec(X_n_rows); for(uword col=0; col<X_n_cols; ++col) { const eT* colmem = X.colptr(col); for(uword row=0; row<X_n_rows; ++row) { tmp_vec[row].val = std::abs(colmem[row]); tmp_vec[row].index = row; } uword index1; uword index2; op_median::direct_cx_median_index(index1, index2, tmp_vec); out[col] = op_median::robust_mean(colmem[index1], colmem[index2]); } } else if(dim == 1) // in each row { arma_extra_debug_print("op_median::apply(), dim = 1"); arma_debug_check( (X_n_cols == 0), "median(): given object has zero columns" ); out.set_size(X_n_rows, 1); std::vector< arma_cx_median_packet<T> > tmp_vec(X_n_cols); for(uword row=0; row<X_n_rows; ++row) { for(uword col=0; col<X_n_cols; ++col) { tmp_vec[col].val = std::abs(X.at(row,col)); tmp_vec[row].index = col; } uword index1; uword index2; op_median::direct_cx_median_index(index1, index2, tmp_vec); out[row] = op_median::robust_mean( X.at(row,index1), X.at(row,index2) ); } } }
inline Proxy_extra_empty(const T1&) { arma_type_check(( is_arma_type<T1>::value == false )); }