inline
void
op_cov::direct_cov(Mat< std::complex<T> >& out, const Mat< std::complex<T> >& A, const u32 norm_type)
{
arma_extra_debug_sigprint();
typedef typename std::complex<T> eT;
if(A.is_vec())
{
if(A.n_rows == 1)
{
const Mat<T> tmp_mat = var(trans(A), norm_type);
out.set_size(1,1);
out[0] = tmp_mat[0];
}
else
{
const Mat<T> tmp_mat = var(A, norm_type);
out.set_size(1,1);
out[0] = tmp_mat[0];
}
}
else
{
const u32 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);
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;
}
}
inline
void
op_stddev::apply(Mat<typename T1::pod_type>& out, const mtOp<typename T1::pod_type, T1, op_stddev>& in)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type in_eT;
typedef typename T1::pod_type out_eT;
const unwrap_check_mixed<T1> tmp(in.m, out);
const Mat<in_eT>& X = tmp.M;
const uword norm_type = in.aux_uword_a;
const uword dim = in.aux_uword_b;
arma_debug_check( (norm_type > 1), "stddev(): incorrect usage. norm_type must be 0 or 1");
arma_debug_check( (dim > 1), "stddev(): incorrect usage. dim must be 0 or 1" );
const uword X_n_rows = X.n_rows;
const uword X_n_cols = X.n_cols;
if(dim == 0)
{
arma_extra_debug_print("op_stddev::apply(), dim = 0");
arma_debug_check( (X_n_rows == 0), "stddev(): given object has zero rows" );
out.set_size(1, X_n_cols);
out_eT* out_mem = out.memptr();
for(uword col=0; col<X_n_cols; ++col)
{
out_mem[col] = std::sqrt( op_var::direct_var( X.colptr(col), X_n_rows, norm_type ) );
}
}
else
if(dim == 1)
{
arma_extra_debug_print("op_stddev::apply(), dim = 1");
arma_debug_check( (X_n_cols == 0), "stddev(): given object has zero columns" );
out.set_size(X_n_rows, 1);
podarray<in_eT> dat(X_n_cols);
in_eT* dat_mem = dat.memptr();
out_eT* out_mem = out.memptr();
for(uword row=0; row<X_n_rows; ++row)
{
dat.copy_row(X, row);
out_mem[row] = std::sqrt( op_var::direct_var( dat_mem, X_n_cols, norm_type) );
}
}
}
inline void op_min::apply(Mat< std::complex<T> >& out, const Op<T1,op_min>& in)
{
arma_extra_debug_sigprint();
typedef typename std::complex<T> eT;
isnt_same_type<eT, typename T1::elem_type>::check();
const unwrap_check<T1> tmp(in.m, out);
const Mat<eT>& X = tmp.M;
arma_debug_check( (X.n_elem == 0), "min(): given matrix has no elements" );
const u32 dim = in.aux_u32_a;
arma_debug_check( (dim > 1), "min(): incorrect usage. dim must be 0 or 1");
if(dim == 0) // column-wise min
{
arma_extra_debug_print("op_min::apply(), dim = 0");
out.set_size(1, X.n_cols);
for(u32 col=0; col<X.n_cols; ++col)
{
out[col] = op_min::direct_min( X.colptr(col), X.n_rows );
}
}
else
if(dim == 1) // row-wise min
{
arma_extra_debug_print("op_min::apply(), dim = 1");
out.set_size(X.n_rows, 1);
for(u32 row=0; row<X.n_rows; ++row)
{
u32 index = 0;
T min_val = std::abs(X.at(row,index));
for(u32 col=1; col<X.n_cols; ++col)
{
const T tmp_val = std::abs(X.at(row,col));
if(tmp_val < min_val)
{
min_val = tmp_val;
index = col;
}
}
out[row] = X.at(row,index);
}
}
}
inline
void
op_mean::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_mean>& in)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT;
const unwrap_check<T1> tmp(in.m, out);
const Mat<eT>& X = tmp.M;
arma_debug_check( (X.n_elem == 0), "mean(): given matrix has no elements" );
const u32 dim = in.aux_u32_a;
arma_debug_check( (dim > 1), "mean(): incorrect usage. dim must be 0 or 1");
if(dim == 0)
{
arma_extra_debug_print("op_mean::apply(), dim = 0");
out.set_size(1, X.n_cols);
for(u32 col=0; col<X.n_cols; ++col)
{
out[col] = op_mean::direct_mean( X.colptr(col), X.n_rows );
}
}
else
if(dim == 1)
{
arma_extra_debug_print("op_mean::apply(), dim = 1");
out.set_size(X.n_rows, 1);
for(u32 row=0; row<X.n_rows; ++row)
{
eT val = eT(0);
for(u32 col=0; col<X.n_cols; ++col)
{
val += X.at(row,col);
}
out[row] = val / eT(X.n_cols);
}
}
}
inline
void
op_min::apply_noalias(Mat<eT>& out, const Mat<eT>& X, const uword dim, const typename arma_not_cx<eT>::result* junk)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
const uword X_n_rows = X.n_rows;
const uword X_n_cols = X.n_cols;
if(dim == 0)
{
arma_extra_debug_print("op_min::apply(): dim = 0");
out.set_size((X_n_rows > 0) ? 1 : 0, X_n_cols);
if(X_n_rows == 0) { return; }
eT* out_mem = out.memptr();
for(uword col=0; col<X_n_cols; ++col)
{
out_mem[col] = op_min::direct_min( X.colptr(col), X_n_rows );
}
}
else
if(dim == 1)
{
arma_extra_debug_print("op_min::apply(): dim = 1");
out.set_size(X_n_rows, (X_n_cols > 0) ? 1 : 0);
if(X_n_cols == 0) { return; }
eT* out_mem = out.memptr();
arrayops::copy(out_mem, X.colptr(0), X_n_rows);
for(uword col=1; col<X_n_cols; ++col)
{
const eT* col_mem = X.colptr(col);
for(uword row=0; row<X_n_rows; ++row)
{
const eT col_val = col_mem[row];
if(col_val < out_mem[row]) { out_mem[row] = col_val; }
}
}
}
}
inline
void
op_var::apply(Mat< typename get_pod_type<eT>::result >& out, const Mat<eT>& X, const u32 norm_type, const u32 dim)
{
arma_extra_debug_sigprint();
arma_debug_check( (X.n_elem == 0), "var(): given matrix has no elements" );
arma_debug_check( (norm_type > 1), "var(): incorrect usage. norm_type must be 0 or 1");
arma_debug_check( (dim > 1), "var(): incorrect usage. dim must be 0 or 1" );
if(dim == 0)
{
arma_extra_debug_print("op_var::apply(), dim = 0");
out.set_size(1, X.n_cols);
for(u32 col=0; col<X.n_cols; ++col)
{
out[col] = op_var::direct_var( X.colptr(col), X.n_rows, norm_type );
}
}
else
if(dim == 1)
{
arma_extra_debug_print("op_var::apply(), dim = 1");
const u32 n_rows = X.n_rows;
const u32 n_cols = X.n_cols;
out.set_size(n_rows, 1);
podarray<eT> tmp(n_cols);
eT* tmp_mem = tmp.memptr();
for(u32 row=0; row<n_rows; ++row)
{
for(u32 col=0; col<n_cols; ++col)
{
tmp_mem[col] = X.at(row,col);
}
out[row] = op_var::direct_var(tmp_mem, n_cols, norm_type);
}
}
}
inline
void
op_max::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_max>& in)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT;
const unwrap_check<T1> tmp(in.m, out);
const Mat<eT>& X = tmp.M;
const uword dim = in.aux_uword_a;
arma_debug_check( (dim > 1), "max(): incorrect usage. dim must be 0 or 1");
const uword X_n_rows = X.n_rows;
const uword X_n_cols = X.n_cols;
if(dim == 0)
{
arma_extra_debug_print("op_max::apply(), dim = 0");
arma_debug_check( (X_n_rows == 0), "max(): given object has zero rows" );
out.set_size(1, X_n_cols);
eT* out_mem = out.memptr();
for(uword col=0; col<X_n_cols; ++col)
{
out_mem[col] = op_max::direct_max( X.colptr(col), X_n_rows );
}
}
else
if(dim == 1)
{
arma_extra_debug_print("op_max::apply(), dim = 1");
arma_debug_check( (X_n_cols == 0), "max(): given object has zero columns" );
out.set_size(X_n_rows, 1);
eT* out_mem = out.memptr();
for(uword row=0; row<X_n_rows; ++row)
{
out_mem[row] = op_max::direct_max( X, row );
}
}
}
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
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
internal_regspace_default_delta
(
Mat<eT>& x,
const typename Mat<eT>::pod_type start,
const typename Mat<eT>::pod_type end
)
{
arma_extra_debug_sigprint();
typedef typename Mat<eT>::pod_type T;
const bool ascend = (start <= end);
const uword N = uword(1) + uword((ascend) ? (end-start) : (start-end));
x.set_size(N);
eT* x_mem = x.memptr();
if(ascend)
{
for(uword i=0; i < N; ++i) { x_mem[i] = eT(start + T(i)); }
}
else
{
for(uword i=0; i < N; ++i) { x_mem[i] = eT(start - T(i)); }
}
}
inline
void
op_cx_scalar_minus_pre::apply
(
Mat< typename std::complex<typename T1::pod_type> >& out,
const mtOp<typename std::complex<typename T1::pod_type>, T1, op_cx_scalar_minus_pre>& X
)
{
arma_extra_debug_sigprint();
typedef typename std::complex<typename T1::pod_type> eT;
typedef typename T1::pod_type T;
const Proxy<T1> A(X.m);
out.set_size(A.n_rows, A.n_cols);
const u32 n_elem = A.n_elem;
const eT k = X.aux_out_eT;
eT* out_mem = out.memptr();
for(u32 i=0; i<n_elem; ++i)
{
out_mem[i] = k - A[i];
}
}
inline
void
glue_cross::apply(Mat<typename T1::elem_type>& out, const Glue<T1, T2, glue_cross>& X)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT;
typedef typename Proxy<T1>::ea_type ea_type1;
typedef typename Proxy<T2>::ea_type ea_type2;
const Proxy<T1> A(X.A);
const Proxy<T2> B(X.B);
arma_debug_check( ((A.get_n_elem() != 3) || (B.get_n_elem() != 3)), "cross(): input vectors must have 3 elements" );
out.set_size(A.get_n_rows(), A.get_n_cols());
eT* out_mem = out.memptr();
ea_type1 PA = A.get_ea();
ea_type2 PB = B.get_ea();
const eT ax = PA[0];
const eT ay = PA[1];
const eT az = PA[2];
const eT bx = PB[0];
const eT by = PB[1];
const eT bz = PB[2];
out_mem[0] = ay*bz - az*by;
out_mem[1] = az*bx - ax*bz;
out_mem[2] = ax*by - ay*bx;
}
inline void
poly2mat(const field<Polynomial<eT> >& pa, Mat<eT>& m)
{
const uword r = pa.n_rows;
const uword c = pa.n_cols;
uword n = 0;
uword k;
for(uword i = 0; i < r; ++i)
{
for(uword j = 0; j < c; ++j)
{
k = pa(i,j).degree();
if(k > n) n = k;
}
}
n++;
m.set_size(r, n*c);
for(uword i = 0; i < r; ++i)
{
for(uword j = 0; j < c; ++j)
{
for(uword k = 0; k < n; ++k)
m(i, k*c+j) = pa(i,j)[k];
}
}
}
inline
bool
op_logmat_cx::apply_direct(Mat<typename T1::elem_type>& out, const Base<typename T1::elem_type,T1>& expr, const uword n_iters)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT;
Mat<eT> S = expr.get_ref();
arma_debug_check( (S.n_rows != S.n_cols), "logmat(): given matrix must be square sized" );
if(S.n_elem == 0)
{
out.reset();
return true;
}
else
if(S.n_elem == 1)
{
out.set_size(1,1);
out[0] = std::log(S[0]);
return true;
}
return op_logmat_cx::apply_common(out, S, n_iters);
}
inline
void
glue_rel_lteq::apply
(
Mat <u32>& out,
const mtGlue<u32, T1, T2, glue_rel_lteq>& X
)
{
arma_extra_debug_sigprint();
const Proxy<T1> A(X.A);
const Proxy<T2> B(X.B);
arma_debug_assert_same_size(A, B, "operator<=");
out.set_size(A.n_rows, A.n_cols);
const u32 n_elem = A.n_elem;
u32* out_mem = out.memptr();
for(u32 i=0; i<n_elem; ++i)
{
out_mem[i] = (A[i] <= B[i]) ? u32(1) : u32(0);
}
}
inline
void
op_nonzeros::apply_noalias(Mat<typename T1::elem_type>& out, const SpBase<typename T1::elem_type,T1>& X)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT;
const SpProxy<T1> P(X.get_ref());
const uword N = P.get_n_nonzero();
out.set_size(N,1);
if(N > 0)
{
if(is_SpMat<typename SpProxy<T1>::stored_type>::value)
{
const unwrap_spmat<typename SpProxy<T1>::stored_type> U(P.Q);
arrayops::copy(out.memptr(), U.M.values, N);
}
else
{
eT* out_mem = out.memptr();
typename SpProxy<T1>::const_iterator_type it = P.begin();
for(uword i=0; i<N; ++i) { out_mem[i] = (*it); ++it; }
}
}
}
inline
void
op_nonzeros::apply(Mat<typename T1::elem_type>& out, const Op<T1, op_nonzeros>& X)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT;
const Proxy<T1> P(X.m);
if(P.get_n_elem() == 0) { out.set_size(0,1); return; }
if(P.is_alias(out))
{
Mat<eT> out2;
op_nonzeros::apply_noalias(out2, P);
out.steal_mem(out2);
}
else
{
op_nonzeros::apply_noalias(out, P);
}
}
inline
void
op_stable_sort_index::apply(Mat<uword>& out, const mtOp<uword,T1,op_stable_sort_index>& in)
{
arma_extra_debug_sigprint();
const Proxy<T1> P(in.m);
if(P.get_n_elem() == 0) { out.set_size(0,1); return; }
const uword sort_type = in.aux_uword_a;
bool all_non_nan = false;
if(P.is_alias(out))
{
Mat<uword> out2;
all_non_nan = op_stable_sort_index::apply_noalias(out2, P, sort_type);
out.steal_mem(out2);
}
else
{
all_non_nan = op_stable_sort_index::apply_noalias(out, P, sort_type);
}
arma_debug_check( (all_non_nan == false), "stable_sort_index(): detected NaN" );
}
inline
void
glue_mixed_plus::apply(Mat<typename eT_promoter<T1,T2>::eT>& out, const mtGlue<typename eT_promoter<T1,T2>::eT, T1, T2, glue_mixed_plus>& X)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT1;
typedef typename T2::elem_type eT2;
typedef typename promote_type<eT1,eT2>::result out_eT;
promote_type<eT1,eT2>::check();
const Proxy<T1> A(X.A);
const Proxy<T2> B(X.B);
arma_debug_assert_same_size(A, B, "matrix addition");
out.set_size(A.n_rows, A.n_cols);
out_eT* out_mem = out.memptr();
const u32 n_elem = out.n_elem;
for(u32 i=0; i<n_elem; ++i)
{
out_mem[i] = upgrade_val<eT1,eT2>::apply(A[i]) + upgrade_val<eT1,eT2>::apply(B[i]);
}
}
inline
void
glue_kron::direct_kron(Mat< std::complex<T> >& out, const Mat< std::complex<T> >& A, const Mat<T>& B)
{
arma_extra_debug_sigprint();
typedef typename std::complex<T> eT;
const u32 A_rows = A.n_rows;
const u32 A_cols = A.n_cols;
const u32 B_rows = B.n_rows;
const u32 B_cols = B.n_cols;
out.set_size(A_rows*B_rows, A_cols*B_cols);
Mat<eT> tmp_B = conv_to< Mat<eT> >::from(B);
for(u32 i = 0; i < A_rows; i++)
{
for(u32 j = 0; j < A_cols; j++)
{
out.submat(i*B_rows, j*B_cols, (i+1)*B_rows-1, (j+1)*B_cols-1) = A(i,j) * tmp_B;
}
}
}
inline
u32
op_find::helper
(
Mat<u32>& indices,
const Base<typename T1::elem_type, T1>& X
)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT;
const Proxy<T1> P(X.get_ref());
const u32 n_elem = P.get_n_elem();
indices.set_size(n_elem, 1);
u32* indices_mem = indices.memptr();
u32 n_nz = 0;
for(u32 i=0; i<n_elem; ++i)
{
if(P[i] != eT(0))
{
indices_mem[n_nz] = i;
++n_nz;
}
}
return n_nz;
}
inline
void
op_find::apply(Mat<uword>& out, const mtOp<uword, T1, op_find>& X)
{
arma_extra_debug_sigprint();
const uword k = X.aux_uword_a;
const uword type = X.aux_uword_b;
Mat<uword> indices;
const uword n_nz = op_find::helper(indices, X.m);
if(n_nz > 0)
{
if(type == 0) // "first"
{
out = (k > 0 && k <= n_nz) ? indices.rows(0, k-1 ) : indices.rows(0, n_nz-1);
}
else // "last"
{
out = (k > 0 && k <= n_nz) ? indices.rows(n_nz-k, n_nz-1) : indices.rows(0, n_nz-1);
}
}
else
{
out.set_size(0,1); // empty column vector
}
}
inline
void
op_vectorise_col::apply_subview(Mat<eT>& out, const subview<eT>& sv)
{
arma_extra_debug_sigprint();
const bool is_alias = (&out == &(sv.m));
if(is_alias == false)
{
const uword sv_n_rows = sv.n_rows;
const uword sv_n_cols = sv.n_cols;
out.set_size(sv.n_elem, 1);
eT* out_mem = out.memptr();
for(uword col=0; col < sv_n_cols; ++col)
{
arrayops::copy(out_mem, sv.colptr(col), sv_n_rows);
out_mem += sv_n_rows;
}
}
else
{
Mat<eT> tmp;
op_vectorise_col::apply_subview(tmp, sv);
out.steal_mem(tmp);
}
}
inline
void
op_sum::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_sum>& in)
{
arma_extra_debug_sigprint();
const uword dim = in.aux_uword_a;
arma_debug_check( (dim > 1), "sum(): incorrect usage. dim must be 0 or 1");
typedef typename T1::elem_type eT;
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;
if(dim == 0) // traverse across rows (i.e. find the sum in each column)
{
out.set_size(1, X_n_cols);
eT* out_mem = out.memptr();
for(uword col=0; col<X_n_cols; ++col)
{
out_mem[col] = arrayops::accumulate(X.colptr(col), X_n_rows);
}
}
else // traverse across columns (i.e. find the sum in each row)
{
out.set_size(X_n_rows, 1);
eT* out_mem = out.memptr();
for(uword row=0; row<X_n_rows; ++row)
{
eT val = eT(0);
for(uword col=0; col<X_n_cols; ++col)
{
val += X.at(row,col);
}
out_mem[row] = val;
}
}
}
inline
void
op_clamp::apply_noalias(Mat<typename T1::elem_type>& out, const Proxy<T1>& P, const typename T1::elem_type min_val, const typename T1::elem_type max_val)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT;
const uword n_rows = P.get_n_rows();
const uword n_cols = P.get_n_cols();
out.set_size(n_rows, n_cols);
eT* out_mem = out.memptr();
if(Proxy<T1>::use_at == false)
{
const uword N = P.get_n_elem();
typename Proxy<T1>::ea_type A = P.get_ea();
uword j;
for(j=1; j<N; j+=2)
{
eT val_i = A[j-1];
eT val_j = A[j ];
val_i = (val_i < min_val) ? min_val : ((val_i > max_val) ? max_val : val_i);
val_j = (val_j < min_val) ? min_val : ((val_j > max_val) ? max_val : val_j);
(*out_mem) = val_i; out_mem++;
(*out_mem) = val_j; out_mem++;
}
const uword i = j-1;
if(i < N)
{
eT val_i = A[i];
val_i = (val_i < min_val) ? min_val : ((val_i > max_val) ? max_val : val_i);
(*out_mem) = val_i;
}
}
else
{
for(uword col=0; col<n_cols; ++col)
for(uword row=0; row<n_rows; ++row)
{
eT val = P.at(row,col);
val = (val < min_val) ? min_val : ((val > max_val) ? max_val : val);
(*out_mem) = val; out_mem++;
}
}
}
inline
void
op_vectorise_cube_col::apply_proxy(Mat<typename T1::elem_type>& out, const ProxyCube<T1>& P)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT;
const uword N = P.get_n_elem();
out.set_size(N, 1);
if(is_Cube<typename ProxyCube<T1>::stored_type>::value == true)
{
const unwrap_cube<typename ProxyCube<T1>::stored_type> tmp(P.Q);
arrayops::copy(out.memptr(), tmp.M.memptr(), N);
}
else
{
eT* outmem = out.memptr();
if(ProxyCube<T1>::use_at == false)
{
typename ProxyCube<T1>::ea_type A = P.get_ea();
uword i,j;
for(i=0, j=1; j < N; i+=2, j+=2)
{
const eT tmp_i = A[i];
const eT tmp_j = A[j];
outmem[i] = tmp_i;
outmem[j] = tmp_j;
}
if(i < N)
{
outmem[i] = A[i];
}
}
else
{
const uword n_rows = P.get_n_rows();
const uword n_cols = P.get_n_cols();
const uword n_slices = P.get_n_slices();
for(uword slice=0; slice < n_slices; ++slice)
for(uword col=0; col < n_cols; ++col )
for(uword row=0; row < n_rows; ++row )
{
*outmem = P.at(row,col,slice);
outmem++;
}
}
}
}
inline
uword
op_find::helper
(
Mat<uword>& indices,
const mtGlue<uword, T1, T2, glue_type>& X,
const typename arma_glue_rel_only<glue_type>::result junk1,
const typename arma_not_cx<typename T1::elem_type>::result junk2,
const typename arma_not_cx<typename T2::elem_type>::result junk3
)
{
arma_extra_debug_sigprint();
arma_ignore(junk1);
arma_ignore(junk2);
arma_ignore(junk3);
typedef typename T1::elem_type eT1;
typedef typename T2::elem_type eT2;
typedef typename Proxy<T1>::ea_type ea_type1;
typedef typename Proxy<T2>::ea_type ea_type2;
const Proxy<T1> A(X.A);
const Proxy<T2> B(X.B);
arma_debug_assert_same_size(A, B, "relational operator");
ea_type1 PA = A.get_ea();
ea_type2 PB = B.get_ea();
const uword n_elem = B.get_n_elem();
indices.set_size(n_elem, 1);
uword* indices_mem = indices.memptr();
uword n_nz = 0;
for(uword i=0; i<n_elem; ++i)
{
const eT1 tmp1 = PA[i];
const eT2 tmp2 = PB[i];
bool not_zero;
if(is_same_type<glue_type, glue_rel_lt >::value == true) { not_zero = (tmp1 < tmp2); }
else if(is_same_type<glue_type, glue_rel_gt >::value == true) { not_zero = (tmp1 > tmp2); }
else if(is_same_type<glue_type, glue_rel_lteq >::value == true) { not_zero = (tmp1 <= tmp2); }
else if(is_same_type<glue_type, glue_rel_gteq >::value == true) { not_zero = (tmp1 >= tmp2); }
else if(is_same_type<glue_type, glue_rel_eq >::value == true) { not_zero = (tmp1 == tmp2); }
else if(is_same_type<glue_type, glue_rel_noteq >::value == true) { not_zero = (tmp1 != tmp2); }
else not_zero = false;
if(not_zero == true) { indices_mem[n_nz] = i; ++n_nz; }
}
return n_nz;
}
inline
u32
op_find::helper
(
Mat<u32>& indices,
const mtOp<u32, T1, op_type>& X,
const typename arma_op_rel_only<op_type>::result junk1,
const typename arma_not_cx<typename T1::elem_type>::result junk2
)
{
arma_extra_debug_sigprint();
arma_ignore(junk1);
arma_ignore(junk2);
typedef typename T1::elem_type eT;
const eT val = X.aux;
const Proxy<T1> P(X.m);
const u32 n_elem = P.get_n_elem();
indices.set_size(n_elem, 1);
u32* indices_mem = indices.memptr();
u32 n_nz = 0;
for(u32 i=0; i<n_elem; ++i)
{
const eT tmp = P[i];
bool not_zero;
if(is_same_type<op_type, op_rel_lt_pre >::value == true) { not_zero = (val < tmp); }
else if(is_same_type<op_type, op_rel_lt_post >::value == true) { not_zero = (tmp < val); }
else if(is_same_type<op_type, op_rel_gt_pre >::value == true) { not_zero = (val > tmp); }
else if(is_same_type<op_type, op_rel_gt_post >::value == true) { not_zero = (tmp > val); }
else if(is_same_type<op_type, op_rel_lteq_pre >::value == true) { not_zero = (val <= tmp); }
else if(is_same_type<op_type, op_rel_lteq_post>::value == true) { not_zero = (tmp <= val); }
else if(is_same_type<op_type, op_rel_gteq_pre >::value == true) { not_zero = (val >= tmp); }
else if(is_same_type<op_type, op_rel_gteq_post>::value == true) { not_zero = (tmp >= val); }
else if(is_same_type<op_type, op_rel_eq >::value == true) { not_zero = (tmp == val); }
else if(is_same_type<op_type, op_rel_noteq >::value == true) { not_zero = (tmp != val); }
else not_zero = false;
if(not_zero == true)
{
indices_mem[n_nz] = i;
++n_nz;
}
}
return n_nz;
}
inline
void
op_fliplr::apply_direct(Mat<eT>& out, const Mat<eT>& X)
{
arma_extra_debug_sigprint();
const uword X_n_rows = X.n_rows;
const uword X_n_cols = X.n_cols;
const uword X_n_cols_m1 = X_n_cols - 1;
if(&out != &X)
{
out.set_size(X_n_rows, X_n_cols);
if(X_n_rows == 1)
{
const eT* X_mem = X.memptr();
eT* out_mem = out.memptr();
for(uword col=0; col < X_n_cols; ++col)
{
out_mem[X_n_cols_m1 - col] = X_mem[col];
}
}
else
{
for(uword col=0; col < X_n_cols; ++col)
{
out.col(X_n_cols_m1 - col) = X.col(col);
}
}
}
else // in-place operation
{
const uword N = X_n_cols / 2;
if(X_n_rows == 1)
{
eT* out_mem = out.memptr();
for(uword col=0; col < N; ++col)
{
std::swap(out_mem[X_n_cols_m1 - col], out_mem[col]);
}
}
else
{
for(uword col=0; col < N; ++col)
{
out.swap_cols(X_n_cols_m1 - col, col);
}
}
}
}
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;
}
