inline
Col<typename T1::pod_type>
eig_sym
(
const Base<typename T1::elem_type,T1>& X,
const typename arma_blas_type_only<typename T1::elem_type>::result* junk = 0
)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
Col<typename T1::pod_type> out;
const bool status = auxlib::eig_sym(out, X);
if(status == false)
{
out.reset();
arma_bad("eig_sym(): failed to converge");
}
return out;
}
inline
bool
princomp
(
Mat<typename T1::elem_type>& coeff_out,
const Base<typename T1::elem_type,T1>& X,
const typename arma_blas_type_only<typename T1::elem_type>::result* junk = 0
)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
const bool status = op_princomp::direct_princomp(coeff_out, X);
if(status == false)
{
coeff_out.reset();
arma_bad("princomp(): failed to converge", false);
}
return status;
}
inline
void
op_princomp::apply
(
Mat<typename T1::elem_type>& out,
const Op<T1,op_princomp>& in
)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT;
const unwrap_check<T1> tmp(in.m, out);
const Mat<eT>& A = tmp.M;
const bool status = op_princomp::direct_princomp(out, A);
if(status == false)
{
out.reset();
arma_bad("princomp(): failed to converge");
}
}
inline
bool
svd
(
Col<typename T1::pod_type>& S,
const Base<typename T1::elem_type,T1>& X,
const typename arma_blas_type_only<typename T1::elem_type>::result* junk = 0
)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
// it doesn't matter if X is an alias of S, as auxlib::svd() makes a copy of X
const bool status = auxlib::svd(S, X);
if(status == false)
{
S.reset();
arma_bad("svd(): failed to converge", false);
}
return status;
}
inline
bool
eig_pair
(
Col< std::complex<eT> >& eigval,
Mat< std::complex<eT> >& eigvec,
const Base< eT, T1 >& A,
const Base< eT, T2 >& B,
const typename arma_blas_type_only<typename T1::elem_type>::result* junk = 0
)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
arma_debug_check( ( ((void*)(&eigval)) == ((void*)(&eigvec)) ), "eig_pair(): eigval is an alias of eigvec" );
Mat<eT> dummy_eigvec;
Mat<eT> tmp_eigvec;
const bool status = auxlib::eig_pair(eigval, dummy_eigvec, tmp_eigvec, A, B, 'r');
if(status == false)
{
eigval.reset();
eigvec.reset();
arma_bad("eig_pair(): failed to converge", false);
}
else
{
const uword n = eigval.n_elem;
eigvec.set_size(n,n);
if(n > 0)
{
// from LAPACK docs:
// If the j-th and (j+1)-th eigenvalues form a complex conjugate pair, then
// v(j) = VR(:,j)+i*VR(:,j+1) and v(j+1) = VR(:,j)-i*VR(:,j+1).
for(uword j=0; j<n; ++j)
{
if( (j < n-1) && (eigval[j] == std::conj(eigval[j+1])) )
{
// eigvec.col(j) = Mat< std::complex<eT> >( tmp_eigvec.col(j), tmp_eigvec.col(j+1) );
// eigvec.col(j+1) = Mat< std::complex<eT> >( tmp_eigvec.col(j), -tmp_eigvec.col(j+1) );
for(uword i=0; i<n; ++i)
{
eigvec.at(i,j) = std::complex<eT>( tmp_eigvec.at(i,j), tmp_eigvec.at(i,j+1) );
eigvec.at(i,j+1) = std::complex<eT>( tmp_eigvec.at(i,j), -tmp_eigvec.at(i,j+1) );
}
++j;
}
else
{
// eigvec.col(i) = tmp_eigvec.col(i);
for(uword i=0; i<n; ++i)
{
eigvec.at(i,j) = std::complex<eT>(tmp_eigvec.at(i,j), eT(0));
}
}
}
}
}
return status;
}
inline
void
op_pinv::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_pinv>& in)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT;
typedef typename get_pod_type<eT>::result T;
const bool use_divide_and_conquer = (in.aux_uword_a == 1);
T tol = access::tmp_real(in.aux);
arma_debug_check((tol < T(0)), "pinv(): tolerance must be >= 0");
const Proxy<T1> P(in.m);
const uword n_rows = P.get_n_rows();
const uword n_cols = P.get_n_cols();
if( (n_rows*n_cols) == 0 )
{
out.set_size(n_cols,n_rows);
return;
}
// economical SVD decomposition
Mat<eT> U;
Col< T> s;
Mat<eT> V;
bool status = false;
if(use_divide_and_conquer)
{
status = (n_cols > n_rows) ? auxlib::svd_dc_econ(U, s, V, trans(P.Q)) : auxlib::svd_dc_econ(U, s, V, P.Q);
}
else
{
status = (n_cols > n_rows) ? auxlib::svd_econ(U, s, V, trans(P.Q), 'b') : auxlib::svd_econ(U, s, V, P.Q, 'b');
}
if(status == false)
{
out.reset();
arma_bad("pinv(): svd failed");
return;
}
const uword s_n_elem = s.n_elem;
const T* s_mem = s.memptr();
// set tolerance to default if it hasn't been specified
if( (tol == T(0)) && (s_n_elem > 0) )
{
tol = (std::max)(n_rows, n_cols) * s_mem[0] * std::numeric_limits<T>::epsilon();
}
uword count = 0;
for(uword i = 0; i < s_n_elem; ++i)
{
count += (s_mem[i] >= tol) ? uword(1) : uword(0);
}
if(count > 0)
{
Col<T> s2(count);
T* s2_mem = s2.memptr();
uword count2 = 0;
for(uword i=0; i < s_n_elem; ++i)
{
const T val = s_mem[i];
if(val >= tol) { s2_mem[count2] = T(1) / val; ++count2; }
}
if(n_rows >= n_cols)
{
out = ( (V.n_cols > count) ? V.cols(0,count-1) : V ) * diagmat(s2) * trans( (U.n_cols > count) ? U.cols(0,count-1) : U );
}
else
{
out = ( (U.n_cols > count) ? U.cols(0,count-1) : U ) * diagmat(s2) * trans( (V.n_cols > count) ? V.cols(0,count-1) : V );
}
}
else
{
out.zeros(n_cols, n_rows);
}
}
inline
bool
eig_gen
(
Col< std::complex<eT> >& eigval,
Mat< std::complex<eT> >& eigvec,
const Base<eT, T1>& X,
const char side = 'r',
const typename arma_blas_type_only<typename T1::elem_type>::result* junk = 0
)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
//std::cout << "real" << std::endl;
arma_debug_check( ( ((void*)(&eigval)) == ((void*)(&eigvec)) ), "eig_gen(): eigval is an alias of eigvec" );
Mat<eT> dummy_eigvec;
Mat<eT> tmp_eigvec;
bool status;
switch(side)
{
case 'r':
status = auxlib::eig_gen(eigval, dummy_eigvec, tmp_eigvec, X, side);
break;
case 'l':
status = auxlib::eig_gen(eigval, tmp_eigvec, dummy_eigvec, X, side);
break;
default:
arma_stop("eig_gen(): parameter 'side' is invalid");
status = false;
}
if(status == false)
{
eigval.reset();
eigvec.reset();
arma_bad("eig_gen(): failed to converge", false);
}
else
{
const uword n = eigval.n_elem;
if(n > 0)
{
eigvec.set_size(n,n);
for(uword j=0; j<n; ++j)
{
if( (j < n-1) && (eigval[j] == std::conj(eigval[j+1])) )
{
// eigvec.col(j) = Mat< std::complex<eT> >( tmp_eigvec.col(j), tmp_eigvec.col(j+1) );
// eigvec.col(j+1) = Mat< std::complex<eT> >( tmp_eigvec.col(j), -tmp_eigvec.col(j+1) );
for(uword i=0; i<n; ++i)
{
eigvec.at(i,j) = std::complex<eT>( tmp_eigvec.at(i,j), tmp_eigvec.at(i,j+1) );
eigvec.at(i,j+1) = std::complex<eT>( tmp_eigvec.at(i,j), -tmp_eigvec.at(i,j+1) );
}
++j;
}
else
{
// eigvec.col(i) = tmp_eigvec.col(i);
for(uword i=0; i<n; ++i)
{
eigvec.at(i,j) = std::complex<eT>(tmp_eigvec.at(i,j), eT(0));
}
}
}
}
}
return status;
}
inline
void
op_pinv::direct_pinv(Mat<eT>& out, const Mat<eT>& A, const eT in_tol)
{
arma_extra_debug_sigprint();
typedef typename get_pod_type<eT>::result T;
T tol = access::tmp_real(in_tol);
arma_debug_check((tol < T(0)), "pinv(): tolerance must be >= 0");
const uword n_rows = A.n_rows;
const uword n_cols = A.n_cols;
// economical SVD decomposition
Mat<eT> U;
Col< T> s;
Mat<eT> V;
const bool status = (n_cols > n_rows) ? auxlib::svd_econ(U,s,V,trans(A),'b') : auxlib::svd_econ(U,s,V,A,'b');
if(status == false)
{
out.reset();
arma_bad("pinv(): svd failed");
return;
}
const uword s_n_elem = s.n_elem;
const T* s_mem = s.memptr();
// set tolerance to default if it hasn't been specified as an argument
if( (tol == T(0)) && (s_n_elem > 0) )
{
tol = (std::max)(n_rows, n_cols) * eop_aux::direct_eps( op_max::direct_max(s_mem, s_n_elem) );
}
// count non zero valued elements in s
uword count = 0;
for(uword i = 0; i < s_n_elem; ++i)
{
if(s_mem[i] > tol)
{
++count;
}
}
if(count != 0)
{
Col<T> s2(count);
T* s2_mem = s2.memptr();
uword count2 = 0;
for(uword i=0; i < s_n_elem; ++i)
{
const T val = s_mem[i];
if(val > tol)
{
s2_mem[count2] = T(1) / val;
++count2;
}
}
if(n_rows >= n_cols)
{
out = ( V.n_cols > count ? V.cols(0,count-1) : V ) * diagmat(s2) * trans( U.n_cols > count ? U.cols(0,count-1) : U );
}
else
{
out = ( U.n_cols > count ? U.cols(0,count-1) : U ) * diagmat(s2) * trans( V.n_cols > count ? V.cols(0,count-1) : V );
}
}
else
{
out.zeros(n_cols, n_rows);
}
}