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 ));
}
