inline
void
subview_each2<parent,mode,TB>::check_indices(const Mat<uword>& indices) const
{
if(mode == 0)
{
arma_debug_check( ((indices.is_vec() == false) && (indices.is_empty() == false)), "each_col(): list of indices must be a vector" );
}
else
{
arma_debug_check( ((indices.is_vec() == false) && (indices.is_empty() == false)), "each_row(): list of indices must be a vector" );
}
}
inline
void
op_cor::direct_cor(Mat< std::complex<T> >& out, const Mat< std::complex<T> >& A, const uword norm_type)
{
arma_extra_debug_sigprint();
typedef typename std::complex<T> eT;
if(A.is_empty())
{
out.reset();
return;
}
if(A.is_vec())
{
out.set_size(1,1);
out[0] = eT(1);
}
else
{
const uword N = A.n_rows;
const eT norm_val = (norm_type == 0) ? ( (N > 1) ? eT(N-1) : eT(1) ) : eT(N);
const Row<eT> acc = sum(A);
const Row<T> sd = stddev(A);
out = trans(A) * A; // out = strans(conj(A)) * A;
out -= (trans(acc) * acc)/eT(N); // out -= (strans(conj(acc)) * acc)/eT(N);
out /= norm_val;
//out = out / (trans(sd) * sd);
out /= conv_to< Mat<eT> >::from(trans(sd) * sd);
}
}
inline
void
op_cor::direct_cor(Mat<eT>& out, const Mat<eT>& A, const uword norm_type)
{
arma_extra_debug_sigprint();
if(A.is_empty())
{
out.reset();
return;
}
if(A.is_vec())
{
out.set_size(1,1);
out[0] = eT(1);
}
else
{
const uword N = A.n_rows;
const eT norm_val = (norm_type == 0) ? ( (N > 1) ? eT(N-1) : eT(1) ) : eT(N);
const Row<eT> acc = sum(A);
const Row<eT> sd = stddev(A);
out = (trans(A) * A);
out -= (trans(acc) * acc)/eT(N);
out /= norm_val;
out /= trans(sd) * sd;
}
}
inline
void
arma_ostream::print(std::ostream& o, const Mat<eT>& m, const bool modify)
{
arma_extra_debug_sigprint();
const arma_ostream_state stream_state(o);
const std::streamsize cell_width = modify ? arma_ostream::modify_stream(o, m.memptr(), m.n_elem) : o.width();
const uword m_n_rows = m.n_rows;
const uword m_n_cols = m.n_cols;
if(m.is_empty() == false)
{
if(m_n_cols > 0)
{
if(cell_width > 0)
{
for(uword row=0; row < m_n_rows; ++row)
{
for(uword col=0; col < m_n_cols; ++col)
{
// the cell width appears to be reset after each element is printed,
// hence we need to restore it
o.width(cell_width);
arma_ostream::print_elem(o, m.at(row,col), modify);
}
o << '\n';
}
}
else
{
for(uword row=0; row < m_n_rows; ++row)
{
for(uword col=0; col < m_n_cols-1; ++col)
{
arma_ostream::print_elem(o, m.at(row,col), modify);
o << ' ';
}
arma_ostream::print_elem(o, m.at(row, m_n_cols-1), modify);
o << '\n';
}
}
}
}
else
{
o << "[matrix size: " << m_n_rows << 'x' << m_n_cols << "]\n";
}
o.flush();
stream_state.restore(o);
}
inline
void
op_resize::apply(Mat<typename T1::elem_type>& actual_out, const Op<T1,op_resize>& in)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT;
const uword out_n_rows = in.aux_uword_a;
const uword out_n_cols = in.aux_uword_b;
const unwrap<T1> tmp(in.m);
const Mat<eT>& A = tmp.M;
const uword A_n_rows = A.n_rows;
const uword A_n_cols = A.n_cols;
const bool alias = (&actual_out == &A);
if(alias)
{
if( (A_n_rows == out_n_rows) && (A_n_cols == out_n_cols) )
{
return;
}
if(actual_out.is_empty())
{
actual_out.zeros(out_n_rows, out_n_cols);
return;
}
}
Mat<eT> B;
Mat<eT>& out = alias ? B : actual_out;
out.set_size(out_n_rows, out_n_cols);
if( (out_n_rows > A_n_rows) || (out_n_cols > A_n_cols) )
{
out.zeros();
}
if( (out.n_elem > 0) && (A.n_elem > 0) )
{
const uword end_row = (std::min)(out_n_rows, A_n_rows) - 1;
const uword end_col = (std::min)(out_n_cols, A_n_cols) - 1;
out.submat(0, 0, end_row, end_col) = A.submat(0, 0, end_row, end_col);
}
if(alias)
{
actual_out.steal_mem(B);
}
}
inline
bool
op_sqrtmat_cx::helper(Mat< std::complex<T> >& S)
{
typedef typename std::complex<T> eT;
if(S.is_empty()) { return true; }
const uword N = S.n_rows;
const eT zero = eT(0);
eT& S_00 = S[0];
bool singular = (S_00 == zero);
S_00 = std::sqrt(S_00);
for(uword j=1; j < N; ++j)
{
eT* S_j = S.colptr(j);
eT& S_jj = S_j[j];
singular = (singular || (S_jj == zero));
S_jj = std::sqrt(S_jj);
for(uword ii=0; ii <= (j-1); ++ii)
{
const uword i = (j-1) - ii;
const eT* S_i = S.colptr(i);
//S_j[i] /= (S_i[i] + S_j[j]);
S_j[i] /= (S_i[i] + S_jj);
for(uword k=0; k < i; ++k)
{
S_j[k] -= S_i[k] * S_j[i];
}
}
}
return (singular) ? false : true;
}
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;
}
}
inline
bool
op_chol::apply_direct(Mat<typename T1::elem_type>& out, const Base<typename T1::elem_type,T1>& A_expr, const uword layout)
{
arma_extra_debug_sigprint();
out = A_expr.get_ref();
arma_debug_check( (out.is_square() == false), "chol(): given matrix must be square sized" );
if(out.is_empty()) { return true; }
uword KD = 0;
const bool is_band = (auxlib::crippled_lapack(out)) ? false : ((layout == 0) ? band_helper::is_band_upper(KD, out, uword(32)) : band_helper::is_band_lower(KD, out, uword(32)));
const bool status = (is_band) ? auxlib::chol_band(out, KD, layout) : auxlib::chol(out, layout);
return status;
}
inline
bool
op_sqrtmat_cx::apply_direct(Mat<typename T1::elem_type>& out, const Base<typename T1::elem_type,T1>& expr)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT;
Mat<eT> U;
Mat<eT> S = expr.get_ref();
if(S.is_empty())
{
out.reset();
return true;
}
arma_debug_check( (S.n_rows != S.n_cols), "sqrtmat(): given matrix must be square sized" );
const bool schur_ok = auxlib::schur(U, S);
if(schur_ok == false)
{
arma_extra_debug_print("sqrtmat(): schur decomposition failed");
out.reset();
return false;
}
const bool status = op_sqrtmat_cx::helper(S);
const Mat<eT> X = U*S;
S.reset();
out = X*U.t();
return status;
}
inline
void
subview_cube_each2<eT,TB>::check_indices(const Mat<uword>& indices) const
{
arma_debug_check( ((indices.is_vec() == false) && (indices.is_empty() == false)), "each_slice(): list of indices must be a vector" );
}
inline
void
glue_toeplitz::apply(Mat<typename T1::elem_type>& out, const Glue<T1, T2, glue_toeplitz>& in)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT;
if( ((void*)(&in.A)) == ((void*)(&in.B)) )
{
arma_extra_debug_print("glue_toeplitz::apply(): one argument version");
const unwrap_check<T1> tmp(in.A, out);
const Mat<eT>& A = tmp.M;
arma_debug_check( (A.is_vec() == false), "toeplitz(): input argument must be a vector" );
const u32 N = A.n_elem;
const eT* A_mem = A.memptr();
out.set_size(N,N);
for(u32 col=0; col<N; ++col)
{
eT* col_mem = out.colptr(col);
u32 i;
i = col;
for(u32 row=0; row<col; ++row, --i)
{
col_mem[row] = A_mem[i];
}
i = 0;
for(u32 row=col; row<N; ++row, ++i)
{
col_mem[row] = A_mem[i];
}
}
}
else
{
arma_extra_debug_print("glue_toeplitz::apply(): two argument version");
const unwrap_check<T1> tmp1(in.A, out);
const unwrap_check<T2> tmp2(in.B, out);
const Mat<eT>& A = tmp1.M;
const Mat<eT>& B = tmp2.M;
arma_debug_check( ( (A.is_vec() == false) || (B.is_vec() == false) ), "toeplitz(): input arguments must be vectors" );
const u32 A_N = A.n_elem;
const u32 B_N = B.n_elem;
const eT* A_mem = A.memptr();
const eT* B_mem = B.memptr();
out.set_size(A_N, B_N);
if( out.is_empty() )
{
return;
}
for(u32 col=0; col<B_N; ++col)
{
eT* col_mem = out.colptr(col);
u32 i = 0;
for(u32 row=col; row<A_N; ++row, ++i)
{
col_mem[row] = A_mem[i];
}
}
for(u32 row=0; row<A_N; ++row)
{
u32 i = 1;
for(u32 col=(row+1); col<B_N; ++col, ++i)
{
out.at(row,col) = B_mem[i];
}
}
}
}
inline
void
glue_hist::apply_noalias(Mat<uword>& out, const Mat<eT>& X, const Mat<eT>& C, const uword dim)
{
arma_extra_debug_sigprint();
arma_debug_check( ((C.is_vec() == false) && (C.is_empty() == false)), "hist(): parameter 'centers' must be a vector" );
const uword X_n_rows = X.n_rows;
const uword X_n_cols = X.n_cols;
const uword C_n_elem = C.n_elem;
if( C_n_elem == 0 ) { out.reset(); return; }
arma_debug_check
(
((Col<eT>(const_cast<eT*>(C.memptr()), C_n_elem, false, false)).is_sorted("strictascend") == false),
"hist(): given 'centers' vector does not contain monotonically increasing values"
);
const eT* C_mem = C.memptr();
const eT center_0 = C_mem[0];
if(dim == 0)
{
out.zeros(C_n_elem, X_n_cols);
for(uword col=0; col < X_n_cols; ++col)
{
const eT* X_coldata = X.colptr(col);
uword* out_coldata = out.colptr(col);
for(uword row=0; row < X_n_rows; ++row)
{
const eT val = X_coldata[row];
if(arma_isfinite(val))
{
eT opt_dist = (center_0 >= val) ? (center_0 - val) : (val - center_0);
uword opt_index = 0;
for(uword j=1; j < C_n_elem; ++j)
{
const eT center = C_mem[j];
const eT dist = (center >= val) ? (center - val) : (val - center);
if(dist < opt_dist)
{
opt_dist = dist;
opt_index = j;
}
else
{
break;
}
}
out_coldata[opt_index]++;
}
else
{
// -inf
if(val < eT(0)) { out_coldata[0]++; }
// +inf
if(val > eT(0)) { out_coldata[C_n_elem-1]++; }
// ignore NaN
}
}
}
}
else
if(dim == 1)
{
out.zeros(X_n_rows, C_n_elem);
if(X_n_rows == 1)
{
const uword X_n_elem = X.n_elem;
const eT* X_mem = X.memptr();
uword* out_mem = out.memptr();
for(uword i=0; i < X_n_elem; ++i)
{
const eT val = X_mem[i];
if(is_finite(val))
{
eT opt_dist = (val >= center_0) ? (val - center_0) : (center_0 - val);
uword opt_index = 0;
for(uword j=1; j < C_n_elem; ++j)
{
const eT center = C_mem[j];
const eT dist = (val >= center) ? (val - center) : (center - val);
if(dist < opt_dist)
{
opt_dist = dist;
opt_index = j;
}
else
{
break;
}
}
out_mem[opt_index]++;
}
else
{
// -inf
if(val < eT(0)) { out_mem[0]++; }
// +inf
if(val > eT(0)) { out_mem[C_n_elem-1]++; }
// ignore NaN
}
}
}
else
{
for(uword row=0; row < X_n_rows; ++row)
{
for(uword col=0; col < X_n_cols; ++col)
{
const eT val = X.at(row,col);
if(arma_isfinite(val))
{
eT opt_dist = (center_0 >= val) ? (center_0 - val) : (val - center_0);
uword opt_index = 0;
for(uword j=1; j < C_n_elem; ++j)
{
const eT center = C_mem[j];
const eT dist = (center >= val) ? (center - val) : (val - center);
if(dist < opt_dist)
{
opt_dist = dist;
opt_index = j;
}
else
{
break;
}
}
out.at(row,opt_index)++;
}
else
{
// -inf
if(val < eT(0)) { out.at(row,0)++; }
// +inf
if(val > eT(0)) { out.at(row,C_n_elem-1)++; }
// ignore NaN
}
}
}
}
}
}
inline
void
glue_join::apply_noalias(Mat<eT>& out, const Mat<eT>& A, const Mat<eT>& B, const uword join_type)
{
arma_extra_debug_sigprint();
const uword A_n_rows = A.n_rows;
const uword A_n_cols = A.n_cols;
const uword B_n_rows = B.n_rows;
const uword B_n_cols = B.n_cols;
if(join_type == 0)
{
arma_debug_check
(
( (A_n_cols != B_n_cols) && ( (A_n_rows > 0) || (A_n_cols > 0) ) && ( (B_n_rows > 0) || (B_n_cols > 0) ) ),
"join_cols() / join_vert(): number of columns must be the same"
);
}
else
{
arma_debug_check
(
( (A_n_rows != B.n_rows) && ( (A_n_rows > 0) || (A_n_cols > 0) ) && ( (B_n_rows > 0) || (B_n_cols > 0) ) ),
"join_rows() / join_horiz(): number of rows must be the same"
);
}
if(join_type == 0) // join columns (i.e. result matrix has more rows)
{
out.set_size( A_n_rows + B_n_rows, (std::max)(A_n_cols, B_n_cols) );
if( out.n_elem > 0 )
{
if(A.is_empty() == false)
{
out.submat(0, 0, A_n_rows-1, out.n_cols-1) = A;
}
if(B.is_empty() == false)
{
out.submat(A_n_rows, 0, out.n_rows-1, out.n_cols-1) = B;
}
}
}
else // join rows (i.e. result matrix has more columns)
{
out.set_size( (std::max)(A_n_rows, B_n_rows), A_n_cols + B_n_cols );
if( out.n_elem > 0 )
{
if(A.is_empty() == false)
{
out.submat(0, 0, out.n_rows-1, A.n_cols-1) = A;
}
if(B.is_empty() == false)
{
out.submat(0, A_n_cols, out.n_rows-1, out.n_cols-1) = B;
}
}
}
}
inline
void
glue_histc::apply_noalias(Mat<uword>& C, const Mat<eT>& A, const Mat<eT>& B, const uword dim)
{
arma_extra_debug_sigprint();
arma_debug_check( ((B.is_vec() == false) && (B.is_empty() == false)), "histc(): parameter 'edges' is not a vector" );
const uword A_n_rows = A.n_rows;
const uword A_n_cols = A.n_cols;
const uword B_n_elem = B.n_elem;
if( B_n_elem == uword(0) ) { C.reset(); return; }
const eT* B_mem = B.memptr();
const uword B_n_elem_m1 = B_n_elem - 1;
if(dim == uword(0))
{
C.zeros(B_n_elem, A_n_cols);
for(uword col=0; col < A_n_cols; ++col)
{
const eT* A_coldata = A.colptr(col);
uword* C_coldata = C.colptr(col);
for(uword row=0; row < A_n_rows; ++row)
{
const eT x = A_coldata[row];
for(uword i=0; i < B_n_elem_m1; ++i)
{
if( (B_mem[i] <= x) && (x < B_mem[i+1]) ) { C_coldata[i]++; break; }
else if( B_mem[B_n_elem_m1] == x ) { C_coldata[B_n_elem_m1]++; break; } // for compatibility with Matlab
}
}
}
}
else
if(dim == uword(1))
{
C.zeros(A_n_rows, B_n_elem);
if(A.n_rows == 1)
{
const uword A_n_elem = A.n_elem;
const eT* A_mem = A.memptr();
uword* C_mem = C.memptr();
for(uword j=0; j < A_n_elem; ++j)
{
const eT x = A_mem[j];
for(uword i=0; i < B_n_elem_m1; ++i)
{
if( (B_mem[i] <= x) && (x < B_mem[i+1]) ) { C_mem[i]++; break; }
else if( B_mem[B_n_elem_m1] == x ) { C_mem[B_n_elem_m1]++; break; } // for compatibility with Matlab
}
}
}
else
{
for(uword row=0; row < A_n_rows; ++row)
for(uword col=0; col < A_n_cols; ++col)
{
const eT x = A.at(row,col);
for(uword i=0; i < B_n_elem_m1; ++i)
{
if( (B_mem[i] <= x) && (x < B_mem[i+1]) ) { C.at(row,i)++; break; }
else if( B_mem[B_n_elem_m1] == x ) { C.at(row,B_n_elem_m1)++; break; } // for compatibility with Matlab
}
}
}
}
}
