inline
Col<typename T1::pod_type>
eigs_sym
(
const SpBase<typename T1::elem_type,T1>& X,
const uword n_eigvals,
const char* form = "lm",
const typename T1::elem_type tol = 0.0,
const typename arma_real_only<typename T1::elem_type>::result* junk = 0
)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
Mat<typename T1::elem_type> eigvec;
Col<typename T1::pod_type > eigval;
const bool status = sp_auxlib::eigs_sym(eigval, eigvec, X, n_eigvals, form, tol);
if(status == false)
{
eigval.reset();
arma_bad("eigs_sym(): failed to converge");
}
return eigval;
}
void expectedColClear() {
cout << "- Compute expectedColClear() ... ";
Col<double> expected = _genColVec;
expected.clear();
save<double>("Col.clear", expected);
cout << "done." << endl;
}
arma_warn_unused
inline
Col<uword>
find(const SpBase<typename T1::elem_type,T1>& X, const uword k = 0)
{
arma_extra_debug_sigprint();
const SpProxy<T1> P(X.get_ref());
const uword n_rows = P.get_n_rows();
const uword n_nz = P.get_n_nonzero();
Mat<uword> tmp(n_nz,1);
uword* tmp_mem = tmp.memptr();
typename SpProxy<T1>::const_iterator_type it = P.begin();
for(uword i=0; i<n_nz; ++i)
{
const uword index = it.row() + it.col()*n_rows;
tmp_mem[i] = index;
++it;
}
Col<uword> out;
const uword count = (k == 0) ? uword(n_nz) : uword( (std::min)(n_nz, k) );
out.steal_mem_col(tmp, count);
return out;
}
void expectedColReset() {
cout << "- Compute expectedColReset() ... ";
Col<double> expected = _genColVec;
expected.reset();
save<double>("Col.reset", expected);
cout << "done." << endl;
}
inline
typename enable_if2< is_supported_blas_type<typename T1::pod_type>::value, Col< std::complex<typename T1::pod_type> > >::result
eig_gen
(
const Base<typename T1::elem_type, T1>& expr
)
{
arma_extra_debug_sigprint();
typedef typename T1::pod_type T;
typedef typename std::complex<T> eT;
Col<eT> eigvals;
Mat<eT> eigvecs;
const bool status = auxlib::eig_gen(eigvals, eigvecs, false, expr.get_ref());
if(status == false)
{
eigvals.reset();
arma_bad("eig_gen(): decomposition failed");
}
return eigvals;
}
arma_warn_unused
inline
typename enable_if2< is_supported_blas_type<typename T1::pod_type>::value, Col< std::complex<typename T1::pod_type> > >::result
eig_pair
(
const Base<typename T1::elem_type, T1>& A_expr,
const Base<typename T1::elem_type, T2>& B_expr
)
{
arma_extra_debug_sigprint();
typedef typename T1::pod_type T;
Col< std::complex<T> > eigvals;
Mat< std::complex<T> > eigvecs;
const bool status = auxlib::eig_pair(eigvals, eigvecs, false, A_expr.get_ref(), B_expr.get_ref());
if(status == false)
{
eigvals.reset();
arma_stop_runtime_error("eig_pair(): decomposition failed");
}
return eigvals;
}
arma_warn_unused
inline
Col<typename T1::pod_type>
eigs_sym
(
const SpBase<typename T1::elem_type,T1>& X,
const uword n_eigvals,
const char* form = "lm",
const typename T1::elem_type tol = 0.0,
const typename arma_real_only<typename T1::elem_type>::result* junk = 0
)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
Mat<typename T1::elem_type> eigvec;
Col<typename T1::pod_type > eigval;
const bool status = sp_auxlib::eigs_sym(eigval, eigvec, X, n_eigvals, form, tol);
if(status == false)
{
eigval.reset();
arma_stop_runtime_error("eigs_sym(): decomposition failed");
}
return eigval;
}
inline
void
GenEigsSolver<eT, SelectionRule, OpType>::retrieve_ritzpair()
{
arma_extra_debug_sigprint();
UpperHessenbergEigen<eT> decomp(fac_H);
Col< std::complex<eT> > evals = decomp.eigenvalues();
Mat< std::complex<eT> > evecs = decomp.eigenvectors();
SortEigenvalue< std::complex<eT>, SelectionRule > sorting(evals.memptr(), evals.n_elem);
std::vector<uword> ind = sorting.index();
// Copy the ritz values and vectors to ritz_val and ritz_vec, respectively
for(uword i = 0; i < ncv; i++)
{
ritz_val(i) = evals(ind[i]);
ritz_est(i) = evecs(ncv - 1, ind[i]);
}
for(uword i = 0; i < nev; i++)
{
ritz_vec.col(i) = evecs.col(ind[i]);
}
}
inline
Col< std::complex<T> >
eig_pair
(
const Base< std::complex<T>, T1>& A,
const Base< std::complex<T>, T1>& B,
const typename arma_blas_type_only< std::complex<T> >::result* junk1 = 0,
const typename arma_cx_only< std::complex<T> >::result* junk2 = 0
)
{
arma_extra_debug_sigprint();
arma_ignore(junk1);
arma_ignore(junk2);
Mat< std::complex<T> > l_eigvec;
Mat< std::complex<T> > r_eigvec;
Col< std::complex<T> > eigval;
const bool status = auxlib::eig_pair(eigval, l_eigvec, r_eigvec, A, B, 'n');
if(status == false)
{
eigval.reset();
arma_bad("eig_pair(): failed to converge");
}
return eigval;
}
inline
bool
princomp
(
Mat<typename T1::elem_type>& coeff_out,
Mat<typename T1::elem_type>& score_out,
Col<typename T1::pod_type>& latent_out,
Col<typename T1::elem_type>& tsquared_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, score_out, latent_out, tsquared_out, X);
if(status == false)
{
coeff_out.reset();
score_out.reset();
latent_out.reset();
tsquared_out.reset();
arma_bad("princomp(): failed to converge", false);
}
return status;
}
inline
bool
op_princomp::direct_princomp
(
Mat<typename T1::elem_type>& coeff_out,
Mat<typename T1::elem_type>& score_out,
const Base<typename T1::elem_type, 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;
const unwrap_check<T1> Y( X.get_ref(), score_out );
const Mat<eT>& in = Y.M;
const uword n_rows = in.n_rows;
const uword n_cols = in.n_cols;
if(n_rows > 1) // more than one sample
{
// subtract the mean - use score_out as temporary matrix
score_out = in; score_out.each_row() -= mean(in);
// singular value decomposition
Mat<eT> U;
Col<eT> s;
const bool svd_ok = svd(U, s, coeff_out, score_out);
if(svd_ok == false) { return false; }
// normalize the eigenvalues
s /= std::sqrt( double(n_rows - 1) );
// project the samples to the principals
score_out *= coeff_out;
if(n_rows <= n_cols) // number of samples is less than their dimensionality
{
score_out.cols(n_rows-1,n_cols-1).zeros();
Col<eT> s_tmp = zeros< Col<eT> >(n_cols);
s_tmp.rows(0,n_rows-2) = s.rows(0,n_rows-2);
s = s_tmp;
}
}
else // 0 or 1 samples
{
coeff_out.eye(n_cols, n_cols);
score_out.copy_size(in);
score_out.zeros();
}
return true;
}
inline
bool
op_princomp::direct_princomp
(
Mat<eT>& coeff_out,
Mat<eT>& score_out,
const Mat<eT>& in
)
{
arma_extra_debug_sigprint();
const u32 n_rows = in.n_rows;
const u32 n_cols = in.n_cols;
if(n_rows > 1) // more than one sample
{
// subtract the mean - use score_out as temporary matrix
score_out = in - repmat(mean(in), n_rows, 1);
// singular value decomposition
Mat<eT> U;
Col<eT> s;
const bool svd_ok = svd(U,s,coeff_out,score_out);
if(svd_ok == false)
{
return false;
}
// U.reset();
// normalize the eigenvalues
s /= std::sqrt( double(n_rows - 1) );
// project the samples to the principals
score_out *= coeff_out;
if(n_rows <= n_cols) // number of samples is less than their dimensionality
{
score_out.cols(n_rows-1,n_cols-1).zeros();
Col<eT> s_tmp = zeros< Col<eT> >(n_cols);
s_tmp.rows(0,n_rows-2) = s.rows(0,n_rows-2);
s = s_tmp;
}
}
else // 0 or 1 samples
{
coeff_out.eye(n_cols, n_cols);
score_out.copy_size(in);
score_out.zeros();
}
return true;
}
inline
bool
op_null::apply_direct(Mat<typename T1::elem_type>& out, const Base<typename T1::elem_type,T1>& expr, typename T1::pod_type tol)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT;
typedef typename T1::pod_type T;
arma_debug_check((tol < T(0)), "null(): tolerance must be >= 0");
const unwrap<T1> tmp(expr.get_ref());
const Mat<eT>& X = tmp.M;
Mat<eT> U;
Col< T> s;
Mat<eT> V;
const bool status = auxlib::svd_dc(U, s, V, X);
U.reset();
if(status == false) { out.reset(); return false; }
if(s.is_empty()) { out.reset(); return true; }
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)) { tol = (std::max)(X.n_rows, X.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 < X.n_cols)
{
out = V.tail_cols(X.n_cols - count);
const uword out_n_elem = out.n_elem;
eT* out_mem = out.memptr();
for(uword i=0; i<out_n_elem; ++i)
{
if(std::abs(out_mem[i]) < std::numeric_limits<T>::epsilon()) { out_mem[i] = eT(0); }
}
}
else
{
out.set_size(X.n_cols, 0);
}
return true;
}
bool PuzzleMaker::checkCol(int num, int col, int ypos)
{
Col* toCheck = a->getCol(col);
for(int i = 0; i < 9; i++)
{
int check = toCheck->getTile(i)->getNum();
if( num == check && i != ypos)
return false;
}
return true;
}
inline
arma_warn_unused
uword
rank
(
const Base<typename T1::elem_type,T1>& X,
typename T1::pod_type tol = 0.0,
const typename arma_blas_type_only<typename T1::elem_type>::result* junk = 0
)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
typedef typename T1::pod_type T;
uword X_n_rows;
uword X_n_cols;
Col<T> s;
const bool status = auxlib::svd_dc(s, X, X_n_rows, X_n_cols);
const uword n_elem = s.n_elem;
if(status == true)
{
if( (tol == T(0)) && (n_elem > 0) )
{
tol = (std::max)(X_n_rows, X_n_cols) * eop_aux::direct_eps(max(s));
}
// count non zero valued elements in s
const T* s_mem = s.memptr();
uword count = 0;
for(uword i=0; i<n_elem; ++i)
{
if(s_mem[i] > tol) { ++count; }
}
return count;
}
else
{
arma_bad("rank(): failed to converge");
return uword(0);
}
}
void origNISim::initialize() {
mat W_t(maxVertexId, maxVertexId, fill::zeros);
for (int i = 0; i < maxVertexId; i++) {
int e = origGraphSrc[i + 1], s = origGraphSrc[i];
for (int j = s; j < e; j++) {
W_t(i, origGraphDst[j]) = 1.0;
}
}
double sumRow;
double Degr = 0;
for (int i = 0; i < maxVertexId; i++) {
sumRow = 0;
for (int j = 0; j < maxVertexId; j++)
sumRow += W_t(i, j);
if (sumRow == 0.0) {
printf("node %d has no ingoing edges\n", i);
} else {
for (int j = 0; j < maxVertexId; j++)
W_t(i, j) = W_t(i, j) / sumRow;
}
Degr += sumRow;
}
//start svd
Mat<double> U;
Col<double> s;
Mat<double> V_t;
svd(U, s, V_t, W_t);
mat V = V_t.t();
U = U.submat(0, 0, maxVertexId - 1, Rank - 1);
V = V.submat(0, 0, Rank - 1, maxVertexId - 1);
s = s.submat(0, 0, Rank - 1, 0);
Ku = kron(U, U);//kronecker roduct
mat sigma = kron(s, s);//one column
mat K_sigma = diagmat(sigma);
Kv = kron(V, V);
mat K_vu = Kv * Ku;
mat I(maxVertexId, maxVertexId);
I.eye();
A = inv(inv(K_sigma) - decayFactor * K_vu);
V_r = Kv * vectorise(I);
A.save(Apath);
V_r.save(V_rpath);
Kv.save(Kvpath);
Ku.save(Kupath);
}
inline
bool
eig_pair
(
Col< std::complex<eT> >& eigval,
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);
Mat<eT> l_eigvec;
Mat<eT> r_eigvec;
const bool status = auxlib::eig_pair(eigval, l_eigvec, r_eigvec, A, B, 'n');
if(status == false)
{
eigval.reset();
arma_bad("eig_pair(): failed to converge", false);
}
return status;
}
inline
bool
eigs_sym
(
Col<typename T1::pod_type >& eigval,
Mat<typename T1::elem_type>& eigvec,
const SpBase<typename T1::elem_type,T1>& X,
const uword n_eigvals,
const char* form = "lm",
const typename T1::elem_type tol = 0.0,
const typename arma_real_only<typename T1::elem_type>::result* junk = 0
)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
arma_debug_check( void_ptr(&eigval) == void_ptr(&eigvec), "eigs_sym(): paramater 'eigval' is an alias of parameter 'eigvec'" );
const bool status = sp_auxlib::eigs_sym(eigval, eigvec, X, n_eigvals, form, tol);
if(status == false)
{
eigval.reset();
arma_debug_warn("eigs_sym(): decomposition failed");
}
return status;
}
inline
bool
eig_pair
(
Col< std::complex<T> >& eigval,
Mat< std::complex<T> >& eigvec,
const Base< std::complex<T>, T1 >& A,
const Base< std::complex<T>, 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< std::complex<T> > dummy_eigvec;
const bool status = auxlib::eig_pair(eigval, dummy_eigvec, eigvec, A, B, 'r');
if(status == false)
{
eigval.reset();
eigvec.reset();
arma_bad("eig_pair(): failed to converge", false);
}
return status;
}
inline
typename enable_if2< is_supported_blas_type<typename T1::pod_type>::value, bool >::result
eig_pair
(
Col< std::complex<typename T1::pod_type> >& eigvals,
Mat< std::complex<typename T1::pod_type> >& eigvecs,
const Base< typename T1::elem_type, T1 >& A_expr,
const Base< typename T1::elem_type, T2 >& B_expr
)
{
arma_extra_debug_sigprint();
arma_debug_check( (void_ptr(&eigvals) == void_ptr(&eigvecs)), "eig_pair(): parameter 'eigval' is an alias of parameter 'eigvec'" );
const bool status = auxlib::eig_pair(eigvals, eigvecs, true, A_expr.get_ref(), B_expr.get_ref());
if(status == false)
{
eigvals.reset();
eigvecs.reset();
arma_debug_warn("eig_pair(): decomposition failed");
}
return status;
}
inline
bool
eig_sym
(
Col<typename T1::pod_type>& eigval,
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);
// unwrap_check not used as T1::elem_type and T1::pod_type may not be the same.
// furthermore, it doesn't matter if X is an alias of eigval, as auxlib::eig_sym() makes a copy of X
const bool status = auxlib::eig_sym(eigval, X);
if(status == false)
{
eigval.reset();
arma_debug_warn("eig_sym(): decomposition failed");
}
return status;
}
inline
bool
eig_sym
(
Col<typename T1::pod_type>& eigval,
Mat<typename T1::elem_type>& eigvec,
const Base<typename T1::elem_type,T1>& X,
const char* method = "dc",
const typename arma_blas_type_only<typename T1::elem_type>::result* junk = 0
)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
arma_debug_check( void_ptr(&eigval) == void_ptr(&eigvec), "eig_sym(): eigval is an alias of eigvec" );
const char sig = (method != NULL) ? method[0] : char(0);
arma_debug_check( ((sig != 's') && (sig != 'd')), "eig_sym(): unknown method specified" );
const bool status = (sig == 'd') ? auxlib::eig_sym_dc(eigval, eigvec, X) : auxlib::eig_sym(eigval, eigvec, X);
if(status == false)
{
eigval.reset();
eigvec.reset();
arma_bad("eig_sym(): failed to converge", false);
}
return status;
}
inline
bool
eig_gen
(
Col< std::complex<T> >& eigval,
const Base<T, T1>& X,
const typename arma_blas_type_only<T>::result* junk = 0
)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
Mat<T> l_eigvec;
Mat<T> r_eigvec;
const bool status = auxlib::eig_gen(eigval, l_eigvec, r_eigvec, X, 'n');
if(status == false)
{
eigval.reset();
arma_bad("eig_gen(): failed to converge", false);
}
return status;
}
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
}
inline
Col<eT>::Col(const Col<eT>& X)
: Mat<eT>(arma_vec_indicator(), X.n_elem, 1, 1)
{
arma_extra_debug_sigprint();
arrayops::copy((*this).memptr(), X.memptr(), X.n_elem);
}
inline
void
glue_trapz::apply_noalias(Mat<eT>& out, const Mat<eT>& X, const Mat<eT>& Y, const uword dim)
{
arma_extra_debug_sigprint();
arma_debug_check( (dim > 1), "trapz(): argument 'dim' must be 0 or 1" );
arma_debug_check( ((X.is_vec() == false) && (X.is_empty() == false)), "trapz(): argument 'X' must be a vector" );
const uword N = X.n_elem;
if(dim == 0)
{
arma_debug_check( (N != Y.n_rows), "trapz(): length of X must equal the number of rows in Y when dim=0" );
}
else
if(dim == 1)
{
arma_debug_check( (N != Y.n_cols), "trapz(): length of X must equal the number of columns in Y when dim=1" );
}
if(N <= 1)
{
if(dim == 0) { out.zeros(1, Y.n_cols); }
else if(dim == 1) { out.zeros(Y.n_rows, 1); }
return;
}
const Col<eT> vec_X( const_cast<eT*>(X.memptr()), X.n_elem, false, true );
const Col<eT> diff_X = diff(vec_X);
if(dim == 0)
{
const Row<eT> diff_X_t( const_cast<eT*>(diff_X.memptr()), diff_X.n_elem, false, true );
out = diff_X_t * (0.5 * (Y.rows(0, N-2) + Y.rows(1, N-1)));
}
else
if(dim == 1)
{
out = (0.5 * (Y.cols(0, N-2) + Y.cols(1, N-1))) * diff_X;
}
}
void expectedRowsElemDivide() {
for(int n = 0; n < _elemInds.n_elem; n++) {
if(!_genColVec.in_range(_elemInds.at(n))) {
return;
}
}
if(_genRowVec.n_elem != _elemInds.n_elem) {
return;
}
cout << "- Compute expectedElemElemDivide() ... ";
_genColVec.rows(_elemInds) /= _genRowVec;
save<double>("Col.rowsElemDivide", _genColVec);
cout << "done." << endl;
}
inline
bool
svd
(
Mat<typename T1::elem_type>& U,
Col<typename T1::pod_type >& S,
Mat<typename T1::elem_type>& V,
const Base<typename T1::elem_type,T1>& X,
const char* method = "",
const typename arma_blas_type_only<typename T1::elem_type>::result* junk = 0
)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
typedef typename T1::elem_type eT;
arma_debug_check
(
( ((void*)(&U) == (void*)(&S)) || (&U == &V) || ((void*)(&S) == (void*)(&V)) ),
"svd(): two or more output objects are the same object"
);
bool use_divide_and_conquer = false;
const char sig = method[0];
switch(sig)
{
case '\0':
case 's':
break;
case 'd':
use_divide_and_conquer = true;
break;
default:
{
arma_stop("svd(): unknown method specified");
return false;
}
}
// auxlib::svd() makes an internal copy of X
const bool status = (use_divide_and_conquer == false) ? auxlib::svd(U, S, V, X) : auxlib::svd_dc(U, S, V, X);
if(status == false)
{
U.reset();
S.reset();
V.reset();
arma_bad("svd(): failed to converge", false);
}
return status;
}
int main(int argc, char** argv)
{
Col<uint32_t> a;
a<<1<<2<<4<<3<<1<<6<<7<<2<<4;
cout<<a.t()<<endl;
cout<<(a==1).t()<<endl;
cout<<sum(a==1)<<endl;
mat A;
A.randn(10,2);
A.rows(0,4) += 4;
cout<<A<<endl;
Col<uint32_t> b=a;
b.resize(b.n_elem+1);
b(b.n_elem-1)=99;
cout<<a.t()<<endl;
cout<<b.t()<<endl;
colvec c(10);
c.zeros();
c(4)=math::inf();
c(5)=math::nan();
cout<<c<<endl;
cout<<is_finite(c(3))<<endl;
cout<<is_finite(c(4))<<endl;
cout<<is_finite(c(5))<<endl;
cout<<is_finite(c)<<endl;
colvec d(2);
d.ones();
c.insert_rows(c.n_elem,d);
cout<<c<<endl;
colvec l(2);
l << -8.0 << -16.0;
cout<<l.t()<<endl;
cout<<exp(l).t()<<endl;
return 0;
}
inline
Col<eT>::Col(const Col<eT>& X)
: Mat<eT>(X.n_elem, 1)
{
arma_extra_debug_sigprint();
access::rw(Mat<eT>::vec_state) = 1;
arrayops::copy((*this).memptr(), X.memptr(), X.n_elem);
}
