arma_ostream_meat.hpp   arma_ostream_meat.hpp 
skipping to change at line 47 skipping to change at line 47
// //
// //
template<typename eT> template<typename eT>
inline inline
u32 u32
arma_ostream::modify_stream(std::ostream& o, const eT* data, const u32 n_el em) arma_ostream::modify_stream(std::ostream& o, const eT* data, const u32 n_el em)
{ {
o.unsetf(ios::showbase); o.unsetf(ios::showbase);
o.unsetf(ios::uppercase); o.unsetf(ios::uppercase);
o.unsetf(ios::showpos);
o.fill(' '); o.fill(' ');
u32 cell_width; u32 cell_width;
bool use_layout_B = false; bool use_layout_B = false;
bool use_layout_C = false; bool use_layout_C = false;
for(u32 i=0; i<n_elem; ++i) for(u32 i=0; i<n_elem; ++i)
{ {
const eT val = data[i]; const eT val = data[i];
 End of changes. 1 change blocks. 
0 lines changed or deleted 2 lines changed or added


 armadillo   armadillo 
skipping to change at line 301 skipping to change at line 301
#include "armadillo_bits/fn_repmat.hpp" #include "armadillo_bits/fn_repmat.hpp"
#include "armadillo_bits/fn_reshape.hpp" #include "armadillo_bits/fn_reshape.hpp"
#include "armadillo_bits/fn_cov.hpp" #include "armadillo_bits/fn_cov.hpp"
#include "armadillo_bits/fn_cor.hpp" #include "armadillo_bits/fn_cor.hpp"
#include "armadillo_bits/fn_shuffle.hpp" #include "armadillo_bits/fn_shuffle.hpp"
#include "armadillo_bits/fn_prod.hpp" #include "armadillo_bits/fn_prod.hpp"
#include "armadillo_bits/fn_eps.hpp" #include "armadillo_bits/fn_eps.hpp"
#include "armadillo_bits/fn_pinv.hpp" #include "armadillo_bits/fn_pinv.hpp"
#include "armadillo_bits/fn_rank.hpp" #include "armadillo_bits/fn_rank.hpp"
#include "armadillo_bits/fn_kron.hpp" #include "armadillo_bits/fn_kron.hpp"
#include "armadillo_bits/fn_as_scalar.hpp"
// //
// class meat // class meat
#include "armadillo_bits/gemm.hpp" #include "armadillo_bits/gemm.hpp"
#include "armadillo_bits/gemv.hpp" #include "armadillo_bits/gemv.hpp"
#include "armadillo_bits/gemm_mixed.hpp" #include "armadillo_bits/gemm_mixed.hpp"
#include "armadillo_bits/podarray_meat.hpp" #include "armadillo_bits/podarray_meat.hpp"
#include "armadillo_bits/auxlib_meat.hpp" #include "armadillo_bits/auxlib_meat.hpp"
 End of changes. 1 change blocks. 
0 lines changed or deleted 1 lines changed or added


 constants.hpp   constants.hpp 
skipping to change at line 158 skipping to change at line 158
typedef Math<float> fmath; typedef Math<float> fmath;
typedef Math<double> math; typedef Math<double> math;
typedef Phy<float> fphy; typedef Phy<float> fphy;
typedef Phy<double> phy; typedef Phy<double> phy;
struct arma_version struct arma_version
{ {
static const unsigned int major = 0; static const unsigned int major = 0;
static const unsigned int minor = 8; static const unsigned int minor = 8;
static const unsigned int patch = 0; static const unsigned int patch = 2;
}; };
struct arma_config struct arma_config
{ {
#if defined(ARMA_USE_ATLAS) #if defined(ARMA_USE_ATLAS)
static const bool atlas = true; static const bool atlas = true;
#else #else
static const bool atlas = false; static const bool atlas = false;
#endif #endif
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 fn_ones.hpp   fn_ones.hpp 
skipping to change at line 77 skipping to change at line 77
} }
} }
//! Delayed generation of a diagonal matrix with the diagonal elements set to one //! Delayed generation of a diagonal matrix with the diagonal elements set to one
inline inline
const Op<mat,op_ones_diag> const Op<mat,op_ones_diag>
eye(const u32 n_rows, const u32 n_cols) eye(const u32 n_rows, const u32 n_cols)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_debug_check( (n_rows != n_cols), "eye(): non-square matrix specified
" );
return Op<mat,op_ones_diag>(n_rows, n_cols, 'j'); return Op<mat,op_ones_diag>(n_rows, n_cols, 'j');
} }
template<typename mat_type> template<typename mat_type>
inline inline
const Op<mat_type,op_ones_diag> const Op<mat_type,op_ones_diag>
eye(const u32 n_rows, const u32 n_cols) eye(const u32 n_rows, const u32 n_cols)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
 End of changes. 1 change blocks. 
0 lines changed or deleted 3 lines changed or added


 op_eps_meat.hpp   op_eps_meat.hpp 
skipping to change at line 36 skipping to change at line 36
// acording to IEEE Standard for Floating-Point Arithmetic (IEEE 754) // acording to IEEE Standard for Floating-Point Arithmetic (IEEE 754)
// the mantissa length for double is 53 bits = std::numeric_limits<double >::digits // the mantissa length for double is 53 bits = std::numeric_limits<double >::digits
// the mantissa length for float is 24 bits = std::numeric_limits<float >::digits // the mantissa length for float is 24 bits = std::numeric_limits<float >::digits
//return std::pow( std::numeric_limits<eT>::radix, (std::floor(std::log10 (std::abs(x))/std::log10(std::numeric_limits<eT>::radix))-(std::numeric_lim its<eT>::digits-1)) ); //return std::pow( std::numeric_limits<eT>::radix, (std::floor(std::log10 (std::abs(x))/std::log10(std::numeric_limits<eT>::radix))-(std::numeric_lim its<eT>::digits-1)) );
const eT radix_eT = eT(std::numeric_limits<eT>::radix); const eT radix_eT = eT(std::numeric_limits<eT>::radix);
const eT digits_m1_eT = eT(std::numeric_limits<eT>::digits - 1); const eT digits_m1_eT = eT(std::numeric_limits<eT>::digits - 1);
return std::pow( radix_eT, (std::floor(std::log10(std::abs(x))/std::log10 (radix_eT)) - digits_m1_eT) ); return std::pow( radix_eT, eT(std::floor(std::log10(std::abs(x))/std::log 10(radix_eT)) - digits_m1_eT) );
} }
template<typename T> template<typename T>
inline inline
T T
op_eps::direct_eps(const std::complex<T>& x) op_eps::direct_eps(const std::complex<T>& x)
{ {
//arma_extra_debug_sigprint(); //arma_extra_debug_sigprint();
//return std::pow( std::numeric_limits<T>::radix, (std::floor(std::log10( std::abs(x))/std::log10(std::numeric_limits<T>::radix))-(std::numeric_limit s<T>::digits-1)) ); //return std::pow( std::numeric_limits<T>::radix, (std::floor(std::log10( std::abs(x))/std::log10(std::numeric_limits<T>::radix))-(std::numeric_limit s<T>::digits-1)) );
const T radix_T = T(std::numeric_limits<T>::radix); const T radix_T = T(std::numeric_limits<T>::radix);
const T digits_m1_T = T(std::numeric_limits<T>::digits - 1); const T digits_m1_T = T(std::numeric_limits<T>::digits - 1);
return std::pow( radix_T, (std::floor(std::log10(std::abs(x))/std::log10( radix_T)) - digits_m1_T) ); return std::pow( radix_T, T(std::floor(std::log10(std::abs(x))/std::log10 (radix_T)) - digits_m1_T) );
} }
template<typename eT> template<typename eT>
inline inline
void void
op_eps::direct_eps(Mat<eT>& out, const Mat<eT>& A) op_eps::direct_eps(Mat<eT>& out, const Mat<eT>& A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
out.copy_size(A); out.copy_size(A);
 End of changes. 2 change blocks. 
2 lines changed or deleted 2 lines changed or added


 op_inv_meat.hpp   op_inv_meat.hpp 
skipping to change at line 59 skipping to change at line 59
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
const unwrap<T1> tmp(in.m); const unwrap<T1> tmp(in.m);
typedef typename T1::elem_type eT; typedef typename T1::elem_type eT;
const Mat<eT>& X = tmp.M; const Mat<eT>& X = tmp.M;
op_inv::apply(out, X); op_inv::apply(out, X);
} }
#if defined(ARMA_GOOD_COMPILER)
//! inverse of diagmat(mat) //! inverse of diagmat(mat)
template<typename T1> template<typename T1>
inline inline
void void
op_inv::apply(Mat<typename T1::elem_type>& out, const Op< Op<T1,op_diagmat> , op_inv>& in) op_inv::apply(Mat<typename T1::elem_type>& out, const Op< Op<T1,op_diagmat> , op_inv>& in)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
const unwrap<T1> X_tmp(in.m.m); const unwrap<T1> X_tmp(in.m.m);
skipping to change at line 153 skipping to change at line 155
inline inline
void void
op_inv::apply(Mat<eT>& out, const Op< Op<Mat<eT>,op_diagmat_vec>, op_inv>& in) op_inv::apply(Mat<eT>& out, const Op< Op<Mat<eT>,op_diagmat_vec>, op_inv>& in)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
const Mat<eT>& X = in.m.m; const Mat<eT>& X = in.m.m;
op_inv::apply_diagvec(out, X); op_inv::apply_diagvec(out, X);
} }
#endif
//! @} //! @}
 End of changes. 2 change blocks. 
0 lines changed or deleted 4 lines changed or added


 op_inv_proto.hpp   op_inv_proto.hpp 
skipping to change at line 32 skipping to change at line 32
public: public:
// mat // mat
template<typename eT> template<typename eT>
inline static void apply(Mat<eT>& out, const Mat<eT>& A); inline static void apply(Mat<eT>& out, const Mat<eT>& A);
template<typename T1> template<typename T1>
inline static void apply(Mat<typename T1::elem_type>& out, const Op<T1,op _inv>& in); inline static void apply(Mat<typename T1::elem_type>& out, const Op<T1,op _inv>& in);
#if defined(ARMA_GOOD_COMPILER)
template<typename T1> template<typename T1>
inline static void apply(Mat<typename T1::elem_type>& out, const Op< Op<T 1,op_diagmat>, op_inv>& in); inline static void apply(Mat<typename T1::elem_type>& out, const Op< Op<T 1,op_diagmat>, op_inv>& in);
//
template<typename eT> template<typename eT>
inline static void apply_diagvec(Mat<eT>& out, const Mat<eT>& X); inline static void apply_diagvec(Mat<eT>& out, const Mat<eT>& X);
template<typename eT> template<typename eT>
inline static void apply(Mat<eT>& out, const Op< Op<Mat<eT>,op_diagmat_ve c>, op_inv>& in); inline static void apply(Mat<eT>& out, const Op< Op<Mat<eT>,op_diagmat_ve c>, op_inv>& in);
#endif
}; };
//! @} //! @}
 End of changes. 3 change blocks. 
2 lines changed or deleted 4 lines changed or added


 op_randn_meat.hpp   op_randn_meat.hpp 
skipping to change at line 41 skipping to change at line 41
op_randn::randn() op_randn::randn()
{ {
const u32 N = 12; const u32 N = 12;
eT acc = eT(0); eT acc = eT(0);
for(u32 i=0; i<N; ++i) for(u32 i=0; i<N; ++i)
{ {
acc += eT(std::rand()) / eT(RAND_MAX); acc += eT(std::rand()) / eT(RAND_MAX);
} }
return acc/eT(N) - eT(0.5); //return acc/eT(N) - eT(0.5);
return acc - eT(N/2);
} }
template<typename eT> template<typename eT>
inline inline
void void
op_randn::direct_randn(eT* x, const u32 n_elem) op_randn::direct_randn(eT* x, const u32 n_elem)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
for(u32 i=0; i<n_elem; ++i) for(u32 i=0; i<n_elem; ++i)
 End of changes. 1 change blocks. 
1 lines changed or deleted 2 lines changed or added


 operator_cube_div.hpp   operator_cube_div.hpp 
skipping to change at line 72 skipping to change at line 72
template<typename eT1, typename T1, typename eT2, typename T2> template<typename eT1, typename T1, typename eT2, typename T2>
arma_inline arma_inline
Cube<typename promote_type<eT1,eT2>::result> Cube<typename promote_type<eT1,eT2>::result>
operator/ operator/
(const BaseCube<eT1,T1>& X, const BaseCube<eT2,T2>& Y) (const BaseCube<eT1,T1>& X, const BaseCube<eT2,T2>& Y)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
promote_type<eT1,eT2>::check(); promote_type<eT1,eT2>::check();
const unwrap<T1> tmp1(X.get_ref()); const unwrap_cube<T1> tmp1(X.get_ref());
const unwrap<T2> tmp2(Y.get_ref()); const unwrap_cube<T2> tmp2(Y.get_ref());
const Cube<eT1>& A = tmp1.M; const Cube<eT1>& A = tmp1.M;
const Cube<eT2>& B = tmp2.M; const Cube<eT2>& B = tmp2.M;
Cube< typename promote_type<eT1,eT2>::result > out; Cube< typename promote_type<eT1,eT2>::result > out;
glue_cube_div::apply_mixed(out, A, B); glue_cube_div::apply_mixed(out, A, B);
return out; return out;
} }
 End of changes. 1 change blocks. 
2 lines changed or deleted 2 lines changed or added


 operator_cube_relational.hpp   operator_cube_relational.hpp 
skipping to change at line 161 skipping to change at line 161
ucube out(A.n_rows, A.n_cols, A.n_slices); ucube out(A.n_rows, A.n_cols, A.n_slices);
const eT* A_mem = A.mem; const eT* A_mem = A.mem;
const eT* B_mem = B.mem; const eT* B_mem = B.mem;
typedef typename ucube::elem_type ucube_elem_type; typedef typename ucube::elem_type ucube_elem_type;
ucube_elem_type* out_mem = out.memptr(); ucube_elem_type* out_mem = out.memptr();
for(u32 i=0; i<A.n_elem; ++i) for(u32 i=0; i<A.n_elem; ++i)
{ {
if(A_mem[i] == B_mem[i]) if(A_mem[i] <= B_mem[i])
{ {
out_mem[i] = ucube_elem_type(1); out_mem[i] = ucube_elem_type(1);
} }
else else
{ {
out_mem[i] = ucube_elem_type(0); out_mem[i] = ucube_elem_type(0);
} }
} }
return out; return out;
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 operator_div.hpp   operator_div.hpp 
skipping to change at line 220 skipping to change at line 220
arma_inline arma_inline
const Glue<T1, T2, glue_div> const Glue<T1, T2, glue_div>
operator/ operator/
(const Base<u8,T1>& X, const Base<u8,T2>& Y) (const Base<u8,T1>& X, const Base<u8,T2>& Y)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
return Glue<T1, T2, glue_div>(X.get_ref(), Y.get_ref()); return Glue<T1, T2, glue_div>(X.get_ref(), Y.get_ref());
} }
//
// old operators
//
// //! mat / scalar
// template<typename mT>
// arma_inline
// const Op<Mat<mT>, op_scalar_div_post>
// operator/
// (const Mat<mT>& X, const mT k)
// {
// arma_extra_debug_sigprint();
//
// return Op<Mat<mT>, op_scalar_div_post>(X, k);
// }
//
//
//
// //! op / scalar
// template<typename T1, typename op_type>
// arma_inline
// const Op< Op<T1,op_type>, op_scalar_div_post>
// operator/
// (const Op<T1,op_type>& X, const typename T1::elem_type k)
// {
// arma_extra_debug_sigprint();
//
// return Op< Op<T1,op_type>, op_scalar_div_post>(X, k);
// }
//
//
//
// //! op / scalar, level 2
// template<typename T1>
// arma_inline
// const Op<T1,op_scalar_div_post>
// operator/
// (const Op<T1,op_scalar_div_post>& X, const typename T1::elem_type k)
// {
// arma_extra_debug_sigprint();
//
// return Op<T1, op_scalar_div_post>(X.m, X.aux / k);
// }
//
//
//
// //! glue / scalar
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Op<Glue<T1,T2,glue_type>, op_scalar_div_post>
// operator/
// (const Glue<T1,T2,glue_type>& X, const typename T1::elem_type k)
// {
// arma_extra_debug_sigprint();
//
// return Op<Glue<T1,T2,glue_type>, op_scalar_div_post>(X, k);
// }
//
//
//
// //! Op<mat,op_ones_full> / scalar
// template<typename mT>
// arma_inline
// Mat<mT>
// operator/
// (const Op<Mat<mT>,op_ones_full>& X, const mT k)
// {
// arma_extra_debug_sigprint();
//
// Mat<mT> tmp(X.aux_u32_a, X.aux_u32_b);
// tmp.fill( mT(1)/k );
//
// return tmp;
// }
//
//
//
// //! Op<mat,op_ones_diag> / scalar
// template<typename mT>
// arma_inline
// Mat<mT>
// operator/
// (const Op<Mat<mT>,op_ones_diag>& X, const mT k)
// {
// arma_extra_debug_sigprint();
//
// Mat<mT> out;
// out.zeros(X.aux_u32_a, X.aux_u32_b);
//
// const mT inv_k = mT(1)/k;
//
// for(u32 i=0; i<out.n_rows; ++i)
// {
// out.at(i,i) = inv_k;
// }
//
// return out;
// }
//
//
//
// //! scalar / mat
// template<typename mT>
// arma_inline
// const Op<Mat<mT>, op_scalar_div_pre>
// operator/
// (const mT k, const Mat<mT>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<Mat<mT>, op_scalar_div_pre>(X, k);
// }
//
//
//
// //! scalar / op
// template<typename T1, typename op_type>
// arma_inline
// const Op< Op<T1,op_type>, op_scalar_div_pre>
// operator/
// (const typename T1::elem_type k, const Op<T1,op_type>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op< Op<T1,op_type>, op_scalar_div_pre>(X, k);
// }
//
//
//
// //! scalar / glue
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Op<Glue<T1,T2,glue_type>, op_scalar_div_pre>
// operator/
// (const typename T1::elem_type k, const Glue<T1,T2,glue_type>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<Glue<T1,T2,glue_type>, op_scalar_div_pre>(X, k);
// }
//
//
//
// //! mat / mat
// template<typename mT>
// arma_inline
// const Glue<Mat<mT>, Mat<mT>, glue_div>
// operator/
// (const Mat<mT>& X, const Mat<mT>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<mT>, Mat<mT>, glue_div>(X,Y);
// }
//
//
//
// //! mat / op
// template<typename T1, typename op_type>
// arma_inline
// const Glue<Mat<typename T1::elem_type>, Op<T1,op_type>, glue_div>
// operator/
// (const Mat<typename T1::elem_type>& X, const Op<T1,op_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<typename T1::elem_type>, Op<T1,op_type>, glue_div>(X,Y
);
// }
//
//
//
// //! mat / glue
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Glue<Mat<typename T1::elem_type>, Glue<T1, T2,glue_type>, glue_div
>
// operator/
// (const Mat<typename T1::elem_type>& X, const Glue<T1, T2,glue_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<typename T1::elem_type>, Glue<T1, T2,glue_type>, glue_
div>(X,Y);
// }
//
//
//
// //! op / mat
// template<typename T1, typename op_type>
// arma_inline
// const Glue<Op<T1,op_type>, Mat<typename T1::elem_type>, glue_div>
// operator/
// (const Op<T1,op_type>& X, const Mat<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type>, Mat<typename T1::elem_type>, glue_div>(X,Y
);
// }
//
//
//
// //! op / op
// template<typename T1, typename op_type1, typename T2, typename op_type2>
// arma_inline
// const Glue<Op<T1,op_type1>, Op<T2,op_type2>, glue_div>
// operator/
// (const Op<T1,op_type1>& X, const Op<T2,op_type2>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type1>, Op<T2,op_type2>, glue_div>(X,Y);
// }
//
//
//
// //! op / glue
// template<typename T1, typename op_type, typename T2, typename T3, typena
me glue_type>
// arma_inline
// const Glue<Op<T1,op_type>, Glue<T2, T3, glue_type>, glue_div>
// operator/
// (const Op<T1,op_type>& X, const Glue<T2, T3, glue_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type>, Glue<T2, T3, glue_type>, glue_div>(X,Y);
// }
//
//
//
// //! glue / mat
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Glue<Glue<T1, T2,glue_type>, Mat<typename T1::elem_type>, glue_div
>
// operator/
// (const Glue<T1, T2,glue_type>& X, const Mat<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Glue<T1, T2,glue_type>, Mat<typename T1::elem_type>, glue_
div>(X,Y);
// }
//
//
//
// //! glue / op
// template<typename T1, typename op_type, typename T2, typename T3, typena
me glue_type>
// arma_inline
// const Glue<Glue<T2, T3, glue_type>, Op<T1,op_type>, glue_div>
// operator/
// (const Glue<T2, T3, glue_type>& X, const Op<T1,op_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Glue<T2, T3, glue_type>, Op<T1,op_type>, glue_div>(X,Y);
// }
//
//
//
// //! glue / glue
// template<typename T1, typename T2, typename glue_type1, typename T3, typ
ename T4, typename glue_type2>
// arma_inline
// const Glue<Glue<T1,T2,glue_type1>, Glue<T3,T4,glue_type2>, glue_div>
// operator/
// (const Glue<T1,T2,glue_type1>& X, const Glue<T3,T4,glue_type2>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Glue<T1,T2,glue_type1>, Glue<T3,T4,glue_type2>, glue_div>(
X,Y);
// }
//
//
//
// //! Base / subview
// template<typename T1>
// arma_inline
// const Glue<T1, subview<typename T1::elem_type>, glue_div>
// operator/
// (const Base<T1>& X, const subview<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<T1, subview<typename T1::elem_type>, glue_div>(X.get_ref()
,Y);
// }
//
//
//
// //! subview / Base
// template<typename T1>
// arma_inline
// const Glue<subview<typename T1::elem_type>, T1, glue_div>
// operator/
// (const subview<typename T1::elem_type>& X, const Base<T1>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<subview<typename T1::elem_type>, T1, glue_div>(X,Y.get_ref
());
// }
//
//
//
// //! Base / diagview
// template<typename T1>
// arma_inline
// const Glue<T1, diagview<typename T1::elem_type>, glue_div>
// operator/
// (const Base<T1>& X, const diagview<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<T1, diagview<typename T1::elem_type>, glue_div>(X.get_ref(
),Y);
// }
//
//
//
// //! diagview / Base
// template<typename T1>
// arma_inline
// const Glue<diagview<typename T1::elem_type>, T1, glue_div>
// operator/
// (const diagview<typename T1::elem_type>& X, const Base<T1>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<diagview<typename T1::elem_type>, T1, glue_div>(X,Y.get_re
f());
// }
//
//
//
// //! scalar / subview
// template<typename mT>
// arma_inline
// const Op<subview<mT>, op_scalar_div_pre>
// operator/
// (const mT k, const subview<mT>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<subview<mT>, op_scalar_div_pre>(X,k);
// }
//
//
//
// //! scalar / diagview
// template<typename mT>
// arma_inline
// const Op<diagview<mT>, op_scalar_div_pre>
// operator/
// (const mT k, const diagview<mT>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<diagview<mT>, op_scalar_div_pre>(X,k);
// }
//
//
//
// //! subview / scalar
// template<typename mT>
// arma_inline
// const Op<subview<mT>, op_scalar_div_post>
// operator/
// (const subview<mT>& X, const mT k)
// {
// arma_extra_debug_sigprint();
//
// return Op<subview<mT>, op_scalar_div_post>(X,k);
// }
//
//
//
// //! diagview / scalar
// template<typename mT>
// arma_inline
// const Op<diagview<mT>, op_scalar_div_post>
// operator/
// (const diagview<mT>& X, const mT k)
// {
// arma_extra_debug_sigprint();
//
// return Op<diagview<mT>, op_scalar_div_post>(X,k);
// }
//! @} //! @}
 End of changes. 1 change blocks. 
393 lines changed or deleted 0 lines changed or added


 operator_minus.hpp   operator_minus.hpp 
skipping to change at line 108 skipping to change at line 108
arma_inline arma_inline
const Glue< Op<T1,op_diagmat>, T2, glue_minus_diag> const Glue< Op<T1,op_diagmat>, T2, glue_minus_diag>
operator- operator-
(const Op<T1,op_diagmat>& X, const Base<typename T1::elem_type,T2>& Y) (const Op<T1,op_diagmat>& X, const Base<typename T1::elem_type,T2>& Y)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
return Glue< Op<T1,op_diagmat>, T2, glue_minus_diag>(X, Y.get_ref()); return Glue< Op<T1,op_diagmat>, T2, glue_minus_diag>(X, Y.get_ref());
} }
//! diagmat - diagmat
template<typename T1, typename T2>
inline
Mat< typename promote_type<typename T1::elem_type, typename T2::elem_type>:
:result >
operator-
(const Op<T1, op_diagmat>& X, const Op<T2, op_diagmat>& Y)
{
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 unwrap<T1> tmp1(X.m);
const unwrap<T2> tmp2(Y.m);
const Mat<eT1> A(tmp1.M);
const Mat<eT2> B(tmp2.M);
arma_debug_assert_same_size(A.n_rows, A.n_cols, B.n_rows, B.n_cols, "matr
ix subtraction");
Mat<out_eT> out(A.n_rows, A.n_rows);
out.zeros();
for(u32 i=0; i<A.n_rows; ++i)
{
out.at(i,i) = upgrade_val<eT1,eT2>::apply( A.at(i,i) ) - upgrade_val<eT
1,eT2>::apply( B.at(i,i) );
}
return out;
}
//! Base - Op<T2,op_neg> = Base + T2 //! Base - Op<T2,op_neg> = Base + T2
template<typename T1, typename T2> template<typename T1, typename T2>
arma_inline arma_inline
const Glue<T1, T2, glue_plus> const Glue<T1, T2, glue_plus>
operator- operator-
(const Base<typename T2::elem_type,T1>& X, const Op<T2, op_neg>& Y) (const Base<typename T2::elem_type,T1>& X, const Op<T2, op_neg>& Y)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
return Glue<T1, T2, glue_plus>(X.get_ref(), Y.m); return Glue<T1, T2, glue_plus>(X.get_ref(), Y.m);
skipping to change at line 276 skipping to change at line 311
arma_inline arma_inline
const Glue<T1, T2, glue_minus> const Glue<T1, T2, glue_minus>
operator- operator-
(const Base<u8,T1>& X, const Base<u8,T2>& Y) (const Base<u8,T1>& X, const Base<u8,T2>& Y)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
return Glue<T1, T2, glue_minus>(X.get_ref(), Y.get_ref()); return Glue<T1, T2, glue_minus>(X.get_ref(), Y.get_ref());
} }
//
// old operators
//
// //! unary -
// template<typename mT>
// arma_inline
// const Op<Mat<mT>, op_neg>
// operator-
// (const Mat<mT>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<Mat<mT>,op_neg>(X);
// }
//
//
//
// //! unary -
// template<typename T1, typename op_type>
// arma_inline
// const Op< Op<T1, op_type>, op_neg >
// operator-
// (const Op<T1, op_type>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<Op<T1, op_type>,op_neg>(X);
// }
//
//
//
// //! cancellation of two consecutive negations: -(-T1)
// template<typename T1>
// arma_inline
// const T1&
// operator-
// (const Op<T1, op_neg>& X)
// {
// arma_extra_debug_sigprint();
//
// return X.m;
// }
//
//
//
// //! -(Glue<T1,T2,glue_type>)
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Op< Glue<T1,T2,glue_type>, op_neg >
// operator-
// (const Glue<T1,T2,glue_type>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op< Glue<T1,T2,glue_type>,op_neg >(X);
// }
//
//
//
// //! mat - scalar
// template<typename mT>
// arma_inline
// const Op<Mat<mT>, op_scalar_minus_post>
// operator-
// (const Mat<mT>& X, const mT k)
// {
// arma_extra_debug_sigprint();
//
// return Op<Mat<mT>, op_scalar_minus_post>(X,k);
// }
//
//
//
// //! op - scalar
// template<typename T1, typename op_type>
// arma_inline
// const Op<Op<T1,op_type>, op_scalar_minus_post>
// operator-
// (const Op<T1,op_type>& X, const typename T1::elem_type k)
// {
// arma_extra_debug_sigprint();
//
// return Op<Op<T1,op_type>, op_scalar_minus_post>(X,k);
// }
//
//
//
// //! op - scalar, level 2
// template<typename T1>
// arma_inline
// const Op<T1, op_scalar_minus_post>
// operator-
// (const Op<T1,op_scalar_plus>& X, const typename T1::elem_type k)
// {
// arma_extra_debug_sigprint();
//
// return Op<T1,op_scalar_minus_post>(X.m, X.aux - k);
// }
//
//
//
// //! glue - scalar
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Op<Glue<T1,T2,glue_type>, op_scalar_minus_post>
// operator-
// (const Glue<T1,T2,glue_type>& X, const typename T1::elem_type k)
// {
// arma_extra_debug_sigprint();
//
// return Op<Glue<T1,T2,glue_type>, op_scalar_minus_post>(X,k);
// }
//
//
//
// //! scalar - mat
// template<typename mT>
// arma_inline
// const Op<Mat<mT>, op_scalar_minus_pre>
// operator-
// (const mT k, const Mat<mT>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<Mat<mT>, op_scalar_minus_pre>(X,k);
// }
//
//
//
// //! scalar - op
// template<typename T1, typename op_type>
// arma_inline
// const Op<Op<T1,op_type>, op_scalar_minus_pre>
// operator-
// (const typename T1::elem_type k, const Op<T1,op_type>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<Op<T1,op_type>, op_scalar_minus_pre>(X,k);
// }
//
//
//
// //! scalar - glue
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Op<Glue<T1,T2,glue_type>, op_scalar_minus_pre>
// operator-
// (const typename T1::elem_type k, const Glue<T1,T2,glue_type>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<Glue<T1,T2,glue_type>, op_scalar_minus_pre>(X,k);
// }
//
//
//
// //! mat - mat
// template<typename mT>
// arma_inline
// const Glue<Mat<mT>, Mat<mT>, glue_minus>
// operator-
// (const Mat<mT>& X, const Mat<mT>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<mT>, Mat<mT>, glue_minus>(X,Y);
// }
//
//
//
// //! mat - diagmat(T1)
// template<typename T1>
// arma_inline
// const Glue<Mat<typename T1::elem_type>, Op<T1,op_diagmat>, glue_minus_di
ag>
// operator-
// (const Mat<typename T1::elem_type>& X, const Op<T1,op_diagmat>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<typename T1::elem_type>, Op<T1,op_diagmat>, glue_minus
_diag>(X,Y);
// }
//
//
//
// //! diagmat(T1) - mat
// template<typename T1>
// arma_inline
// const Glue< Op<T1,op_diagmat>, Mat<typename T1::elem_type>, glue_minus_d
iag>
// operator-
// (const Op<T1,op_diagmat>& X, const Mat<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue< Op<T1,op_diagmat>, Mat<typename T1::elem_type>, glue_minu
s_diag>(X,Y);
// }
//
//
//
// //! diagmat(T1) - diagmat(T2)
// template<typename T1, typename T2>
// arma_inline
// const Glue< Op<T1,op_diagmat>, Op<T2,op_diagmat>, glue_minus_diag>
// operator-
// (const Op<T1,op_diagmat>& X, const Op<T2,op_diagmat>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue< Op<T1,op_diagmat>, Op<T2,op_diagmat>, glue_minus_diag>(X,
Y);
// }
//
//
//
// //! mat - op
// template<typename T1, typename op_type>
// arma_inline
// const Glue<Mat<typename T1::elem_type>, Op<T1,op_type>, glue_minus>
// operator-
// (const Mat<typename T1::elem_type>& X, const Op<T1,op_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<typename T1::elem_type>, Op<T1,op_type>, glue_minus>(X
,Y);
// }
//
//
//
// //! diagmat(T1) - op
// template<typename T1, typename T2, typename op_type>
// arma_inline
// const Glue< Op<T1,op_diagmat>, Op<T2,op_type>, glue_minus_diag>
// operator-
// (const Op<T1,op_diagmat>& X, const Op<T2,op_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue< Op<T1,op_diagmat>, Op<T2,op_type>, glue_minus_diag>(X,Y);
// }
//
//
//
// //! op - mat
// template<typename T1, typename op_type>
// arma_inline
// const Glue<Op<T1,op_type>, Mat<typename T1::elem_type>, glue_minus>
// operator-
// (const Op<T1,op_type>& X, const Mat<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type>, Mat<typename T1::elem_type>, glue_minus>(X
,Y);
// }
//
//
//
// //! op - diagmat(T2)
// template<typename T1, typename op_type, typename T2>
// arma_inline
// const Glue<Op<T1,op_type>, Op<T2,op_diagmat>, glue_minus_diag>
// operator-
// (const Op<T1,op_type>& X, const Op<T2,op_diagmat>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type>, Op<T2,op_diagmat>, glue_minus_diag>(X,Y);
// }
//
//
//
// //! op - glue
// template<typename T1, typename op_type, typename T2, typename T3, typena
me glue_type>
// arma_inline
// const Glue<Op<T1,op_type>, Glue<T2, T3, glue_type>, glue_minus>
// operator-
// (const Op<T1,op_type>& X, const Glue<T2, T3, glue_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type>, Glue<T2, T3, glue_type>, glue_minus>(X,Y);
// }
//
//
//
// //! glue - op
// template<typename T1, typename op_type, typename T2, typename T3, typena
me glue_type>
// arma_inline
// const Glue<Glue<T2, T3, glue_type>, Op<T1,op_type>, glue_minus>
// operator-
// (const Glue<T2, T3, glue_type>& X, const Op<T1,op_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Glue<T2, T3, glue_type>, Op<T1,op_type>, glue_minus>(X,Y);
// }
//
//
//
// //! mat - glue
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Glue<Mat<typename T1::elem_type>, Glue<T1, T2,glue_type>, glue_min
us>
// operator-
// (const Mat<typename T1::elem_type>& X, const Glue<T1, T2,glue_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<typename T1::elem_type>, Glue<T1, T2,glue_type>, glue_
minus>(X,Y);
// }
//
//
//
// //! diagmat(T1) - glue
// template<typename T1, typename T2, typename T3, typename glue_type>
// arma_inline
// const Glue<Op<T1,op_diagmat>, Glue<T2,T3,glue_type>, glue_minus_diag>
// operator-
// (const Op<T1,op_diagmat>& X, const Glue<T2,T3,glue_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_diagmat>, Glue<T2,T3,glue_type>, glue_minus_diag>
(X,Y);
// }
//
//
//
// //! glue - mat
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Glue< Glue<T1,T2,glue_type>, Mat<typename T1::elem_type>, glue_min
us>
// operator-
// (const Glue<T1,T2,glue_type>& X, const Mat<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue< Glue<T1,T2,glue_type>, Mat<typename T1::elem_type>, glue_
minus>(X,Y);
// }
//
//
//
// //! glue - diagmat(T1)
// template<typename T1, typename T2, typename glue_type, typename T3>
// arma_inline
// const Glue< Glue<T1,T2,glue_type>, Op<T3,op_diagmat>, glue_minus_diag>
// operator-
// (const Glue<T1,T2,glue_type>& X, const Op<T3,op_diagmat>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue< Glue<T1,T2,glue_type>, Op<T3,op_diagmat>, glue_minus_diag
>(X,Y);
// }
//
//
//
// //! op - op
// template<typename T1, typename op_type1, typename T2, typename op_type2>
// arma_inline
// const Glue<Op<T1,op_type1>, Op<T2,op_type2>, glue_minus>
// operator-
// (const Op<T1,op_type1>& X, const Op<T2,op_type2>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type1>, Op<T2,op_type2>, glue_minus>(X,Y);
// }
//
//
//
// //! glue - glue
// template<typename T1, typename T2, typename glue_type1, typename T3, typ
ename T4, typename glue_type2>
// arma_inline
// const Glue<Glue<T1,T2,glue_type1>, Glue<T3,T4,glue_type2>, glue_minus>
// operator-
// (const Glue<T1,T2,glue_type1>& X, const Glue<T3,T4,glue_type2>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Glue<T1,T2,glue_type1>, Glue<T3,T4,glue_type2>, glue_minus
>(X,Y);
// }
//
//
//
// //! mat - Op<T2,op_neg> = mat + T2
// template<typename T2>
// arma_inline
// const Glue<Mat<typename T2::elem_type>, T2, glue_plus>
// operator-
// (const Mat<typename T2::elem_type>& X, const Op<T2, op_neg>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<typename T2::elem_type>, T2, glue_plus>(X,Y.m);
// }
//
//
//
// //! diagmat - Op<T2,op_neg> = diagmat + T2
// template<typename T1, typename T2>
// arma_inline
// const Glue< Op<T1,op_diagmat>, T2, glue_plus_diag>
// operator-
// (const Op<T1,op_diagmat>& X, const Op<T2, op_neg>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue< Op<T1,op_diagmat>, T2, glue_plus_diag>(X,Y.m);
// }
//
//
//
// //! op - Op<T2,op_neg> = op + T2
// template<typename T1, typename op_type, typename T2>
// arma_inline
// const Glue<Op<T1, op_type>, T2, glue_plus>
// operator-
// (const Op<T1, op_type>& X, const Op<T2, op_neg>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue< Op<T1, op_type>, T2, glue_plus>(X,Y.m);
// }
//
//
//
// //! glue - Op<T3,op_neg> = glue + T3
// template<typename T1, typename T2, typename glue_type, typename T3>
// arma_inline
// const Glue<Glue<T1,T2,glue_type>, T3, glue_plus>
// operator-
// (const Glue<T1,T2,glue_type>& X, const Op<T3, op_neg>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue< Glue<T1,T2,glue_type>, T3, glue_plus>(X,Y.m);
// }
//
//
//
// //! Base - subview
// template<typename T1>
// arma_inline
// const Glue<T1, subview<typename T1::elem_type>, glue_minus>
// operator-
// (const Base<T1>& X, const subview<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<T1, subview<typename T1::elem_type>, glue_minus>(X.get_ref
(),Y);
// }
//
//
//
// //! subview - Base
// template<typename T1>
// arma_inline
// const Glue<subview<typename T1::elem_type>, T1, glue_minus>
// operator-
// (const subview<typename T1::elem_type>& X, const Base<T1>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<subview<typename T1::elem_type>, T1, glue_minus>(X,Y.get_r
ef());
// }
//
//
//
// //! Base - diagview
// template<typename T1>
// arma_inline
// const Glue<T1, diagview<typename T1::elem_type>, glue_minus>
// operator-
// (const Base<T1>& X, const diagview<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<T1, diagview<typename T1::elem_type>, glue_minus>(X.get_re
f(),Y);
// }
//
//
//
// //! diagview - Base
// template<typename T1>
// arma_inline
// const Glue<diagview<typename T1::elem_type>, T1, glue_minus>
// operator-
// (const diagview<typename T1::elem_type>& X, const Base<T1>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<diagview<typename T1::elem_type>, T1, glue_minus>(X,Y.get_
ref());
// }
//
//
//
// //! scalar - subview
// template<typename mT>
// arma_inline
// const Op<subview<mT>, op_scalar_minus_pre>
// operator-
// (const mT k, const subview<mT>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<subview<mT>, op_scalar_minus_pre>(X,k);
// }
//
//
//
// //! scalar - diagview
// template<typename mT>
// arma_inline
// const Op<diagview<mT>, op_scalar_minus_pre>
// operator-
// (const mT k, const diagview<mT>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<diagview<mT>, op_scalar_minus_pre>(X,k);
// }
//
//
//
// //! subview - scalar
// template<typename mT>
// arma_inline
// const Op<subview<mT>, op_scalar_minus_post>
// operator-
// (const subview<mT>& X, const mT k)
// {
// arma_extra_debug_sigprint();
//
// return Op<subview<mT>, op_scalar_minus_post>(X,k);
// }
//
//
//
// //! diagview - scalar
// template<typename mT>
// arma_inline
// const Op<diagview<mT>, op_scalar_minus_post>
// operator-
// (const diagview<mT>& X, const mT k)
// {
// arma_extra_debug_sigprint();
//
// return Op<diagview<mT>, op_scalar_minus_post>(X,k);
// }
//! @} //! @}
 End of changes. 2 change blocks. 
569 lines changed or deleted 38 lines changed or added


 operator_plus.hpp   operator_plus.hpp 
skipping to change at line 90 skipping to change at line 90
arma_inline arma_inline
const Glue<T1, Op<T2,op_diagmat>, glue_plus_diag> const Glue<T1, Op<T2,op_diagmat>, glue_plus_diag>
operator+ operator+
(const Op<T2,op_diagmat>& Y, const Base<typename T1::elem_type, T1>& X) (const Op<T2,op_diagmat>& Y, const Base<typename T1::elem_type, T1>& X)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
return Glue<T1, Op<T2,op_diagmat>, glue_plus_diag>(X.get_ref(), Y); // N OTE: order is swapped return Glue<T1, Op<T2,op_diagmat>, glue_plus_diag>(X.get_ref(), Y); // N OTE: order is swapped
} }
//! diagmat + diagmat
template<typename T1, typename T2>
inline
Mat< typename promote_type<typename T1::elem_type, typename T2::elem_type>:
:result >
operator+
(const Op<T1, op_diagmat>& X, const Op<T2, op_diagmat>& Y)
{
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 unwrap<T1> tmp1(X.m);
const unwrap<T2> tmp2(Y.m);
const Mat<eT1> A(tmp1.M);
const Mat<eT2> B(tmp2.M);
arma_debug_assert_same_size(A.n_rows, A.n_cols, B.n_rows, B.n_cols, "matr
ix addition");
Mat<out_eT> out(A.n_rows, A.n_rows);
out.zeros();
for(u32 i=0; i<A.n_rows; ++i)
{
out.at(i,i) = upgrade_val<eT1,eT2>::apply( A.at(i,i) ) + upgrade_val<eT
1,eT2>::apply( B.at(i,i) );
}
return out;
}
// //
// addition of Base objects with different element types // addition of Base objects with different element types
// //
//! Base + Base //! Base + Base
template<typename eT1, typename T1, typename eT2, typename T2> template<typename eT1, typename T1, typename eT2, typename T2>
arma_inline arma_inline
Mat<typename promote_type<eT1,eT2>::result> Mat<typename promote_type<eT1,eT2>::result>
operator+ operator+
(const Base<eT1,T1>& X, const Base<eT2,T2>& Y) (const Base<eT1,T1>& X, const Base<eT2,T2>& Y)
skipping to change at line 231 skipping to change at line 266
arma_inline arma_inline
const Glue<T1, T2, glue_plus> const Glue<T1, T2, glue_plus>
operator+ operator+
(const Base<u8,T1>& X, const Base<u8,T2>& Y) (const Base<u8,T1>& X, const Base<u8,T2>& Y)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
return Glue<T1, T2, glue_plus>(X.get_ref(), Y.get_ref()); return Glue<T1, T2, glue_plus>(X.get_ref(), Y.get_ref());
} }
//
// old operators
//
// //! unary plus operation (does nothing, but is required for completeness
)
// template<typename mT>
// arma_inline
// const Mat<mT>&
// operator+
// (const Mat<mT>& X)
// {
// arma_extra_debug_sigprint();
//
// return X;
// }
//
//
//
// //! unary plus operation (does nothing, but is required for completeness
)
// template<typename T1, typename op_type>
// arma_inline
// const Op<T1, op_type>&
// operator+
// (const Op<T1, op_type>& X)
// {
// arma_extra_debug_sigprint();
//
// return X;
// }
//
// //! unary plus operation (does nothing, but is required for completeness
)
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Glue<T1, T2, glue_type>&
// operator+
// (const Glue<T1, T2, glue_type>& X)
// {
// arma_extra_debug_sigprint();
//
// return X;
// }
//
//
//
// //! mat + scalar
// template<typename mT>
// arma_inline
// const Op<Mat<mT>, op_scalar_plus>
// operator+
// (const Mat<mT>& X, const mT k)
// {
// arma_extra_debug_sigprint();
//
// return Op<Mat<mT>, op_scalar_plus>(X,k);
// }
//
//
//
// //! op + scalar
// template<typename T1, typename op_type>
// arma_inline
// const Op<Op<T1,op_type>, op_scalar_plus>
// operator+
// (const Op<T1,op_type>& X, const typename T1::elem_type k)
// {
// arma_extra_debug_sigprint();
//
// return Op<Op<T1,op_type>, op_scalar_plus>(X,k);
// }
//
//
//
// //! op + scalar, level 2
// template<typename T1>
// arma_inline
// const Op<T1,op_scalar_plus>
// operator+
// (const Op<T1,op_scalar_plus>& X, const typename T1::elem_type k)
// {
// arma_extra_debug_sigprint();
//
// return Op<T1, op_scalar_plus>(X.m, X.aux + k);
// }
//
//
// //! glue + scalar
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Op<Glue<T1,T2,glue_type>, op_scalar_plus>
// operator+
// (const Glue<T1,T2,glue_type>& X, const typename T1::elem_type k)
// {
// arma_extra_debug_sigprint();
//
// return Op<Glue<T1,T2,glue_type>, op_scalar_plus>(X,k);
// }
//
//
// //! scalar + mat
// template<typename mT>
// arma_inline
// const Op<Mat<mT>, op_scalar_plus>
// operator+
// (const mT k, const Mat<mT>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<Mat<mT>, op_scalar_plus>(X,k); // NOTE: order is swapped
// }
//
//
//
// //! scalar + op
// template<typename T1, typename op_type>
// arma_inline
// const Op<Op<T1,op_type>, op_scalar_plus>
// operator+
// (const typename T1::elem_type k, const Op<T1,op_type>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<Op<T1,op_type>, op_scalar_plus>(X,k); // NOTE: order is swa
pped
// }
//
//
//
// //! scalar + glue
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Op<Glue<T1,T2,glue_type>, op_scalar_plus>
// operator+
// (const typename T1::elem_type k, const Glue<T1,T2,glue_type>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<Glue<T1,T2,glue_type>, op_scalar_plus>(X,k); // NOTE: order
is swapped
// }
//
//
// //! mat + mat
// template<typename mT>
// arma_inline
// const Glue<Mat<mT>, Mat<mT>, glue_plus>
// operator+
// (const Mat<mT>& X, const Mat<mT>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<mT>, Mat<mT>, glue_plus>(X,Y);
// }
//
//
//
// //! mat + diagmat(T1)
// template<typename T1>
// arma_inline
// const Glue<Mat<typename T1::elem_type>, Op<T1,op_diagmat>, glue_plus_dia
g>
// operator+
// (const Mat<typename T1::elem_type>& X, const Op<T1,op_diagmat>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<typename T1::elem_type>, Op<T1,op_diagmat>, glue_plus_
diag>(X,Y);
// }
//
//
//
// //! diagmat(T1) + mat
// template<typename T1>
// arma_inline
// const Glue<Op<T1,op_diagmat>, Mat<typename T1::elem_type>, glue_plus_dia
g>
// operator+
// (const Op<T1,op_diagmat>& X, const Mat<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_diagmat>, Mat<typename T1::elem_type>, glue_plus_
diag>(X,Y);
// }
//
//
//
// //! diagmat(T1) + diagmat(T2)
// template<typename T1, typename T2>
// arma_inline
// const Glue< Op<T1,op_diagmat>, Op<T2,op_diagmat>, glue_plus_diag>
// operator+
// (const Op<T1,op_diagmat>& X, const Op<T2,op_diagmat>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue< Op<T1,op_diagmat>, Op<T2,op_diagmat>, glue_plus_diag>(X,Y
);
// }
//
//
//
// //! mat + op
// template<typename T1, typename op_type>
// arma_inline
// const Glue<Mat<typename T1::elem_type>, Op<T1,op_type>, glue_plus>
// operator+
// (const Mat<typename T1::elem_type>& X, const Op<T1,op_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<typename T1::elem_type>, Op<T1,op_type>, glue_plus>(X,
Y);
// }
//
//
//
// //! diagmat(T1) + op
// template<typename T1, typename T2, typename op_type>
// arma_inline
// const Glue< Op<T1,op_diagmat>, Op<T2,op_type>, glue_plus_diag>
// operator+
// (const Op<T1,op_diagmat>& X, const Op<T2,op_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue< Op<T1,op_diagmat>, Op<T2,op_type>, glue_plus_diag>(X,Y);
// }
//
//
// //! op + mat
// template<typename T1, typename op_type>
// arma_inline
// const Glue<Op<T1,op_type>, Mat<typename T1::elem_type>, glue_plus>
// operator+
// (const Op<T1,op_type>& X, const Mat<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type>, Mat<typename T1::elem_type>, glue_plus>(X,
Y);
// }
//
//
//
// //! op + diagmat(T2)
// template<typename T1, typename op_type, typename T2>
// arma_inline
// const Glue<Op<T1,op_type>, Op<T2,op_diagmat>, glue_plus_diag>
// operator+
// (const Op<T1,op_type>& X, const Op<T2,op_diagmat>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type>, Op<T2,op_diagmat>, glue_plus_diag>(X,Y);
// }
//
//
//
// //! op + glue
// template<typename T1, typename op_type, typename T2, typename T3, typena
me glue_type>
// arma_inline
// const Glue<Op<T1,op_type>, Glue<T2, T3, glue_type>, glue_plus>
// operator+
// (const Op<T1,op_type>& X, const Glue<T2, T3, glue_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type>, Glue<T2, T3, glue_type>, glue_plus>(X,Y);
// }
//
//
//
// //! glue + op
// template<typename T1, typename op_type, typename T2, typename T3, typena
me glue_type>
// arma_inline
// const Glue<Glue<T2, T3, glue_type>, Op<T1,op_type>, glue_plus>
// operator+
// (const Glue<T2, T3, glue_type>& X, const Op<T1,op_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Glue<T2, T3, glue_type>, Op<T1,op_type>, glue_plus>(X,Y);
// }
//
//
//
// //! mat + glue
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Glue<Mat<typename T1::elem_type>, Glue<T1, T2,glue_type>, glue_plu
s>
// operator+
// (const Mat<typename T1::elem_type>& X, const Glue<T1, T2,glue_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<typename T1::elem_type>, Glue<T1, T2,glue_type>, glue_
plus>(X,Y);
// }
//
//
//
// //! diagmat(T1) + glue
// template<typename T1, typename T2, typename T3, typename glue_type>
// arma_inline
// const Glue< Op<T1,op_diagmat>, Glue<T2,T3,glue_type>, glue_plus_diag>
// operator+
// (const Op<T1,op_diagmat>& X, const Glue<T2,T3,glue_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue< Op<T1,op_diagmat>, Glue<T2,T3,glue_type>, glue_plus_diag>
(X,Y);
// }
//
//
//
// //! glue + mat
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Glue<Glue<T1, T2,glue_type>, Mat<typename T1::elem_type>, glue_plu
s>
// operator+
// (const Glue<T1, T2,glue_type>& X, const Mat<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Glue<T1, T2,glue_type>, Mat<typename T1::elem_type>, glue_
plus>(X,Y);
// }
//
//
//
// //! glue + diagmat(T3)
// template<typename T1, typename T2, typename glue_type, typename T3>
// arma_inline
// const Glue< Glue<T1,T2,glue_type>, Op<T3,op_diagmat>, glue_plus_diag>
// operator+
// (const Glue<T1, T2,glue_type>& X, const Op<T3,op_diagmat>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue< Glue<T1,T2,glue_type>, Op<T3,op_diagmat>, glue_plus_diag>
(X,Y);
// }
//
//
//
// //! op + op
// template<typename T1, typename op_type1, typename T2, typename op_type2>
// arma_inline
// const Glue<Op<T1,op_type1>, Op<T2,op_type2>, glue_plus>
// operator+
// (const Op<T1,op_type1>& X, const Op<T2,op_type2>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type1>, Op<T2,op_type2>, glue_plus>(X,Y);
// }
//
//
//
// //! glue + glue
// template<typename T1, typename T2, typename glue_type1, typename T3, typ
ename T4, typename glue_type2>
// arma_inline
// const Glue<Glue<T1,T2,glue_type1>, Glue<T3,T4,glue_type2>, glue_plus>
// operator+
// (const Glue<T1,T2,glue_type1>& X, const Glue<T3,T4,glue_type2>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Glue<T1,T2,glue_type1>, Glue<T3,T4,glue_type2>, glue_plus>
(X,Y);
// }
//
//
//
// //! Base + subview
// template<typename T1>
// arma_inline
// const Glue<T1, subview<typename T1::elem_type>, glue_plus>
// operator+
// (const Base<T1>& X, const subview<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<T1, subview<typename T1::elem_type>, glue_plus>(X.get_ref(
),Y);
// }
//
//
//
// //! subview + Base
// template<typename T1>
// arma_inline
// const Glue<subview<typename T1::elem_type>, T1, glue_plus>
// operator+
// (const subview<typename T1::elem_type>& X, const Base<T1>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<subview<typename T1::elem_type>, T1, glue_plus>(X,Y.get_re
f());
// }
//
//
//
// //! Base + diagview
// template<typename T1>
// arma_inline
// const Glue<T1, diagview<typename T1::elem_type>, glue_plus>
// operator+
// (const Base<T1>& X, const diagview<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<T1, diagview<typename T1::elem_type>, glue_plus>(X.get_ref
(),Y);
// }
//
//
//
// //! diagview + Base
// template<typename T1>
// arma_inline
// const Glue<diagview<typename T1::elem_type>, T1, glue_plus>
// operator+
// (const diagview<typename T1::elem_type>& X, const T1& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<diagview<typename T1::elem_type>, T1, glue_plus>(X,Y.get_r
ef());
// }
//
//
//
// //! scalar + subview
// template<typename mT>
// arma_inline
// const Op<subview<mT>, op_scalar_plus>
// operator+
// (const mT k, const subview<mT>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<subview<mT>, op_scalar_plus>(X,k);
// }
//
//
//
// //! scalar + diagview
// template<typename mT>
// arma_inline
// const Op<diagview<mT>, op_scalar_plus>
// operator+
// (const mT k, const diagview<mT>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<diagview<mT>, op_scalar_plus>(X,k);
// }
//
//
//
// //! subview + scalar
// template<typename mT>
// arma_inline
// const Op<subview<mT>, op_scalar_plus>
// operator+
// (const subview<mT>& X, const mT k)
// {
// arma_extra_debug_sigprint();
//
// return Op<subview<mT>, op_scalar_plus>(X,k);
// }
//
//
//
// //! diagview + scalar
// template<typename mT>
// arma_inline
// const Op<diagview<mT>, op_scalar_plus>
// operator+
// (const diagview<mT>& X, const mT k)
// {
// arma_extra_debug_sigprint();
//
// return Op<diagview<mT>, op_scalar_plus>(X,k);
// }
//! @} //! @}
 End of changes. 2 change blocks. 
498 lines changed or deleted 38 lines changed or added


 operator_schur.hpp   operator_schur.hpp 
skipping to change at line 56 skipping to change at line 56
arma_inline arma_inline
const Glue< Op<T1,op_diagmat>, T2, glue_schur_diag> const Glue< Op<T1,op_diagmat>, T2, glue_schur_diag>
operator% operator%
(const Op<T1,op_diagmat>& X, const Base<typename T1::elem_type,T2>& Y) (const Op<T1,op_diagmat>& X, const Base<typename T1::elem_type,T2>& Y)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
return Glue< Op<T1,op_diagmat>, T2, glue_schur_diag>(X, Y.get_ref()); return Glue< Op<T1,op_diagmat>, T2, glue_schur_diag>(X, Y.get_ref());
} }
//! diagmat % diagmat
template<typename T1, typename T2>
inline
Mat< typename promote_type<typename T1::elem_type, typename T2::elem_type>:
:result >
operator%
(const Op<T1, op_diagmat>& X, const Op<T2, op_diagmat>& Y)
{
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 unwrap<T1> tmp1(X.m);
const unwrap<T2> tmp2(Y.m);
const Mat<eT1> A(tmp1.M);
const Mat<eT2> B(tmp2.M);
arma_debug_assert_same_size(A.n_rows, A.n_cols, B.n_rows, B.n_cols, "elem
ent-wise matrix multiplication");
Mat<out_eT> out(A.n_rows, A.n_rows);
out.zeros();
for(u32 i=0; i<A.n_rows; ++i)
{
out.at(i,i) = upgrade_val<eT1,eT2>::apply( A.at(i,i) ) * upgrade_val<eT
1,eT2>::apply( B.at(i,i) );
}
return out;
}
// //
// schur product of Base objects with different element types // schur product of Base objects with different element types
// //
//! Base % Base //! Base % Base
template<typename eT1, typename T1, typename eT2, typename T2> template<typename eT1, typename T1, typename eT2, typename T2>
arma_inline arma_inline
Mat<typename promote_type<eT1,eT2>::result> Mat<typename promote_type<eT1,eT2>::result>
operator% operator%
(const Base<eT1,T1>& X, const Base<eT2,T2>& Y) (const Base<eT1,T1>& X, const Base<eT2,T2>& Y)
skipping to change at line 197 skipping to change at line 232
arma_inline arma_inline
const Glue<T1, T2, glue_schur> const Glue<T1, T2, glue_schur>
operator% operator%
(const Base<u8,T1>& X, const Base<u8,T2>& Y) (const Base<u8,T1>& X, const Base<u8,T2>& Y)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
return Glue<T1, T2, glue_schur>(X.get_ref(), Y.get_ref()); return Glue<T1, T2, glue_schur>(X.get_ref(), Y.get_ref());
} }
//
// old operators
//
// //! mat % mat
// template<typename mT>
// arma_inline
// const Glue<Mat<mT>, Mat<mT>, glue_schur>
// operator%
// (const Mat<mT>& X, const Mat<mT>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<mT>, Mat<mT>, glue_schur>(X,Y);
// }
//
//
//
// //! mat % diagmat(T1)
// template<typename T1>
// arma_inline
// const Glue<Mat<typename T1::elem_type>, Op<T1,op_diagmat>, glue_schur_di
ag>
// operator%
// (const Mat<typename T1::elem_type>& X, const Op<T1,op_diagmat>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<typename T1::elem_type>, Op<T1,op_diagmat>, glue_schur
_diag>(X,Y);
// }
//
//
//
// //! diagmat(T1) % mat
// template<typename mT, typename T1>
// arma_inline
// const Glue< Op<T1,op_diagmat>, Mat<typename T1::elem_type>, glue_schur_d
iag>
// operator%
// (const Op<T1,op_diagmat>& X, const Mat<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue< Op<T1,op_diagmat>, Mat<typename T1::elem_type>, glue_schu
r_diag>(X,Y);
// }
//
//
//
// //! diagmat(T1) % diagmat(T2)
// template<typename T1, typename T2>
// arma_inline
// const Glue< Op<T1,op_diagmat>, Op<T2,op_diagmat>, glue_schur_diag>
// operator%
// (const Op<T1,op_diagmat>& X, const Op<T2,op_diagmat>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue< Op<T1,op_diagmat>, Op<T2,op_diagmat>, glue_schur_diag>(X,
Y);
// }
//
//
//
// //! mat % op
// template<typename T1, typename op_type>
// arma_inline
// const Glue<Mat<typename T1::elem_type>, Op<T1,op_type>, glue_schur>
// operator%
// (const Mat<typename T1::elem_type>& X, const Op<T1,op_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<typename T1::elem_type>, Op<T1,op_type>, glue_schur>(X
,Y);
// }
//
//
//
// //! op % mat
// template<typename T1, typename op_type>
// arma_inline
// const Glue<Op<T1,op_type>, Mat<typename T1::elem_type>, glue_schur>
// operator%
// (const Op<T1,op_type>& X, const Mat<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type>, Mat<typename T1::elem_type>, glue_schur>(X
,Y);
// }
//
//
//
// //! op % diagmat(T2)
// template<typename T1, typename op_type, typename T2>
// arma_inline
// const Glue<Op<T1,op_type>, Op<T2,op_diagmat>, glue_schur_diag>
// operator%
// (const Op<T1,op_type>& X, const Op<T2,op_diagmat>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type>, Op<T2,op_diagmat>, glue_schur_diag>(X,Y);
// }
//
//
//
// //! op % glue
// template<typename T1, typename op_type, typename T2, typename T3, typena
me glue_type>
// arma_inline
// const Glue<Op<T1,op_type>, Glue<T2, T3, glue_type>, glue_schur>
// operator%
// (const Op<T1,op_type>& X, const Glue<T2, T3, glue_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type>, Glue<T2, T3, glue_type>, glue_schur>(X,Y);
// }
//
//
//
// //! glue % op
// template<typename T1, typename op_type, typename T2, typename T3, typena
me glue_type>
// arma_inline
// const Glue<Glue<T2, T3, glue_type>, Op<T1,op_type>, glue_schur>
// operator%
// (const Glue<T2, T3, glue_type>& X, const Op<T1,op_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Glue<T2, T3, glue_type>, Op<T1,op_type>, glue_schur>(X,Y);
// }
//
//
//
// //! mat % glue
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Glue<Mat<typename T1::elem_type>, Glue<T1,T2,glue_type>, glue_schu
r>
// operator%
// (const Mat<typename T1::elem_type>& X, const Glue<T1,T2,glue_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<typename T1::elem_type>, Glue<T1,T2,glue_type>, glue_s
chur>(X,Y);
// }
//
//
//
// //! diagmat(T1) % glue
// template<typename T1, typename T2, typename T3, typename glue_type>
// arma_inline
// const Glue< Op<T1,op_diagmat>, Glue<T2,T3,glue_type>, glue_schur_diag>
// operator%
// (const Op<T1,op_diagmat>& X, const Glue<T2,T3,glue_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue< Op<T1,op_diagmat>, Glue<T2,T3,glue_type>, glue_schur_diag
>(X,Y);
// }
//
//
//
// //! glue % mat
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Glue<Glue<T1, T2,glue_type>, Mat<typename T1::elem_type>, glue_sch
ur>
// operator%
// (const Glue<T1,T2,glue_type>& X, const Mat<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Glue<T1,T2,glue_type>, Mat<typename T1::elem_type>, glue_s
chur>(X,Y);
// }
//
//
//
// //! glue % diagmat(T3)
// template<typename T1, typename T2, typename glue_type, typename T3>
// arma_inline
// const Glue<Glue<T1, T2,glue_type>, Op<T3,op_diagmat>, glue_schur_diag>
// operator%
// (const Glue<T1,T2,glue_type>& X, const Op<T3,op_diagmat>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Glue<T1,T2,glue_type>, Op<T3,op_diagmat>, glue_schur_diag>
(X,Y);
// }
//
//
//
// //! op % op
// template<typename T1, typename op_type1, typename T2, typename op_type2>
// arma_inline
// const Glue<Op<T1,op_type1>, Op<T2,op_type2>, glue_schur>
// operator%
// (const Op<T1,op_type1>& X, const Op<T2,op_type2>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type1>, Op<T2,op_type2>, glue_schur>(X,Y);
// }
//
//
// //! glue % glue
// template<typename T1, typename T2, typename glue_type1, typename T3, typ
ename T4, typename glue_type2>
// arma_inline
// const Glue<Glue<T1,T2,glue_type1>, Glue<T3,T4,glue_type2>, glue_schur>
// operator%
// (const Glue<T1,T2,glue_type1>& X, const Glue<T3,T4,glue_type2>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Glue<T1,T2,glue_type1>, Glue<T3,T4,glue_type2>, glue_schur
>(X,Y);
// }
//
//
//
// //! Base % subview
// template<typename T1>
// arma_inline
// const Glue<T1, subview<typename T1::elem_type>, glue_schur>
// operator%
// (const Base<T1>& X, const subview<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<T1, subview<typename T1::elem_type>, glue_schur>(X.get_ref
(),Y);
// }
//
//
//
// //! subview % Base
// template<typename T1>
// arma_inline
// const Glue<subview<typename T1::elem_type>, T1, glue_schur>
// operator%
// (const subview<typename T1::elem_type>& X, const Base<T1>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<subview<typename T1::elem_type>, T1, glue_schur>(X,Y.get_r
ef());
// }
//
//
//
// //! Base % diagview
// template<typename T1>
// arma_inline
// const Glue<T1, diagview<typename T1::elem_type>, glue_schur>
// operator%
// (const Base<T1>& X, const diagview<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<T1, diagview<typename T1::elem_type>, glue_schur>(X.get_re
f(),Y);
// }
//
//
//
// //! diagview % Base
// template<typename T1>
// arma_inline
// const Glue<diagview<typename T1::elem_type>, T1, glue_schur>
// operator%
// (const diagview<typename T1::elem_type>& X, const Base<T1>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<diagview<typename T1::elem_type>, T1, glue_schur>(X,Y.get_
ref());
// }
//! @} //! @}
 End of changes. 2 change blocks. 
288 lines changed or deleted 38 lines changed or added


 operator_times.hpp   operator_times.hpp 
skipping to change at line 152 skipping to change at line 152
arma_inline arma_inline
const Glue<Op<T1,op_diagmat>, T2, glue_times_diag> const Glue<Op<T1,op_diagmat>, T2, glue_times_diag>
operator* operator*
(const Op<T1,op_diagmat>& X, const Base<typename T1::elem_type, T2>& Y) (const Op<T1,op_diagmat>& X, const Base<typename T1::elem_type, T2>& Y)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
return Glue<Op<T1,op_diagmat>, T2, glue_times_diag>(X, Y.get_ref()); return Glue<Op<T1,op_diagmat>, T2, glue_times_diag>(X, Y.get_ref());
} }
//! diagmat * diagmat
template<typename T1, typename T2>
inline
Mat< typename promote_type<typename T1::elem_type, typename T2::elem_type>:
:result >
operator*
(const Op<T1, op_diagmat>& X, const Op<T2, op_diagmat>& Y)
{
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 unwrap<T1> tmp1(X.m);
const unwrap<T2> tmp2(Y.m);
const Mat<eT1> A(tmp1.M);
const Mat<eT2> B(tmp2.M);
arma_debug_assert_same_size(A.n_rows, A.n_cols, B.n_rows, B.n_cols, "matr
ix multiplication");
Mat<out_eT> out(A.n_rows, A.n_rows);
out.zeros();
for(u32 i=0; i<A.n_rows; ++i)
{
out.at(i,i) = upgrade_val<eT1,eT2>::apply( A.at(i,i) ) * upgrade_val<eT
1,eT2>::apply( B.at(i,i) );
}
return out;
}
//! colvec * rowvec //! colvec * rowvec
template<typename eT> template<typename eT>
arma_inline arma_inline
const Glue<Col<eT>, Row<eT>, glue_times_vec> const Glue<Col<eT>, Row<eT>, glue_times_vec>
operator* operator*
(const Col<eT>& X, const Row<eT>& Y) (const Col<eT>& X, const Row<eT>& Y)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
return Glue<Col<eT>, Row<eT>, glue_times_vec>(X, Y); return Glue<Col<eT>, Row<eT>, glue_times_vec>(X, Y);
skipping to change at line 402 skipping to change at line 437
arma_inline arma_inline
const Glue<T1, T2, glue_times> const Glue<T1, T2, glue_times>
operator* operator*
(const Base<u8,T1>& X, const Base<u8,T2>& Y) (const Base<u8,T1>& X, const Base<u8,T2>& Y)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
return Glue<T1, T2, glue_times>(X.get_ref(), Y.get_ref()); return Glue<T1, T2, glue_times>(X.get_ref(), Y.get_ref());
} }
//
// old operators
//
// //! mat * scalar
// template<typename mT>
// arma_inline
// const Op<Mat<mT>, op_scalar_times>
// operator*
// (const Mat<mT>& X, const mT k)
// {
// arma_extra_debug_sigprint();
//
// return Op<Mat<mT>, op_scalar_times>(X,k);
// }
//
//
//
// //! op * scalar
// template<typename T1, typename op_type>
// arma_inline
// const Op< Op<T1,op_type>, op_scalar_times>
// operator*
// (const Op<T1,op_type>& X, const typename T1::elem_type k)
// {
// arma_extra_debug_sigprint();
//
// return Op< Op<T1,op_type>, op_scalar_times>(X,k);
// }
//
//
//
// //! op * scalar, level 2
// template<typename T1>
// arma_inline
// const Op<T1,op_scalar_times>
// operator*
// (const Op<T1,op_scalar_times>& X, const typename T1::elem_type k)
// {
// arma_extra_debug_sigprint();
//
// return Op<T1, op_scalar_times>(X.m, X.aux * k);
// }
//
//
//
// //! glue * scalar
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Op<Glue<T1,T2,glue_type>, op_scalar_times>
// operator*
// (const Glue<T1,T2,glue_type>& X, const typename T1::elem_type k)
// {
// arma_extra_debug_sigprint();
//
// return Op<Glue<T1,T2,glue_type>, op_scalar_times>(X,k);
// }
//
//
//
// //! Op<mat,op_ones_full> * scalar
// template<typename mT>
// arma_inline
// Mat<mT>
// operator*
// (const Op<Mat<mT>,op_ones_full>& X, const mT k)
// {
// arma_extra_debug_sigprint();
//
// Mat<mT> tmp(X.aux_u32_a, X.aux_u32_b);
// tmp.fill(k);
//
// return tmp;
// }
//
//
//
// //! Op<mat,op_ones_diag> * scalar
// template<typename mT>
// arma_inline
// Mat<mT>
// operator*
// (const Op<Mat<mT>,op_ones_diag>& X, const mT k)
// {
// arma_extra_debug_sigprint();
//
// Mat<mT> out;
// out.zeros(X.aux_u32_a, X.aux_u32_b);
//
// for(u32 i=0; i<out.n_rows; ++i)
// {
// out.at(i,i) = k;
// }
//
// return out;
// }
//
//
//
// //! scalar * mat
// template<typename mT>
// arma_inline
// const Op<Mat<mT>, op_scalar_times>
// operator*
// (const mT k, const Mat<mT>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<Mat<mT>, op_scalar_times>(X,k); // NOTE: order is swapped
// }
//
//
//
// //! scalar * op
// template<typename T1, typename op_type>
// arma_inline
// const Op<Op<T1,op_type>, op_scalar_times>
// operator*
// (const typename T1::elem_type k, const Op<T1,op_type>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<Op<T1,op_type>, op_scalar_times>(X,k); // NOTE: order is sw
apped
// }
//
//
//
// //! scalar * glue
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Op<Glue<T1,T2,glue_type>, op_scalar_times>
// operator*
// (const typename T1::elem_type k, const Glue<T1,T2,glue_type>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<Glue<T1,T2,glue_type>, op_scalar_times>(X,k); // NOTE: orde
r is swapped
// }
//
//
//
// //! scalar * Op<mat,op_ones_full>
// template<typename mT>
// arma_inline
// Mat<mT>
// operator*
// (const mT k, const Op<Mat<mT>,op_ones_full>& X)
// {
// arma_extra_debug_sigprint();
//
// Mat<mT> tmp(X.aux_u32_a, X.aux_u32_b);
// tmp.fill(k);
//
// return tmp;
// }
//
//
//
// //! scalar * Op<mat,op_ones_diag>
// template<typename mT>
// arma_inline
// Mat<mT>
// operator*
// (const mT k, const Op<Mat<mT>,op_ones_diag>& X)
// {
// arma_extra_debug_sigprint();
//
// Mat<mT> out;
// out.zeros(X.aux_u32_a, X.aux_u32_b);
//
// for(u32 i=0; i<out.n_rows; ++i)
// out.at(i,i) = k;
//
// return out;
// }
//
//
//
// //! mat * mat
// template<typename mT>
// arma_inline
// const Glue<Mat<mT>, Mat<mT>, glue_times>
// operator*
// (const Mat<mT>& X, const Mat<mT>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<mT>, Mat<mT>, glue_times>(X,Y);
// }
//
//
//
// //! mat * diagmat(T1)
// template<typename T1>
// arma_inline
// const Glue<Mat<typename T1::elem_type>, Op<T1,op_diagmat>, glue_times_di
ag>
// operator*
// (const Mat<typename T1::elem_type>& X, const Op<T1,op_diagmat>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<typename T1::elem_type>, Op<T1,op_diagmat>, glue_times
_diag>(X,Y);
// }
//
//
//
// //! diagmat(T1) * mat
// template<typename T1>
// arma_inline
// const Glue<Op<T1,op_diagmat>, Mat<typename T1::elem_type>, glue_times_di
ag>
// operator*
// (const Op<T1,op_diagmat>& X, const Mat<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_diagmat>, Mat<typename T1::elem_type>, glue_times
_diag>(X,Y);
// }
//
//
//
// //! diagmat(T1) * diagmat(T2)
// template<typename T1, typename T2>
// arma_inline
// const Glue< Op<T1,op_diagmat>, Op<T2,op_diagmat>, glue_times_diag>
// operator*
// (const Op<T1,op_diagmat>& X, const Op<T2,op_diagmat>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue< Op<T1,op_diagmat>, Op<T2,op_diagmat>, glue_times_diag>(X,
Y);
// }
//
//
//
// //! mat * colvec
// template<typename mT>
// arma_inline
// const Glue<Mat<mT>, Col<mT>, glue_times>
// operator*
// (const Mat<mT>& X, const Col<mT>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<mT>, Col<mT>, glue_times>(X,Y);
// }
//
//
//
// //! mat * rowvec
// template<typename mT>
// arma_inline
// const Glue<Mat<mT>, Row<mT>, glue_times>
// operator*
// (const Mat<mT>& X, const Row<mT>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<mT>, Row<mT>, glue_times>(X,Y);
// }
//
//
//
// //! mat * op
// template<typename T1, typename op_type>
// arma_inline
// const Glue<Mat<typename T1::elem_type>, Op<T1,op_type>, glue_times>
// operator*
// (const Mat<typename T1::elem_type>& X, const Op<T1,op_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<typename T1::elem_type>, Op<T1,op_type>, glue_times>(X
,Y);
// }
//
//
//
// //! diagmat(T1) * op
// template<typename T1, typename T2, typename op_type>
// arma_inline
// const Glue< Op<T1,op_diagmat>, Op<T2,op_type>, glue_times_diag>
// operator*
// (const Op<T1,op_diagmat>& X, const Op<T2,op_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue< Op<T1,op_diagmat>, Op<T2,op_type>, glue_times_diag>(X,Y);
// }
//
//
//
// //! rowvec * mat
// template<typename mT>
// arma_inline
// const Glue<Row<mT>, Mat<mT>, glue_times>
// operator*
// (const Row<mT>& X, const Mat<mT>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Row<mT>, Mat<mT>, glue_times>(X,Y);
// }
//
//
//
// //! rowvec * op
// template<typename T1, typename op_type>
// arma_inline
// const Glue<Row<typename T1::elem_type>, Op<T1,op_type>, glue_times>
// operator*
// (const Row<typename T1::elem_type>& X, const Op<T1,op_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Row<typename T1::elem_type>, Op<T1,op_type>, glue_times>(X
,Y);
// }
//
//
//
// //! colvec * rowvec
// template<typename mT>
// arma_inline
// const Glue<Col<mT>, Row<mT>, glue_times>
// operator*
// (const Col<mT>& X, const Row<mT>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Col<mT>, Row<mT>, glue_times>(X,Y);
// }
//
//
// //! colvec * op
// template<typename T1, typename op_type>
// arma_inline
// const Glue<Col<typename T1::elem_type>, Op<T1,op_type>, glue_times>
// operator*
// (const Col<typename T1::elem_type>& X, const Op<T1,op_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Col<typename T1::elem_type>, Op<T1,op_type>, glue_times>(X
,Y);
// }
//
//
//
// //! op * mat
// template<typename T1, typename op_type>
// arma_inline
// const Glue<Op<T1,op_type>, Mat<typename T1::elem_type>, glue_times>
// operator*
// (const Op<T1,op_type>& X, const Mat<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type>, Mat<typename T1::elem_type>, glue_times>(X
,Y);
// }
//
//
//
// //! op * diagmat(T2)
// template<typename T1, typename op_type, typename T2>
// arma_inline
// const Glue<Op<T1,op_type>, Op<T2,op_diagmat>, glue_times_diag>
// operator*
// (const Op<T1,op_type>& X, const Op<T2,op_diagmat>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type>, Op<T2,op_diagmat>, glue_times_diag>(X,Y);
// }
//
//
//
// //! op * colvec
// template<typename T1, typename op_type>
// arma_inline
// const Glue<Op<T1,op_type>, Col<typename T1::elem_type>, glue_times>
// operator*
// (const Op<T1,op_type>& X, const Col<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type>, Col<typename T1::elem_type>, glue_times>(X
,Y);
// }
//
//
//
// //! op * rowvec
// template<typename T1, typename op_type>
// arma_inline
// const Glue<Op<T1,op_type>, Row<typename T1::elem_type>, glue_times>
// operator*
// (const Op<T1,op_type>& X, const Row<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type>, Row<typename T1::elem_type>, glue_times>(X
,Y);
// }
//
//
//
// //! op * glue
// template<typename T1, typename op_type, typename T2, typename T3, typena
me glue_type>
// arma_inline
// const Glue<Op<T1,op_type>, Glue<T2, T3, glue_type>, glue_times>
// operator*
// (const Op<T1,op_type>& X, const Glue<T2, T3, glue_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type>, Glue<T2, T3, glue_type>, glue_times>(X,Y);
// }
//
//
//
// //! glue * op
// template<typename T1, typename op_type, typename T2, typename T3, typena
me glue_type>
// arma_inline
// const Glue<Glue<T2, T3, glue_type>, Op<T1,op_type>, glue_times>
// operator*
// (const Glue<T2, T3, glue_type>& X, const Op<T1,op_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Glue<T2, T3, glue_type>, Op<T1,op_type>, glue_times>(X,Y);
// }
//
//
//
// //! glue * mat
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Glue<Glue<T1, T2,glue_type>, Mat<typename T1::elem_type>, glue_tim
es>
// operator*
// (const Glue<T1, T2,glue_type>& X, const Mat<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Glue<T1, T2,glue_type>, Mat<typename T1::elem_type>, glue_
times>(X,Y);
// }
//
//
//
// //! glue * diagmat(T3)
// template<typename T1, typename T2, typename glue_type, typename T3>
// arma_inline
// const Glue<Glue<T1, T2,glue_type>, Op<T3,op_diagmat>, glue_times_diag>
// operator*
// (const Glue<T1, T2,glue_type>& X, const Op<T3,op_diagmat>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Glue<T1, T2,glue_type>, Op<T3,op_diagmat>, glue_times_diag
>(X,Y);
// }
//
//
//
// //! glue * colvec
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Glue<Glue<T1, T2,glue_type>, Col<typename T1::elem_type>, glue_tim
es>
// operator*
// (const Glue<T1, T2,glue_type>& X, const Col<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Glue<T1, T2,glue_type>, Col<typename T1::elem_type>, glue_
times>(X,Y);
// }
//
//
// //! glue * rowvec
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Glue<Glue<T1, T2,glue_type>, Row<typename T1::elem_type>, glue_tim
es>
// operator*
// (const Glue<T1, T2,glue_type>& X, const Row<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Glue<T1, T2,glue_type>, Row<typename T1::elem_type>, glue_
times>(X,Y);
// }
//
//
//
// //! mat * glue
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Glue<Mat<typename T1::elem_type>, Glue<T1, T2,glue_type>, glue_tim
es>
// operator*
// (const Mat<typename T1::elem_type>& X, const Glue<T1, T2,glue_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Mat<typename T1::elem_type>, Glue<T1, T2,glue_type>, glue_
times>(X,Y);
// }
//
//
//
// //! diagmat(T1) * glue
// template<typename T1, typename T2, typename T3, typename glue_type>
// arma_inline
// const Glue<Op<T1,op_diagmat>, Glue<T2,T3,glue_type>, glue_times_diag>
// operator*
// (const Op<T1,op_diagmat>& X, const Glue<T2,T3,glue_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue< Op<T1,op_diagmat>, Glue<T1, T2,glue_type>, glue_times_dia
g>(X,Y);
// }
//
//
//
// //! colvec * glue
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Glue<Col<typename T1::elem_type>, Glue<T1, T2,glue_type>, glue_tim
es>
// operator*
// (const Col<typename T1::elem_type>& X, const Glue<T1, T2,glue_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Col<typename T1::elem_type>, Glue<T1, T2,glue_type>, glue_
times>(X,Y);
// }
//
//
//
// //! rowvec * glue
// template<typename T1, typename T2, typename glue_type>
// arma_inline
// const Glue<Row<typename T1::elem_type>, Glue<T1, T2,glue_type>, glue_tim
es>
// operator*
// (const Row<typename T1::elem_type>& X, const Glue<T1, T2,glue_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Row<typename T1::elem_type>, Glue<T1, T2,glue_type>, glue_
times>(X,Y);
// }
//
//
//
// //! op * op
// template<typename T1, typename op_type1, typename T2, typename op_type2>
// arma_inline
// const Glue<Op<T1,op_type1>, Op<T2,op_type2>, glue_times>
// operator*
// (const Op<T1,op_type1>& X, const Op<T2,op_type2>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Op<T1,op_type1>, Op<T2,op_type2>, glue_times>(X,Y);
// }
//
//
//
// //! glue * glue
// template<typename T1, typename T2, typename glue_type1, typename T3, typ
ename T4, typename glue_type2>
// arma_inline
// const Glue<Glue<T1,T2,glue_type1>, Glue<T3,T4,glue_type2>, glue_times>
// operator*
// (const Glue<T1,T2,glue_type1>& X, const Glue<T3,T4,glue_type2>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<Glue<T1,T2,glue_type1>, Glue<T3,T4,glue_type2>, glue_times
>(X,Y);
// }
//
//
//
// //! Base * subview
// template<typename T1>
// arma_inline
// const Glue<T1, subview<typename T1::elem_type>, glue_times>
// operator*
// (const Base<T1>& X, const subview<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<T1, subview<typename T1::elem_type>, glue_times>(X.get_ref
(),Y);
// }
//
//
//
// //! subview * Base
// template<typename T1>
// arma_inline
// const Glue<subview<typename T1::elem_type>, T1, glue_times>
// operator*
// (const subview<typename T1::elem_type>& X, const Base<T1>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<subview<typename T1::elem_type>, T1, glue_times>(X,Y.get_r
ef());
// }
//
//
//
// //! Base * diagview
// template<typename T1>
// arma_inline
// const Glue<T1, diagview<typename T1::elem_type>, glue_times>
// operator*
// (const Base<T1>& X, const diagview<typename T1::elem_type>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<T1, diagview<typename T1::elem_type>, glue_times>(X.get_re
f(),Y);
// }
//
//
//
// //! diagview * Base
// template<typename T1>
// arma_inline
// const Glue<diagview<typename T1::elem_type>, T1, glue_times>
// operator*
// (const diagview<typename T1::elem_type>& X, const Base<T1>& Y)
// {
// arma_extra_debug_sigprint();
//
// return Glue<diagview<typename T1::elem_type>, T1, glue_times>(X,Y.get_
ref());
// }
//
//
//
// //! scalar * subview
// template<typename mT>
// arma_inline
// const Op<subview<mT>, op_scalar_times>
// operator*
// (const mT k, const subview<mT>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<subview<mT>, op_scalar_times>(X,k);
// }
//
//
//
// //! scalar * diagview
// template<typename mT>
// arma_inline
// const Op<diagview<mT>, op_scalar_times>
// operator*
// (const mT k, const diagview<mT>& X)
// {
// arma_extra_debug_sigprint();
//
// return Op<diagview<mT>, op_scalar_times>(X,k);
// }
//
//
//
// //! subview * scalar
// template<typename mT>
// arma_inline
// const Op<subview<mT>, op_scalar_times>
// operator*
// (const subview<mT>& X, const mT k)
// {
// arma_extra_debug_sigprint();
//
// return Op<subview<mT>, op_scalar_times>(X,k);
// }
//
//
//
// //! diagview * scalar
// template<typename mT>
// arma_inline
// const Op<diagview<mT>, op_scalar_times>
// operator*
// (const diagview<mT>& X, const mT k)
// {
// arma_extra_debug_sigprint();
//
// return Op<diagview<mT>, op_scalar_times>(X,k);
// }
//
//! @} //! @}
 End of changes. 2 change blocks. 
714 lines changed or deleted 38 lines changed or added


 subview_cube_meat.hpp   subview_cube_meat.hpp 
skipping to change at line 447 skipping to change at line 447
{ {
delete tmp_subview_cube; delete tmp_subview_cube;
delete tmp_cube; delete tmp_cube;
} }
} }
template<typename eT> template<typename eT>
inline inline
void void
subview_cube<eT>::operator%= (const subview_cube& x_in) subview_cube<eT>::operator%= (const subview_cube<eT>&amp; x_in)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
const bool overlap = check_overlap(x_in); const bool overlap = check_overlap(x_in);
Cube<eT>* tmp_cube = overlap ? new Cube<eT>(x_in.m) : 0; Cube<eT>* tmp_cube = overlap ? new Cube<eT>(x_in.m) : 0;
const subview_cube<eT>* tmp_subview_cube = overlap ? new subview_cube<eT> (*tmp_cube, x_in.aux_row1, x_in.aux_col1, x_in.aux_slice1, x_in.aux_row2, x _in.aux_col2, x_in.aux_slice2) : 0; const subview_cube<eT>* tmp_subview_cube = overlap ? new subview_cube<eT> (*tmp_cube, x_in.aux_row1, x_in.aux_col1, x_in.aux_slice1, x_in.aux_row2, x _in.aux_col2, x_in.aux_slice2) : 0;
const subview_cube<eT>& x = overlap ? (*tmp_subview_cube) : x_in; const subview_cube<eT>& x = overlap ? (*tmp_subview_cube) : x_in;
subview_cube<eT>& t = *this; subview_cube<eT>& t = *this;
skipping to change at line 486 skipping to change at line 486
{ {
delete tmp_subview_cube; delete tmp_subview_cube;
delete tmp_cube; delete tmp_cube;
} }
} }
template<typename eT> template<typename eT>
inline inline
void void
subview_cube<eT>::operator/= (const subview_cube& x_in) subview_cube<eT>::operator/= (const subview_cube<eT>&amp; x_in)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
const bool overlap = check_overlap(x_in); const bool overlap = check_overlap(x_in);
Cube<eT>* tmp_cube = overlap ? new Cube<eT>(x_in.m) : 0; Cube<eT>* tmp_cube = overlap ? new Cube<eT>(x_in.m) : 0;
const subview_cube<eT>* tmp_subview_cube = overlap ? new subview_cube<eT> (*tmp_cube, x_in.aux_row1, x_in.aux_col1, x_in.aux_slice1, x_in.aux_row2, x _in.aux_col2, x_in.aux_slice2) : 0; const subview_cube<eT>* tmp_subview_cube = overlap ? new subview_cube<eT> (*tmp_cube, x_in.aux_row1, x_in.aux_col1, x_in.aux_slice1, x_in.aux_row2, x _in.aux_col2, x_in.aux_slice2) : 0;
const subview_cube<eT>& x = overlap ? (*tmp_subview_cube) : x_in; const subview_cube<eT>& x = overlap ? (*tmp_subview_cube) : x_in;
subview_cube<eT>& t = *this; subview_cube<eT>& t = *this;
 End of changes. 2 change blocks. 
2 lines changed or deleted 2 lines changed or added


 subview_meat.hpp   subview_meat.hpp 
skipping to change at line 404 skipping to change at line 404
{ {
delete tmp_subview; delete tmp_subview;
delete tmp_mat; delete tmp_mat;
} }
} }
template<typename eT> template<typename eT>
inline inline
void void
subview<eT>::operator%= (const subview& x_in) subview<eT>::operator%= (const subview<eT>&amp; x_in)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
const bool overlap = check_overlap(x_in); const bool overlap = check_overlap(x_in);
Mat<eT>* tmp_mat = overlap ? new Mat<eT>(x_in.m) : 0; Mat<eT>* tmp_mat = overlap ? new Mat<eT>(x_in.m) : 0;
const subview<eT>* tmp_subview = overlap ? new subview(*tmp_mat, x_in.aux _row1, x_in.aux_col1, x_in.aux_row2, x_in.aux_col2) : 0; const subview<eT>* tmp_subview = overlap ? new subview(*tmp_mat, x_in.aux _row1, x_in.aux_col1, x_in.aux_row2, x_in.aux_col2) : 0;
const subview<eT>& x = overlap ? (*tmp_subview) : x_in; const subview<eT>& x = overlap ? (*tmp_subview) : x_in;
subview<eT>& t = *this; subview<eT>& t = *this;
skipping to change at line 440 skipping to change at line 440
{ {
delete tmp_subview; delete tmp_subview;
delete tmp_mat; delete tmp_mat;
} }
} }
template<typename eT> template<typename eT>
inline inline
void void
subview<eT>::operator/= (const subview& x_in) subview<eT>::operator/= (const subview<eT>&amp; x_in)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
const bool overlap = check_overlap(x_in); const bool overlap = check_overlap(x_in);
Mat<eT>* tmp_mat = overlap ? new Mat<eT>(x_in.m) : 0; Mat<eT>* tmp_mat = overlap ? new Mat<eT>(x_in.m) : 0;
const subview<eT>* tmp_subview = overlap ? new subview(*tmp_mat, x_in.aux _row1, x_in.aux_col1, x_in.aux_row2, x_in.aux_col2) : 0; const subview<eT>* tmp_subview = overlap ? new subview(*tmp_mat, x_in.aux _row1, x_in.aux_col1, x_in.aux_row2, x_in.aux_col2) : 0;
const subview<eT>& x = overlap ? (*tmp_subview) : x_in; const subview<eT>& x = overlap ? (*tmp_subview) : x_in;
subview<eT>& t = *this; subview<eT>& t = *this;
 End of changes. 2 change blocks. 
2 lines changed or deleted 2 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/