Base_bones.hpp   Base_bones.hpp 
skipping to change at line 36 skipping to change at line 36
template<typename derived, bool condition> template<typename derived, bool condition>
struct Base_extra {}; struct Base_extra {};
template<typename derived> template<typename derived>
struct Base_extra<derived, true> { typedef Base_blas_elem_type<derived> r esult; }; struct Base_extra<derived, true> { typedef Base_blas_elem_type<derived> r esult; };
template<typename derived> template<typename derived>
struct Base_extra<derived, false> { typedef Base_other_elem_type<derived> r esult; }; struct Base_extra<derived, false> { typedef Base_other_elem_type<derived> r esult; };
template<typename elem_type, typename derived>
struct Base_eval_Mat
{
const derived& eval() const;
};
template<typename elem_type, typename derived>
struct Base_eval_expr
{
Mat<elem_type> eval() const;
};
template<typename elem_type, typename derived, bool condition>
struct Base_eval {};
template<typename elem_type, typename derived>
struct Base_eval<elem_type, derived, true> { typedef Base_eval_Mat<elem_ty
pe, derived> result; };
template<typename elem_type, typename derived>
struct Base_eval<elem_type, derived, false> { typedef Base_eval_expr<elem_t
ype, derived> result; };
//! Class for static polymorphism, modelled after the "Curiously Recurring Template Pattern" (CRTP). //! Class for static polymorphism, modelled after the "Curiously Recurring Template Pattern" (CRTP).
//! Used for type-safe downcasting in functions that restrict their input(s ) to be classes that are //! Used for type-safe downcasting in functions that restrict their input(s ) to be classes that are
//! derived from Base (e.g. Mat, Op, Glue, diagview, subview). //! derived from Base (e.g. Mat, Op, Glue, diagview, subview).
//! A Base object can be converted to a Mat object by the unwrap class. //! A Base object can be converted to a Mat object by the unwrap class.
template<typename elem_type, typename derived> template<typename elem_type, typename derived>
struct Base : public Base_extra<derived, is_supported_blas_type<elem_type>: struct Base
:value>::result : public Base_extra<derived, is_supported_blas_type<elem_type>::value>::r
esult
, public Base_eval<elem_type, derived, is_Mat<derived>::value>::result
{ {
arma_inline const derived& get_ref() const; arma_inline const derived& get_ref() const;
arma_inline const Op<derived,op_htrans> t() const; //!< Hermitian trans pose arma_inline const Op<derived,op_htrans> t() const; //!< Hermitian trans pose
arma_inline const Op<derived,op_htrans> ht() const; //!< Hermitian trans pose arma_inline const Op<derived,op_htrans> ht() const; //!< Hermitian trans pose
arma_inline const Op<derived,op_strans> st() const; //!< simple transpos e arma_inline const Op<derived,op_strans> st() const; //!< simple transpos e
inline void print(const std::string extra_text = "") const; inline void print(const std::string extra_text = "") const;
inline void print(std::ostream& user_stream, const std::string extra_text = "") const; inline void print(std::ostream& user_stream, const std::string extra_text = "") const;
 End of changes. 2 change blocks. 
2 lines changed or deleted 27 lines changed or added


 Base_meat.hpp   Base_meat.hpp 
skipping to change at line 53 skipping to change at line 53
Base<elem_type,derived>::st() const Base<elem_type,derived>::st() const
{ {
return Op<derived,op_strans>( (*this).get_ref() ); return Op<derived,op_strans>( (*this).get_ref() );
} }
template<typename elem_type, typename derived> template<typename elem_type, typename derived>
inline inline
void void
Base<elem_type,derived>::print(const std::string extra_text) const Base<elem_type,derived>::print(const std::string extra_text) const
{ {
const unwrap<derived> tmp( (*this).get_ref() ); const Proxy<derived> P( (*this).get_ref() );
const quasi_unwrap< typename Proxy<derived>::stored_type > tmp(P.Q);
tmp.M.impl_print(extra_text); tmp.M.impl_print(extra_text);
} }
template<typename elem_type, typename derived> template<typename elem_type, typename derived>
inline inline
void void
Base<elem_type,derived>::print(std::ostream& user_stream, const std::string extra_text) const Base<elem_type,derived>::print(std::ostream& user_stream, const std::string extra_text) const
{ {
const unwrap<derived> tmp( (*this).get_ref() ); const Proxy<derived> P( (*this).get_ref() );
const quasi_unwrap< typename Proxy<derived>::stored_type > tmp(P.Q);
tmp.M.impl_print(user_stream, extra_text); tmp.M.impl_print(user_stream, extra_text);
} }
template<typename elem_type, typename derived> template<typename elem_type, typename derived>
inline inline
void void
Base<elem_type,derived>::raw_print(const std::string extra_text) const Base<elem_type,derived>::raw_print(const std::string extra_text) const
{ {
const unwrap<derived> tmp( (*this).get_ref() ); const Proxy<derived> P( (*this).get_ref() );
const quasi_unwrap< typename Proxy<derived>::stored_type > tmp(P.Q);
tmp.M.impl_raw_print(extra_text); tmp.M.impl_raw_print(extra_text);
} }
template<typename elem_type, typename derived> template<typename elem_type, typename derived>
inline inline
void void
Base<elem_type,derived>::raw_print(std::ostream& user_stream, const std::st ring extra_text) const Base<elem_type,derived>::raw_print(std::ostream& user_stream, const std::st ring extra_text) const
{ {
const unwrap<derived> tmp( (*this).get_ref() ); const Proxy<derived> P( (*this).get_ref() );
const quasi_unwrap< typename Proxy<derived>::stored_type > tmp(P.Q);
tmp.M.impl_raw_print(user_stream, extra_text); tmp.M.impl_raw_print(user_stream, extra_text);
} }
// //
// extra functions defined in Base_blas_elem_type // extra functions defined in Base_blas_elem_type
template<typename derived> template<typename derived>
arma_inline arma_inline
const Op<derived,op_inv> const Op<derived,op_inv>
Base_blas_elem_type<derived>::i(const bool slow) const Base_blas_elem_type<derived>::i(const bool slow) const
{ {
return Op<derived,op_inv>( static_cast<const derived&>(*this), ((slow == false) ? 0 : 1), 0 ); return Op<derived,op_inv>( static_cast<const derived&>(*this), ((slow == false) ? 0 : 1), 0 );
} }
//
// extra functions defined in Base_eval_Mat
template<typename elem_type, typename derived>
arma_inline
const derived&
Base_eval_Mat<elem_type, derived>::eval() const
{
arma_extra_debug_sigprint();
return static_cast<const derived&>(*this);
}
//
// extra functions defined in Base_eval_expr
template<typename elem_type, typename derived>
arma_inline
Mat<elem_type>
Base_eval_expr<elem_type, derived>::eval() const
{
arma_extra_debug_sigprint();
return Mat<elem_type>( static_cast<const derived&>(*this) );
}
//! @} //! @}
 End of changes. 5 change blocks. 
4 lines changed or deleted 38 lines changed or added


 Col_bones.hpp   Col_bones.hpp 
skipping to change at line 115 skipping to change at line 115
template<uword fixed_n_elem> template<uword fixed_n_elem>
class fixed : public Col<eT> class fixed : public Col<eT>
{ {
private: private:
static const bool use_extra = (fixed_n_elem > arma_config::mat_prealloc ); static const bool use_extra = (fixed_n_elem > arma_config::mat_prealloc );
arma_aligned eT mem_local_extra[ (use_extra) ? fixed_n_elem : 1 ]; arma_aligned eT mem_local_extra[ (use_extra) ? fixed_n_elem : 1 ];
arma_inline void mem_setup();
arma_inline void change_to_row(); arma_inline void change_to_row();
public: public:
typedef fixed<fixed_n_elem> Col_fixed_type; typedef fixed<fixed_n_elem> Col_fixed_type;
typedef eT elem_type; typedef eT elem_type;
typedef typename get_pod_type<eT>::result pod_type; typedef typename get_pod_type<eT>::result pod_type;
static const bool is_col = true; static const bool is_col = true;
skipping to change at line 178 skipping to change at line 177
arma_inline arma_warn_unused eT operator() (const uword in_row, const uword in_col) const; arma_inline arma_warn_unused eT operator() (const uword in_row, const uword in_col) const;
arma_inline arma_warn_unused eT* memptr(); arma_inline arma_warn_unused eT* memptr();
arma_inline arma_warn_unused const eT* memptr() const; arma_inline arma_warn_unused const eT* memptr() const;
arma_hot inline const Col<eT>& fill(const eT val); arma_hot inline const Col<eT>& fill(const eT val);
arma_hot inline const Col<eT>& zeros(); arma_hot inline const Col<eT>& zeros();
arma_hot inline const Col<eT>& ones(); arma_hot inline const Col<eT>& ones();
}; };
protected:
inline Col(const arma_fixed_indicator&, const uword in_n_elem, const eT*
in_mem);
public:
#ifdef ARMA_EXTRA_COL_PROTO #ifdef ARMA_EXTRA_COL_PROTO
#include ARMA_INCFILE_WRAP(ARMA_EXTRA_COL_PROTO) #include ARMA_INCFILE_WRAP(ARMA_EXTRA_COL_PROTO)
#endif #endif
}; };
//! @} //! @}
 End of changes. 3 change blocks. 
2 lines changed or deleted 7 lines changed or added


 Col_meat.hpp   Col_meat.hpp 
skipping to change at line 643 skipping to change at line 643
arma_debug_check( (row_num >= Mat<eT>::n_rows), "end_row(): index out of bounds"); arma_debug_check( (row_num >= Mat<eT>::n_rows), "end_row(): index out of bounds");
return Mat<eT>::memptr() + row_num + 1; return Mat<eT>::memptr() + row_num + 1;
} }
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
arma_inline arma_inline
void void
Col<eT>::fixed<fixed_n_elem>::mem_setup()
{
arma_extra_debug_sigprint();
access::rw(Mat<eT>::n_rows) = fixed_n_elem;
access::rw(Mat<eT>::n_cols) = 1;
access::rw(Mat<eT>::n_elem) = fixed_n_elem;
access::rw(Mat<eT>::vec_state) = 1;
access::rw(Mat<eT>::mem_state) = 3;
access::rw(Mat<eT>::mem) = (use_extra) ? mem_local_extra : Mat<eT>:
:mem_local;
}
template<typename eT>
template<uword fixed_n_elem>
arma_inline
void
Col<eT>::fixed<fixed_n_elem>::change_to_row() Col<eT>::fixed<fixed_n_elem>::change_to_row()
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
access::rw(Mat<eT>::n_cols) = fixed_n_elem; access::rw(Mat<eT>::n_cols) = fixed_n_elem;
access::rw(Mat<eT>::n_rows) = 1; access::rw(Mat<eT>::n_rows) = 1;
} }
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
arma_inline arma_inline
Col<eT>::fixed<fixed_n_elem>::fixed() Col<eT>::fixed<fixed_n_elem>::fixed()
: Col<eT>( arma_fixed_indicator(), fixed_n_elem, ((use_extra) ? mem_local _extra : Mat<eT>::mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
} }
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
arma_inline arma_inline
Col<eT>::fixed<fixed_n_elem>::fixed(const fixed<fixed_n_elem>& X) Col<eT>::fixed<fixed_n_elem>::fixed(const fixed<fixed_n_elem>& X)
: Col<eT>( arma_fixed_indicator(), fixed_n_elem, ((use_extra) ? mem_local _extra : Mat<eT>::mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
eT* dest = (use_extra) ? mem_local_extra : Mat<eT>::mem_local; eT* dest = (use_extra) ? mem_local_extra : Mat<eT>::mem_local;
arrayops::copy( dest, X.mem, fixed_n_elem ); arrayops::copy( dest, X.mem, fixed_n_elem );
} }
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
inline inline
Col<eT>::fixed<fixed_n_elem>::fixed(const subview_cube<eT>& X) Col<eT>::fixed<fixed_n_elem>::fixed(const subview_cube<eT>& X)
: Col<eT>( arma_fixed_indicator(), fixed_n_elem, ((use_extra) ? mem_local _extra : Mat<eT>::mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
Col<eT>::operator=(X); Col<eT>::operator=(X);
} }
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
template<typename T1> template<typename T1>
inline inline
Col<eT>::fixed<fixed_n_elem>::fixed(const Base<eT,T1>& A) Col<eT>::fixed<fixed_n_elem>::fixed(const Base<eT,T1>& A)
: Col<eT>( arma_fixed_indicator(), fixed_n_elem, ((use_extra) ? mem_local _extra : Mat<eT>::mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
Col<eT>::operator=(A.get_ref()); Col<eT>::operator=(A.get_ref());
} }
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
template<typename T1, typename T2> template<typename T1, typename T2>
inline inline
Col<eT>::fixed<fixed_n_elem>::fixed(const Base<pod_type,T1>& A, const Base< pod_type,T2>& B) Col<eT>::fixed<fixed_n_elem>::fixed(const Base<pod_type,T1>& A, const Base< pod_type,T2>& B)
: Col<eT>( arma_fixed_indicator(), fixed_n_elem, ((use_extra) ? mem_local _extra : Mat<eT>::mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
Col<eT>::init(A,B); Col<eT>::init(A,B);
} }
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
inline inline
Col<eT>::fixed<fixed_n_elem>::fixed(const eT* aux_mem) Col<eT>::fixed<fixed_n_elem>::fixed(const eT* aux_mem)
: Col<eT>( arma_fixed_indicator(), fixed_n_elem, ((use_extra) ? mem_local _extra : Mat<eT>::mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup(); eT* dest = (use_extra) ? mem_local_extra : Mat<eT>::mem_local;
arrayops::copy( const_cast<eT*>(Mat<eT>::mem), aux_mem, fixed_n_elem ); arrayops::copy( dest, aux_mem, fixed_n_elem );
} }
//! NOTE: this function relies on //! NOTE: this function relies on
//! Col::operator=(text), to change vec_state as well as swapping n_rows an d n_cols, //! Col::operator=(text), to change vec_state as well as swapping n_rows an d n_cols,
//! and Mat::init(), to check that the given vector will not have a differe nt size than fixed_n_elem. //! and Mat::init(), to check that the given vector will not have a differe nt size than fixed_n_elem.
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
inline inline
Col<eT>::fixed<fixed_n_elem>::fixed(const char* text) Col<eT>::fixed<fixed_n_elem>::fixed(const char* text)
: Col<eT>( arma_fixed_indicator(), fixed_n_elem, ((use_extra) ? mem_local _extra : Mat<eT>::mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
change_to_row(); change_to_row();
Col<eT>::operator=(text); Col<eT>::operator=(text);
} }
//! NOTE: this function relies on //! NOTE: this function relies on
//! Col::operator=(text), to change vec_state as well as swapping n_rows an d n_cols, //! Col::operator=(text), to change vec_state as well as swapping n_rows an d n_cols,
//! and Mat::init(), to check that the given vector will not have a differe nt size than fixed_n_elem. //! and Mat::init(), to check that the given vector will not have a differe nt size than fixed_n_elem.
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
inline inline
Col<eT>::fixed<fixed_n_elem>::fixed(const std::string& text) Col<eT>::fixed<fixed_n_elem>::fixed(const std::string& text)
: Col<eT>( arma_fixed_indicator(), fixed_n_elem, ((use_extra) ? mem_local _extra : Mat<eT>::mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
change_to_row(); change_to_row();
Col<eT>::operator=(text); Col<eT>::operator=(text);
} }
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
template<typename T1> template<typename T1>
const Col<eT>& const Col<eT>&
Col<eT>::fixed<fixed_n_elem>::operator=(const Base<eT,T1>& A) Col<eT>::fixed<fixed_n_elem>::operator=(const Base<eT,T1>& A)
skipping to change at line 846 skipping to change at line 824
return *this; return *this;
} }
#if defined(ARMA_USE_CXX11) #if defined(ARMA_USE_CXX11)
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
inline inline
Col<eT>::fixed<fixed_n_elem>::fixed(const std::initializer_list<eT>& list) Col<eT>::fixed<fixed_n_elem>::fixed(const std::initializer_list<eT>& list)
: Col<eT>( arma_fixed_indicator(), fixed_n_elem, ((use_extra) ? mem_local _extra : Mat<eT>::mem_local) )
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint_this(this);
mem_setup();
(*this).operator=(list); (*this).operator=(list);
} }
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
inline inline
const Col<eT>& const Col<eT>&
Col<eT>::fixed<fixed_n_elem>::operator=(const std::initializer_list<eT>& li st) Col<eT>::fixed<fixed_n_elem>::operator=(const std::initializer_list<eT>& li st)
{ {
skipping to change at line 1053 skipping to change at line 1030
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
eT* mem_use = (use_extra) ? &(mem_local_extra[0]) : &(Mat<eT>::mem_local[ 0]); eT* mem_use = (use_extra) ? &(mem_local_extra[0]) : &(Mat<eT>::mem_local[ 0]);
arrayops::inplace_set_fixed<eT,fixed_n_elem>( mem_use, eT(1) ); arrayops::inplace_set_fixed<eT,fixed_n_elem>( mem_use, eT(1) );
return *this; return *this;
} }
template<typename eT>
inline
Col<eT>::Col(const arma_fixed_indicator&, const uword in_n_elem, const eT*
in_mem)
: Mat<eT>(arma_fixed_indicator(), in_n_elem, 1, 1, in_mem)
{
arma_extra_debug_sigprint_this(this);
}
#ifdef ARMA_EXTRA_COL_MEAT #ifdef ARMA_EXTRA_COL_MEAT
#include ARMA_INCFILE_WRAP(ARMA_EXTRA_COL_MEAT) #include ARMA_INCFILE_WRAP(ARMA_EXTRA_COL_MEAT)
#endif #endif
//! @} //! @}
 End of changes. 21 change blocks. 
36 lines changed or deleted 21 lines changed or added


 Cube_meat.hpp   Cube_meat.hpp 
// Copyright (C) 2008-2011 NICTA (www.nicta.com.au) // Copyright (C) 2008-2012 NICTA (www.nicta.com.au)
// Copyright (C) 2008-2011 Conrad Sanderson // Copyright (C) 2008-2012 Conrad Sanderson
// //
// This file is part of the Armadillo C++ library. // This file is part of the Armadillo C++ library.
// It is provided without any warranty of fitness // It is provided without any warranty of fitness
// for any purpose. You can redistribute this file // for any purpose. You can redistribute this file
// and/or modify it under the terms of the GNU // and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published // Lesser General Public License (LGPL) as published
// by the Free Software Foundation, either version 3 // by the Free Software Foundation, either version 3
// of the License or (at your option) any later version. // of the License or (at your option) any later version.
// (see http://www.opensource.org/licenses for more info) // (see http://www.opensource.org/licenses for more info)
skipping to change at line 35 skipping to change at line 35
{ {
if(n_elem > Cube_prealloc::mem_n_elem) if(n_elem > Cube_prealloc::mem_n_elem)
{ {
memory::release( access::rw(mem) ); memory::release( access::rw(mem) );
} }
} }
if(arma_config::debug == true) if(arma_config::debug == true)
{ {
// try to expose buggy user code that accesses deleted objects // try to expose buggy user code that accesses deleted objects
access::rw(n_rows) = 0;
access::rw(n_cols) = 0;
access::rw(n_slices) = 0;
access::rw(n_elem) = 0;
access::rw(mat_ptrs) = 0; access::rw(mat_ptrs) = 0;
access::rw(mem) = 0; access::rw(mem) = 0;
} }
arma_type_check(( is_supported_elem_type<eT>::value == false )); arma_type_check(( is_supported_elem_type<eT>::value == false ));
} }
template<typename eT> template<typename eT>
inline inline
Cube<eT>::Cube() Cube<eT>::Cube()
 End of changes. 2 change blocks. 
6 lines changed or deleted 2 lines changed or added


 Mat_bones.hpp   Mat_bones.hpp 
skipping to change at line 451 skipping to change at line 451
template<uword fixed_n_rows, uword fixed_n_cols> template<uword fixed_n_rows, uword fixed_n_cols>
class fixed : public Mat<eT> class fixed : public Mat<eT>
{ {
private: private:
static const uword fixed_n_elem = fixed_n_rows * fixed_n_cols; static const uword fixed_n_elem = fixed_n_rows * fixed_n_cols;
static const bool use_extra = (fixed_n_elem > arma_config::mat_prea lloc); static const bool use_extra = (fixed_n_elem > arma_config::mat_prea lloc);
arma_aligned eT mem_local_extra[ (use_extra) ? fixed_n_elem : 1 ]; arma_aligned eT mem_local_extra[ (use_extra) ? fixed_n_elem : 1 ];
arma_inline void mem_setup();
public: public:
typedef fixed<fixed_n_rows, fixed_n_cols> Mat_fixed_type; typedef fixed<fixed_n_rows, fixed_n_cols> Mat_fixed_type;
typedef eT elem_type; typedef eT elem_type;
typedef typename get_pod_type<eT>::result pod_type; typedef typename get_pod_type<eT>::result pod_type;
static const bool is_col = (fixed_n_cols == 1) ? true : false; static const bool is_col = (fixed_n_cols == 1) ? true : false;
static const bool is_row = (fixed_n_rows == 1) ? true : false; static const bool is_row = (fixed_n_rows == 1) ? true : false;
skipping to change at line 527 skipping to change at line 525
#endif #endif
template<typename T1, typename T2> template<typename T1, typename T2>
inline void init(const Base<pod_type,T1>& A, const Base<pod_type,T2>& B); inline void init(const Base<pod_type,T1>& A, const Base<pod_type,T2>& B);
inline Mat(const char junk, const eT* aux_mem, const uword aux_n_rows, co nst uword aux_n_cols); inline Mat(const char junk, const eT* aux_mem, const uword aux_n_rows, co nst uword aux_n_cols);
inline Mat(const arma_vec_indicator&, const uhword in_vec_state); inline Mat(const arma_vec_indicator&, const uhword in_vec_state);
inline Mat(const arma_vec_indicator&, const uword in_n_rows, const uword in_n_cols, const uhword in_vec_state); inline Mat(const arma_vec_indicator&, const uword in_n_rows, const uword in_n_cols, const uhword in_vec_state);
inline Mat(const arma_fixed_indicator&, const uword in_n_rows, const uwor
d in_n_cols, const uhword in_vec_state, const eT* in_mem);
friend class Cube<eT>; friend class Cube<eT>;
friend class glue_join; friend class glue_join;
friend class op_strans; friend class op_strans;
friend class op_htrans; friend class op_htrans;
friend class op_resize; friend class op_resize;
public: public:
#ifdef ARMA_EXTRA_MAT_PROTO #ifdef ARMA_EXTRA_MAT_PROTO
#include ARMA_INCFILE_WRAP(ARMA_EXTRA_MAT_PROTO) #include ARMA_INCFILE_WRAP(ARMA_EXTRA_MAT_PROTO)
 End of changes. 2 change blocks. 
2 lines changed or deleted 3 lines changed or added


 Mat_meat.hpp   Mat_meat.hpp 
skipping to change at line 33 skipping to change at line 33
{ {
if(n_elem > arma_config::mat_prealloc) if(n_elem > arma_config::mat_prealloc)
{ {
memory::release( access::rw(mem) ); memory::release( access::rw(mem) );
} }
} }
if(arma_config::debug == true) if(arma_config::debug == true)
{ {
// try to expose buggy user code that accesses deleted objects // try to expose buggy user code that accesses deleted objects
access::rw(n_rows) = 0; access::rw(mem) = 0;
access::rw(n_cols) = 0;
access::rw(n_elem) = 0;
access::rw(mem) = 0;
} }
arma_type_check(( is_supported_elem_type<eT>::value == false )); arma_type_check(( is_supported_elem_type<eT>::value == false ));
} }
template<typename eT> template<typename eT>
inline inline
Mat<eT>::Mat() Mat<eT>::Mat()
: n_rows(0) : n_rows(0)
, n_cols(0) , n_cols(0)
skipping to change at line 103 skipping to change at line 100
, mem_state(0) , mem_state(0)
, mem() , mem()
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
init_cold(); init_cold();
} }
template<typename eT> template<typename eT>
inline inline
Mat<eT>::Mat(const arma_fixed_indicator&, const uword in_n_rows, const uwor
d in_n_cols, const uhword in_vec_state, const eT* in_mem)
: n_rows (in_n_rows)
, n_cols (in_n_cols)
, n_elem (in_n_rows*in_n_cols)
, vec_state (in_vec_state)
, mem_state (3)
, mem (in_mem)
{
arma_extra_debug_sigprint_this(this);
}
template<typename eT>
inline
void void
Mat<eT>::init_cold() Mat<eT>::init_cold()
{ {
arma_extra_debug_sigprint( arma_boost::format("n_rows = %d, n_cols = %d") % n_rows % n_cols ); arma_extra_debug_sigprint( arma_boost::format("n_rows = %d, n_cols = %d") % n_rows % n_cols );
// ensure that n_elem can hold the result of (n_rows * n_cols) // ensure that n_elem can hold the result of (n_rows * n_cols)
arma_debug_check arma_debug_check
( (
( (
skipping to change at line 182 skipping to change at line 192
in_n_rows = 1; in_n_rows = 1;
} }
} }
else else
{ {
arma_debug_set_error arma_debug_set_error
( (
err_state, err_state,
err_msg, err_msg,
( ((t_vec_state == 1) && (in_n_cols != 1)) || ((t_vec_state == 2) & & (in_n_rows != 1)) ), ( ((t_vec_state == 1) && (in_n_cols != 1)) || ((t_vec_state == 2) & & (in_n_rows != 1)) ),
"Mat::init(): object is a vector; requested size is not compatible" "Mat::init(): object is a row or column vector; requested size is n ot compatible"
); );
} }
} }
// ensure that n_elem can hold the result of (n_rows * n_cols) // ensure that n_elem can hold the result of (n_rows * n_cols)
arma_debug_set_error arma_debug_set_error
( (
err_state, err_state,
err_msg, err_msg,
skipping to change at line 5088 skipping to change at line 5098
inline inline
uword uword
Mat<eT>::size() const Mat<eT>::size() const
{ {
return n_elem; return n_elem;
} }
template<typename eT> template<typename eT>
template<uword fixed_n_rows, uword fixed_n_cols> template<uword fixed_n_rows, uword fixed_n_cols>
arma_inline arma_inline
void
Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::mem_setup()
{
arma_extra_debug_sigprint();
access::rw(Mat<eT>::n_rows) = fixed_n_rows;
access::rw(Mat<eT>::n_cols) = fixed_n_cols;
access::rw(Mat<eT>::n_elem) = fixed_n_elem;
access::rw(Mat<eT>::vec_state) = 0;
access::rw(Mat<eT>::mem_state) = 3;
access::rw(Mat<eT>::mem) = (use_extra) ? mem_local_extra : mem_loca
l;
}
template<typename eT>
template<uword fixed_n_rows, uword fixed_n_cols>
arma_inline
Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::fixed() Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::fixed()
: Mat<eT>( arma_fixed_indicator(), fixed_n_rows, fixed_n_cols, 0, ((use_e xtra) ? mem_local_extra : mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
} }
template<typename eT> template<typename eT>
template<uword fixed_n_rows, uword fixed_n_cols> template<uword fixed_n_rows, uword fixed_n_cols>
arma_inline arma_inline
Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::fixed(const fixed<fixed_n_rows, fixed_n_cols>& X) Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::fixed(const fixed<fixed_n_rows, fixed_n_cols>& X)
: Mat<eT>( arma_fixed_indicator(), fixed_n_rows, fixed_n_cols, 0, ((use_e xtra) ? mem_local_extra : mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
eT* dest = (use_extra) ? mem_local_extra : mem_local; eT* dest = (use_extra) ? mem_local_extra : mem_local;
arrayops::copy( dest, X.mem, fixed_n_elem ); arrayops::copy( dest, X.mem, fixed_n_elem );
} }
template<typename eT> template<typename eT>
template<uword fixed_n_rows, uword fixed_n_cols> template<uword fixed_n_rows, uword fixed_n_cols>
template<typename T1> template<typename T1>
inline inline
Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::fixed(const Base<eT,T1>& A) Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::fixed(const Base<eT,T1>& A)
: Mat<eT>( arma_fixed_indicator(), fixed_n_rows, fixed_n_cols, 0, ((use_e xtra) ? mem_local_extra : mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
Mat<eT>::operator=(A.get_ref()); Mat<eT>::operator=(A.get_ref());
} }
template<typename eT> template<typename eT>
template<uword fixed_n_rows, uword fixed_n_cols> template<uword fixed_n_rows, uword fixed_n_cols>
template<typename T1, typename T2> template<typename T1, typename T2>
inline inline
Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::fixed(const Base<pod_type,T1>& A, const Base<pod_type,T2>& B) Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::fixed(const Base<pod_type,T1>& A, const Base<pod_type,T2>& B)
: Mat<eT>( arma_fixed_indicator(), fixed_n_rows, fixed_n_cols, 0, ((use_e xtra) ? mem_local_extra : mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
Mat<eT>::init(A,B); Mat<eT>::init(A,B);
} }
template<typename eT> template<typename eT>
template<uword fixed_n_rows, uword fixed_n_cols> template<uword fixed_n_rows, uword fixed_n_cols>
inline inline
Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::fixed(const eT* aux_mem) Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::fixed(const eT* aux_mem)
: Mat<eT>( arma_fixed_indicator(), fixed_n_rows, fixed_n_cols, 0, ((use_e xtra) ? mem_local_extra : mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup(); eT* dest = (use_extra) ? mem_local_extra : mem_local;
arrayops::copy( const_cast<eT*>(Mat<eT>::mem), aux_mem, fixed_n_elem ); arrayops::copy( dest, aux_mem, fixed_n_elem );
} }
template<typename eT> template<typename eT>
template<uword fixed_n_rows, uword fixed_n_cols> template<uword fixed_n_rows, uword fixed_n_cols>
inline inline
Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::fixed(const char* text) Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::fixed(const char* text)
: Mat<eT>( arma_fixed_indicator(), fixed_n_rows, fixed_n_cols, 0, ((use_e xtra) ? mem_local_extra : mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
Mat<eT>::operator=(text); Mat<eT>::operator=(text);
} }
template<typename eT> template<typename eT>
template<uword fixed_n_rows, uword fixed_n_cols> template<uword fixed_n_rows, uword fixed_n_cols>
inline inline
Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::fixed(const std::string& text) Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::fixed(const std::string& text)
: Mat<eT>( arma_fixed_indicator(), fixed_n_rows, fixed_n_cols, 0, ((use_e xtra) ? mem_local_extra : mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
Mat<eT>::operator=(text); Mat<eT>::operator=(text);
} }
#if defined(ARMA_USE_CXX11) #if defined(ARMA_USE_CXX11)
template<typename eT> template<typename eT>
template<uword fixed_n_rows, uword fixed_n_cols> template<uword fixed_n_rows, uword fixed_n_cols>
inline inline
Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::fixed(const std::initializer_li st<eT>& list) Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::fixed(const std::initializer_li st<eT>& list)
: Mat<eT>( arma_fixed_indicator(), fixed_n_rows, fixed_n_cols, 0, ((use_e xtra) ? mem_local_extra : mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
(*this).operator=(list); (*this).operator=(list);
} }
template<typename eT> template<typename eT>
template<uword fixed_n_rows, uword fixed_n_cols> template<uword fixed_n_rows, uword fixed_n_cols>
inline inline
const Mat<eT>& const Mat<eT>&
Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::operator=(const std::initialize r_list<eT>& list) Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::operator=(const std::initialize r_list<eT>& list)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
 End of changes. 21 change blocks. 
38 lines changed or deleted 26 lines changed or added


 Proxy.hpp   Proxy.hpp 
skipping to change at line 39 skipping to change at line 39
struct Proxy_fixed struct Proxy_fixed
{ {
typedef typename T1::elem_type elem_type; typedef typename T1::elem_type elem_type;
typedef typename get_pod_type<elem_type>::result pod_type; typedef typename get_pod_type<elem_type>::result pod_type;
typedef T1 stored_type; typedef T1 stored_type;
typedef const elem_type* ea_type; typedef const elem_type* ea_type;
static const bool prefer_at_accessor = false; static const bool prefer_at_accessor = false;
static const bool has_subview = false; static const bool has_subview = false;
static const bool is_fixed = true; static const bool is_fixed = true;
static const bool fake_mat = false;
static const bool is_row = T1::is_row; static const bool is_row = T1::is_row;
static const bool is_col = T1::is_col; static const bool is_col = T1::is_col;
arma_aligned const T1& Q; arma_aligned const T1& Q;
inline explicit Proxy_fixed(const T1& A) inline explicit Proxy_fixed(const T1& A)
: Q(A) : Q(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 96 skipping to change at line 97
public: public:
typedef eT elem_type; typedef eT elem_type;
typedef typename get_pod_type<elem_type>::result pod_type; typedef typename get_pod_type<elem_type>::result pod_type;
typedef Mat<eT> stored_type; typedef Mat<eT> stored_type;
typedef const eT* ea_type; typedef const eT* ea_type;
static const bool prefer_at_accessor = false; static const bool prefer_at_accessor = false;
static const bool has_subview = false; static const bool has_subview = false;
static const bool is_fixed = false; static const bool is_fixed = false;
static const bool fake_mat = false;
static const bool is_row = false; static const bool is_row = false;
static const bool is_col = false; static const bool is_col = false;
arma_aligned const Mat<eT>& Q; arma_aligned const Mat<eT>& Q;
inline explicit Proxy(const Mat<eT>& A) inline explicit Proxy(const Mat<eT>& A)
: Q(A) : Q(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 134 skipping to change at line 136
public: public:
typedef eT elem_type; typedef eT elem_type;
typedef typename get_pod_type<elem_type>::result pod_type; typedef typename get_pod_type<elem_type>::result pod_type;
typedef Col<eT> stored_type; typedef Col<eT> stored_type;
typedef const eT* ea_type; typedef const eT* ea_type;
static const bool prefer_at_accessor = false; static const bool prefer_at_accessor = false;
static const bool has_subview = false; static const bool has_subview = false;
static const bool is_fixed = false; static const bool is_fixed = false;
static const bool fake_mat = false;
static const bool is_row = false; static const bool is_row = false;
static const bool is_col = true; static const bool is_col = true;
arma_aligned const Col<eT>& Q; arma_aligned const Col<eT>& Q;
inline explicit Proxy(const Col<eT>& A) inline explicit Proxy(const Col<eT>& A)
: Q(A) : Q(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 172 skipping to change at line 175
public: public:
typedef eT elem_type; typedef eT elem_type;
typedef typename get_pod_type<elem_type>::result pod_type; typedef typename get_pod_type<elem_type>::result pod_type;
typedef Row<eT> stored_type; typedef Row<eT> stored_type;
typedef const eT* ea_type; typedef const eT* ea_type;
static const bool prefer_at_accessor = false; static const bool prefer_at_accessor = false;
static const bool has_subview = false; static const bool has_subview = false;
static const bool is_fixed = false; static const bool is_fixed = false;
static const bool fake_mat = false;
static const bool is_row = true; static const bool is_row = true;
static const bool is_col = false; static const bool is_col = false;
arma_aligned const Row<eT>& Q; arma_aligned const Row<eT>& Q;
inline explicit Proxy(const Row<eT>& A) inline explicit Proxy(const Row<eT>& A)
: Q(A) : Q(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 210 skipping to change at line 214
public: public:
typedef typename T1::elem_type elem_type; typedef typename T1::elem_type elem_type;
typedef typename get_pod_type<elem_type>::result pod_type; typedef typename get_pod_type<elem_type>::result pod_type;
typedef Gen<T1, gen_type> stored_type; typedef Gen<T1, gen_type> stored_type;
typedef const Gen<T1, gen_type>& ea_type; typedef const Gen<T1, gen_type>& ea_type;
static const bool prefer_at_accessor = Gen<T1, gen_type>::prefer_at_acces sor; static const bool prefer_at_accessor = Gen<T1, gen_type>::prefer_at_acces sor;
static const bool has_subview = false; static const bool has_subview = false;
static const bool is_fixed = false; static const bool is_fixed = false;
static const bool fake_mat = false;
static const bool is_row = Gen<T1, gen_type>::is_row; static const bool is_row = Gen<T1, gen_type>::is_row;
static const bool is_col = Gen<T1, gen_type>::is_col; static const bool is_col = Gen<T1, gen_type>::is_col;
arma_aligned const Gen<T1, gen_type>& Q; arma_aligned const Gen<T1, gen_type>& Q;
inline explicit Proxy(const Gen<T1, gen_type>& A) inline explicit Proxy(const Gen<T1, gen_type>& A)
: Q(A) : Q(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 248 skipping to change at line 253
public: public:
typedef typename T1::elem_type elem_type; typedef typename T1::elem_type elem_type;
typedef typename get_pod_type<elem_type>::result pod_type; typedef typename get_pod_type<elem_type>::result pod_type;
typedef Mat<elem_type> stored_type; typedef Mat<elem_type> stored_type;
typedef const elem_type* ea_type; typedef const elem_type* ea_type;
static const bool prefer_at_accessor = false; static const bool prefer_at_accessor = false;
static const bool has_subview = false; static const bool has_subview = false;
static const bool is_fixed = false; static const bool is_fixed = false;
static const bool fake_mat = false;
static const bool is_row = Op<T1, op_type>::is_row; static const bool is_row = Op<T1, op_type>::is_row;
static const bool is_col = Op<T1, op_type>::is_col; static const bool is_col = Op<T1, op_type>::is_col;
arma_aligned const Mat<elem_type> Q; arma_aligned const Mat<elem_type> Q;
inline explicit Proxy(const Op<T1, op_type>& A) inline explicit Proxy(const Op<T1, op_type>& A)
: Q(A) : Q(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 281 skipping to change at line 287
}; };
template<typename T1> template<typename T1>
struct Proxy_xtrans_default struct Proxy_xtrans_default
{ {
typedef typename T1::elem_type eT; typedef typename T1::elem_type eT;
static const bool prefer_at_accessor = false; static const bool prefer_at_accessor = false;
static const bool has_subview = false; static const bool has_subview = false;
static const bool is_fixed = false; static const bool is_fixed = false;
static const bool fake_mat = false;
arma_aligned const Mat<eT> Q; arma_aligned const Mat<eT> Q;
arma_hot arma_hot
inline Proxy_xtrans_default(const T1& A) inline Proxy_xtrans_default(const T1& A)
: Q(A) : Q(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
skipping to change at line 309 skipping to change at line 316
}; };
template<typename T1> template<typename T1>
struct Proxy_xtrans_vector< Op<T1, op_htrans> > struct Proxy_xtrans_vector< Op<T1, op_htrans> >
{ {
typedef typename T1::elem_type eT; typedef typename T1::elem_type eT;
static const bool prefer_at_accessor = false; static const bool prefer_at_accessor = false;
static const bool has_subview = quasi_unwrap<T1>::has_subview; static const bool has_subview = quasi_unwrap<T1>::has_subview;
static const bool is_fixed = false; static const bool is_fixed = false;
static const bool fake_mat = true;
arma_aligned const quasi_unwrap<T1> U; // avoid copy if T1 is a Row, Col or subview_col arma_aligned const quasi_unwrap<T1> U; // avoid copy if T1 is a Row, Col or subview_col
arma_aligned const Mat<eT> Q; arma_aligned const Mat<eT> Q;
inline Proxy_xtrans_vector(const Op<T1, op_htrans>& A) inline Proxy_xtrans_vector(const Op<T1, op_htrans>& A)
: U(A.m) : U(A.m)
, Q(const_cast<eT*>(U.M.memptr()), U.M.n_cols, U.M.n_rows, false, false ) , Q(const_cast<eT*>(U.M.memptr()), U.M.n_cols, U.M.n_rows, false, false )
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
skipping to change at line 332 skipping to change at line 340
}; };
template<typename T1> template<typename T1>
struct Proxy_xtrans_vector< Op<T1, op_strans> > struct Proxy_xtrans_vector< Op<T1, op_strans> >
{ {
typedef typename T1::elem_type eT; typedef typename T1::elem_type eT;
static const bool prefer_at_accessor = false; static const bool prefer_at_accessor = false;
static const bool has_subview = quasi_unwrap<T1>::has_subview; static const bool has_subview = quasi_unwrap<T1>::has_subview;
static const bool is_fixed = false; static const bool is_fixed = false;
static const bool fake_mat = true;
arma_aligned const quasi_unwrap<T1> U; // avoid copy if T1 is a Row, Col or subview_col arma_aligned const quasi_unwrap<T1> U; // avoid copy if T1 is a Row, Col or subview_col
arma_aligned const Mat<eT> Q; arma_aligned const Mat<eT> Q;
inline Proxy_xtrans_vector(const Op<T1, op_strans>& A) inline Proxy_xtrans_vector(const Op<T1, op_strans>& A)
: U(A.m) : U(A.m)
, Q(const_cast<eT*>(U.M.memptr()), U.M.n_cols, U.M.n_rows, false, false ) , Q(const_cast<eT*>(U.M.memptr()), U.M.n_cols, U.M.n_rows, false, false )
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
skipping to change at line 384 skipping to change at line 393
Proxy_xtrans; Proxy_xtrans;
typedef typename T1::elem_type elem_type; typedef typename T1::elem_type elem_type;
typedef typename get_pod_type<elem_type>::result pod_type; typedef typename get_pod_type<elem_type>::result pod_type;
typedef Mat<elem_type> stored_type; typedef Mat<elem_type> stored_type;
typedef const elem_type* ea_type; typedef const elem_type* ea_type;
static const bool prefer_at_accessor = Proxy_xtrans::prefer_at_accessor; static const bool prefer_at_accessor = Proxy_xtrans::prefer_at_accessor;
static const bool has_subview = Proxy_xtrans::has_subview; static const bool has_subview = Proxy_xtrans::has_subview;
static const bool is_fixed = Proxy_xtrans::is_fixed; static const bool is_fixed = Proxy_xtrans::is_fixed;
static const bool fake_mat = Proxy_xtrans::fake_mat;
// NOTE: the Op class takes care of swapping row and col for op_htrans // NOTE: the Op class takes care of swapping row and col for op_htrans
static const bool is_row = Op<T1, op_htrans>::is_row; static const bool is_row = Op<T1, op_htrans>::is_row;
static const bool is_col = Op<T1, op_htrans>::is_col; static const bool is_col = Op<T1, op_htrans>::is_col;
using Proxy_xtrans::Q; using Proxy_xtrans::Q;
inline explicit Proxy(const Op<T1, op_htrans>& A) inline explicit Proxy(const Op<T1, op_htrans>& A)
: Proxy_xtrans(A) : Proxy_xtrans(A)
{ {
skipping to change at line 438 skipping to change at line 448
Proxy_xtrans; Proxy_xtrans;
typedef typename T1::elem_type elem_type; typedef typename T1::elem_type elem_type;
typedef typename get_pod_type<elem_type>::result pod_type; typedef typename get_pod_type<elem_type>::result pod_type;
typedef Mat<elem_type> stored_type; typedef Mat<elem_type> stored_type;
typedef const elem_type* ea_type; typedef const elem_type* ea_type;
static const bool prefer_at_accessor = Proxy_xtrans::prefer_at_accessor; static const bool prefer_at_accessor = Proxy_xtrans::prefer_at_accessor;
static const bool has_subview = Proxy_xtrans::has_subview; static const bool has_subview = Proxy_xtrans::has_subview;
static const bool is_fixed = Proxy_xtrans::is_fixed; static const bool is_fixed = Proxy_xtrans::is_fixed;
static const bool fake_mat = Proxy_xtrans::fake_mat;
// NOTE: the Op class takes care of swapping row and col for op_strans // NOTE: the Op class takes care of swapping row and col for op_strans
static const bool is_row = Op<T1, op_strans>::is_row; static const bool is_row = Op<T1, op_strans>::is_row;
static const bool is_col = Op<T1, op_strans>::is_col; static const bool is_col = Op<T1, op_strans>::is_col;
using Proxy_xtrans::Q; using Proxy_xtrans::Q;
inline explicit Proxy(const Op<T1, op_strans>& A) inline explicit Proxy(const Op<T1, op_strans>& A)
: Proxy_xtrans(A) : Proxy_xtrans(A)
{ {
skipping to change at line 477 skipping to change at line 488
public: public:
typedef typename T1::elem_type elem_type; typedef typename T1::elem_type elem_type;
typedef typename get_pod_type<elem_type>::result pod_type; typedef typename get_pod_type<elem_type>::result pod_type;
typedef Mat<elem_type> stored_type; typedef Mat<elem_type> stored_type;
typedef const elem_type* ea_type; typedef const elem_type* ea_type;
static const bool prefer_at_accessor = false; static const bool prefer_at_accessor = false;
static const bool has_subview = false; static const bool has_subview = false;
static const bool is_fixed = false; static const bool is_fixed = false;
static const bool fake_mat = false;
static const bool is_row = Glue<T1, T2, glue_type>::is_row; static const bool is_row = Glue<T1, T2, glue_type>::is_row;
static const bool is_col = Glue<T1, T2, glue_type>::is_col; static const bool is_col = Glue<T1, T2, glue_type>::is_col;
arma_aligned const Mat<elem_type> Q; arma_aligned const Mat<elem_type> Q;
inline explicit Proxy(const Glue<T1, T2, glue_type>& A) inline explicit Proxy(const Glue<T1, T2, glue_type>& A)
: Q(A) : Q(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 515 skipping to change at line 527
public: public:
typedef eT elem_type; typedef eT elem_type;
typedef typename get_pod_type<elem_type>::result pod_type; typedef typename get_pod_type<elem_type>::result pod_type;
typedef subview<eT> stored_type; typedef subview<eT> stored_type;
typedef const subview<eT>& ea_type; typedef const subview<eT>& ea_type;
static const bool prefer_at_accessor = true; static const bool prefer_at_accessor = true;
static const bool has_subview = true; static const bool has_subview = true;
static const bool is_fixed = false; static const bool is_fixed = false;
static const bool fake_mat = false;
static const bool is_row = false; static const bool is_row = false;
static const bool is_col = false; static const bool is_col = false;
arma_aligned const subview<eT>& Q; arma_aligned const subview<eT>& Q;
inline explicit Proxy(const subview<eT>& A) inline explicit Proxy(const subview<eT>& A)
: Q(A) : Q(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 553 skipping to change at line 566
public: public:
typedef eT elem_type; typedef eT elem_type;
typedef typename get_pod_type<elem_type>::result pod_type; typedef typename get_pod_type<elem_type>::result pod_type;
typedef subview_col<eT> stored_type; typedef subview_col<eT> stored_type;
typedef const eT* ea_type; typedef const eT* ea_type;
static const bool prefer_at_accessor = false; static const bool prefer_at_accessor = false;
static const bool has_subview = true; static const bool has_subview = true;
static const bool is_fixed = false; static const bool is_fixed = false;
static const bool fake_mat = false;
static const bool is_row = false; static const bool is_row = false;
static const bool is_col = true; static const bool is_col = true;
arma_aligned const subview_col<eT>& Q; arma_aligned const subview_col<eT>& Q;
inline explicit Proxy(const subview_col<eT>& A) inline explicit Proxy(const subview_col<eT>& A)
: Q(A) : Q(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 591 skipping to change at line 605
public: public:
typedef eT elem_type; typedef eT elem_type;
typedef typename get_pod_type<elem_type>::result pod_type; typedef typename get_pod_type<elem_type>::result pod_type;
typedef subview_row<eT> stored_type; typedef subview_row<eT> stored_type;
typedef const subview_row<eT>& ea_type; typedef const subview_row<eT>& ea_type;
static const bool prefer_at_accessor = false; static const bool prefer_at_accessor = false;
static const bool has_subview = true; static const bool has_subview = true;
static const bool is_fixed = false; static const bool is_fixed = false;
static const bool fake_mat = false;
static const bool is_row = true; static const bool is_row = true;
static const bool is_col = false; static const bool is_col = false;
arma_aligned const subview_row<eT>& Q; arma_aligned const subview_row<eT>& Q;
inline explicit Proxy(const subview_row<eT>& A) inline explicit Proxy(const subview_row<eT>& A)
: Q(A) : Q(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 629 skipping to change at line 644
public: public:
typedef eT elem_type; typedef eT elem_type;
typedef typename get_pod_type<elem_type>::result pod_type; typedef typename get_pod_type<elem_type>::result pod_type;
typedef Mat<eT> stored_type; typedef Mat<eT> stored_type;
typedef const eT* ea_type; typedef const eT* ea_type;
static const bool prefer_at_accessor = false; static const bool prefer_at_accessor = false;
static const bool has_subview = false; static const bool has_subview = false;
static const bool is_fixed = false; static const bool is_fixed = false;
static const bool fake_mat = false;
static const bool is_row = false; static const bool is_row = false;
static const bool is_col = true; static const bool is_col = true;
arma_aligned const Mat<eT> Q; arma_aligned const Mat<eT> Q;
inline explicit Proxy(const subview_elem1<eT,T1>& A) inline explicit Proxy(const subview_elem1<eT,T1>& A)
: Q(A) : Q(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 667 skipping to change at line 683
public: public:
typedef eT elem_type; typedef eT elem_type;
typedef typename get_pod_type<elem_type>::result pod_type; typedef typename get_pod_type<elem_type>::result pod_type;
typedef Mat<eT> stored_type; typedef Mat<eT> stored_type;
typedef const eT* ea_type; typedef const eT* ea_type;
static const bool prefer_at_accessor = false; static const bool prefer_at_accessor = false;
static const bool has_subview = false; static const bool has_subview = false;
static const bool is_fixed = false; static const bool is_fixed = false;
static const bool fake_mat = false;
static const bool is_row = false; static const bool is_row = false;
static const bool is_col = false; static const bool is_col = false;
arma_aligned const Mat<eT> Q; arma_aligned const Mat<eT> Q;
inline explicit Proxy(const subview_elem2<eT,T1,T2>& A) inline explicit Proxy(const subview_elem2<eT,T1,T2>& A)
: Q(A) : Q(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 705 skipping to change at line 722
public: public:
typedef eT elem_type; typedef eT elem_type;
typedef typename get_pod_type<elem_type>::result pod_type; typedef typename get_pod_type<elem_type>::result pod_type;
typedef diagview<eT> stored_type; typedef diagview<eT> stored_type;
typedef const diagview<eT>& ea_type; typedef const diagview<eT>& ea_type;
static const bool prefer_at_accessor = false; static const bool prefer_at_accessor = false;
static const bool has_subview = true; static const bool has_subview = true;
static const bool is_fixed = false; static const bool is_fixed = false;
static const bool fake_mat = false;
static const bool is_row = false; static const bool is_row = false;
static const bool is_col = true; static const bool is_col = true;
arma_aligned const diagview<eT>& Q; arma_aligned const diagview<eT>& Q;
inline explicit Proxy(const diagview<eT>& A) inline explicit Proxy(const diagview<eT>& A)
: Q(A) : Q(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 743 skipping to change at line 761
public: public:
typedef typename T1::elem_type elem_type; typedef typename T1::elem_type elem_type;
typedef typename get_pod_type<elem_type>::result pod_type; typedef typename get_pod_type<elem_type>::result pod_type;
typedef eOp<T1, eop_type> stored_type; typedef eOp<T1, eop_type> stored_type;
typedef const eOp<T1, eop_type>& ea_type; typedef const eOp<T1, eop_type>& ea_type;
static const bool prefer_at_accessor = eOp<T1, eop_type>::prefer_at_acces sor; static const bool prefer_at_accessor = eOp<T1, eop_type>::prefer_at_acces sor;
static const bool has_subview = eOp<T1, eop_type>::has_subview; static const bool has_subview = eOp<T1, eop_type>::has_subview;
static const bool is_fixed = eOp<T1, eop_type>::is_fixed; static const bool is_fixed = eOp<T1, eop_type>::is_fixed;
static const bool fake_mat = eOp<T1, eop_type>::fake_mat;
static const bool is_row = eOp<T1, eop_type>::is_row; static const bool is_row = eOp<T1, eop_type>::is_row;
static const bool is_col = eOp<T1, eop_type>::is_col; static const bool is_col = eOp<T1, eop_type>::is_col;
arma_aligned const eOp<T1, eop_type>& Q; arma_aligned const eOp<T1, eop_type>& Q;
inline explicit Proxy(const eOp<T1, eop_type>& A) inline explicit Proxy(const eOp<T1, eop_type>& A)
: Q(A) : Q(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 781 skipping to change at line 800
public: public:
typedef typename T1::elem_type elem_type; typedef typename T1::elem_type elem_type;
typedef typename get_pod_type<elem_type>::result pod_type; typedef typename get_pod_type<elem_type>::result pod_type;
typedef eGlue<T1, T2, eglue_type> stored_type; typedef eGlue<T1, T2, eglue_type> stored_type;
typedef const eGlue<T1, T2, eglue_type>& ea_type; typedef const eGlue<T1, T2, eglue_type>& ea_type;
static const bool prefer_at_accessor = eGlue<T1, T2, eglue_type>::prefer_ at_accessor; static const bool prefer_at_accessor = eGlue<T1, T2, eglue_type>::prefer_ at_accessor;
static const bool has_subview = eGlue<T1, T2, eglue_type>::has_sub view; static const bool has_subview = eGlue<T1, T2, eglue_type>::has_sub view;
static const bool is_fixed = eGlue<T1, T2, eglue_type>::is_fixe d; static const bool is_fixed = eGlue<T1, T2, eglue_type>::is_fixe d;
static const bool fake_mat = eGlue<T1, T2, eglue_type>::fake_ma t;
static const bool is_row = eGlue<T1, T2, eglue_type>::is_row; static const bool is_row = eGlue<T1, T2, eglue_type>::is_row;
static const bool is_col = eGlue<T1, T2, eglue_type>::is_col; static const bool is_col = eGlue<T1, T2, eglue_type>::is_col;
arma_aligned const eGlue<T1, T2, eglue_type>& Q; arma_aligned const eGlue<T1, T2, eglue_type>& Q;
inline explicit Proxy(const eGlue<T1, T2, eglue_type>& A) inline explicit Proxy(const eGlue<T1, T2, eglue_type>& A)
: Q(A) : Q(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 819 skipping to change at line 839
public: public:
typedef out_eT elem_type; typedef out_eT elem_type;
typedef typename get_pod_type<out_eT>::result pod_type; typedef typename get_pod_type<out_eT>::result pod_type;
typedef Mat<out_eT> stored_type; typedef Mat<out_eT> stored_type;
typedef const elem_type* ea_type; typedef const elem_type* ea_type;
static const bool prefer_at_accessor = false; static const bool prefer_at_accessor = false;
static const bool has_subview = false; static const bool has_subview = false;
static const bool is_fixed = false; static const bool is_fixed = false;
static const bool fake_mat = false;
static const bool is_row = mtOp<out_eT, T1, op_type>::is_row; static const bool is_row = mtOp<out_eT, T1, op_type>::is_row;
static const bool is_col = mtOp<out_eT, T1, op_type>::is_col; static const bool is_col = mtOp<out_eT, T1, op_type>::is_col;
arma_aligned const Mat<out_eT> Q; arma_aligned const Mat<out_eT> Q;
inline explicit Proxy(const mtOp<out_eT, T1, op_type>& A) inline explicit Proxy(const mtOp<out_eT, T1, op_type>& A)
: Q(A) : Q(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 857 skipping to change at line 878
public: public:
typedef out_eT elem_type; typedef out_eT elem_type;
typedef typename get_pod_type<out_eT>::result pod_type; typedef typename get_pod_type<out_eT>::result pod_type;
typedef Mat<out_eT> stored_type; typedef Mat<out_eT> stored_type;
typedef const elem_type* ea_type; typedef const elem_type* ea_type;
static const bool prefer_at_accessor = false; static const bool prefer_at_accessor = false;
static const bool has_subview = false; static const bool has_subview = false;
static const bool is_fixed = false; static const bool is_fixed = false;
static const bool fake_mat = false;
static const bool is_row = mtGlue<out_eT, T1, T2, glue_type>::is_row; static const bool is_row = mtGlue<out_eT, T1, T2, glue_type>::is_row;
static const bool is_col = mtGlue<out_eT, T1, T2, glue_type>::is_col; static const bool is_col = mtGlue<out_eT, T1, T2, glue_type>::is_col;
arma_aligned const Mat<out_eT> Q; arma_aligned const Mat<out_eT> Q;
inline explicit Proxy(const mtGlue<out_eT, T1, T2, glue_type>& A) inline explicit Proxy(const mtGlue<out_eT, T1, T2, glue_type>& A)
: Q(A) : Q(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
 End of changes. 22 change blocks. 
0 lines changed or deleted 22 lines changed or added


 Row_bones.hpp   Row_bones.hpp 
skipping to change at line 115 skipping to change at line 115
template<uword fixed_n_elem> template<uword fixed_n_elem>
class fixed : public Row<eT> class fixed : public Row<eT>
{ {
private: private:
static const bool use_extra = (fixed_n_elem > arma_config::mat_prealloc ); static const bool use_extra = (fixed_n_elem > arma_config::mat_prealloc );
arma_aligned eT mem_local_extra[ (use_extra) ? fixed_n_elem : 1 ]; arma_aligned eT mem_local_extra[ (use_extra) ? fixed_n_elem : 1 ];
arma_inline void mem_setup();
public: public:
typedef fixed<fixed_n_elem> Row_fixed_type; typedef fixed<fixed_n_elem> Row_fixed_type;
typedef eT elem_type; typedef eT elem_type;
typedef typename get_pod_type<eT>::result pod_type; typedef typename get_pod_type<eT>::result pod_type;
static const bool is_col = false; static const bool is_col = false;
static const bool is_row = true; static const bool is_row = true;
skipping to change at line 177 skipping to change at line 175
arma_inline arma_warn_unused eT operator() (const uword in_row, const uword in_col) const; arma_inline arma_warn_unused eT operator() (const uword in_row, const uword in_col) const;
arma_inline arma_warn_unused eT* memptr(); arma_inline arma_warn_unused eT* memptr();
arma_inline arma_warn_unused const eT* memptr() const; arma_inline arma_warn_unused const eT* memptr() const;
arma_hot inline const Row<eT>& fill(const eT val); arma_hot inline const Row<eT>& fill(const eT val);
arma_hot inline const Row<eT>& zeros(); arma_hot inline const Row<eT>& zeros();
arma_hot inline const Row<eT>& ones(); arma_hot inline const Row<eT>& ones();
}; };
protected:
inline Row(const arma_fixed_indicator&, const uword in_n_elem, const eT*
in_mem);
public:
#ifdef ARMA_EXTRA_ROW_PROTO #ifdef ARMA_EXTRA_ROW_PROTO
#include ARMA_INCFILE_WRAP(ARMA_EXTRA_ROW_PROTO) #include ARMA_INCFILE_WRAP(ARMA_EXTRA_ROW_PROTO)
#endif #endif
}; };
//! @} //! @}
 End of changes. 3 change blocks. 
3 lines changed or deleted 7 lines changed or added


 Row_meat.hpp   Row_meat.hpp 
skipping to change at line 607 skipping to change at line 607
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_debug_check( (row_num >= Mat<eT>::n_rows), "end_row(): index out of bounds"); arma_debug_check( (row_num >= Mat<eT>::n_rows), "end_row(): index out of bounds");
return Mat<eT>::memptr() + Mat<eT>::n_cols; return Mat<eT>::memptr() + Mat<eT>::n_cols;
} }
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
arma_inline
void
Row<eT>::fixed<fixed_n_elem>::mem_setup()
{
arma_extra_debug_sigprint();
access::rw(Mat<eT>::n_rows) = 1;
access::rw(Mat<eT>::n_cols) = fixed_n_elem;
access::rw(Mat<eT>::n_elem) = fixed_n_elem;
access::rw(Mat<eT>::vec_state) = 2;
access::rw(Mat<eT>::mem_state) = 3;
access::rw(Mat<eT>::mem) = (use_extra) ? mem_local_extra : Mat<eT>:
:mem_local;
}
template<typename eT>
template<uword fixed_n_elem>
inline inline
Row<eT>::fixed<fixed_n_elem>::fixed() Row<eT>::fixed<fixed_n_elem>::fixed()
: Row<eT>( arma_fixed_indicator(), fixed_n_elem, ((use_extra) ? mem_local _extra : Mat<eT>::mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
} }
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
arma_inline arma_inline
Row<eT>::fixed<fixed_n_elem>::fixed(const fixed<fixed_n_elem>& X) Row<eT>::fixed<fixed_n_elem>::fixed(const fixed<fixed_n_elem>& X)
: Row<eT>( arma_fixed_indicator(), fixed_n_elem, ((use_extra) ? mem_local _extra : Mat<eT>::mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
eT* dest = (use_extra) ? mem_local_extra : Mat<eT>::mem_local; eT* dest = (use_extra) ? mem_local_extra : Mat<eT>::mem_local;
arrayops::copy( dest, X.mem, fixed_n_elem ); arrayops::copy( dest, X.mem, fixed_n_elem );
} }
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
arma_inline arma_inline
Row<eT>::fixed<fixed_n_elem>::fixed(const subview_cube<eT>& X) Row<eT>::fixed<fixed_n_elem>::fixed(const subview_cube<eT>& X)
: Row<eT>( arma_fixed_indicator(), fixed_n_elem, ((use_extra) ? mem_local _extra : Mat<eT>::mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
Row<eT>::operator=(X); Row<eT>::operator=(X);
} }
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
template<typename T1> template<typename T1>
arma_inline arma_inline
Row<eT>::fixed<fixed_n_elem>::fixed(const Base<eT,T1>& A) Row<eT>::fixed<fixed_n_elem>::fixed(const Base<eT,T1>& A)
: Row<eT>( arma_fixed_indicator(), fixed_n_elem, ((use_extra) ? mem_local _extra : Mat<eT>::mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
Row<eT>::operator=(A.get_ref()); Row<eT>::operator=(A.get_ref());
} }
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
template<typename T1, typename T2> template<typename T1, typename T2>
arma_inline arma_inline
Row<eT>::fixed<fixed_n_elem>::fixed(const Base<pod_type,T1>& A, const Base< pod_type,T2>& B) Row<eT>::fixed<fixed_n_elem>::fixed(const Base<pod_type,T1>& A, const Base< pod_type,T2>& B)
: Row<eT>( arma_fixed_indicator(), fixed_n_elem, ((use_extra) ? mem_local _extra : Mat<eT>::mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
Row<eT>::init(A,B); Row<eT>::init(A,B);
} }
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
inline inline
Row<eT>::fixed<fixed_n_elem>::fixed(const eT* aux_mem) Row<eT>::fixed<fixed_n_elem>::fixed(const eT* aux_mem)
: Row<eT>( arma_fixed_indicator(), fixed_n_elem, ((use_extra) ? mem_local _extra : Mat<eT>::mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup(); eT* dest = (use_extra) ? mem_local_extra : Mat<eT>::mem_local;
arrayops::copy( const_cast<eT*>(Mat<eT>::mem), aux_mem, fixed_n_elem ); arrayops::copy( dest, aux_mem, fixed_n_elem );
} }
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
inline inline
Row<eT>::fixed<fixed_n_elem>::fixed(const char* text) Row<eT>::fixed<fixed_n_elem>::fixed(const char* text)
: Row<eT>( arma_fixed_indicator(), fixed_n_elem, ((use_extra) ? mem_local _extra : Mat<eT>::mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
Row<eT>::operator=(text); Row<eT>::operator=(text);
} }
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
inline inline
Row<eT>::fixed<fixed_n_elem>::fixed(const std::string& text) Row<eT>::fixed<fixed_n_elem>::fixed(const std::string& text)
: Row<eT>( arma_fixed_indicator(), fixed_n_elem, ((use_extra) ? mem_local _extra : Mat<eT>::mem_local) )
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
mem_setup();
Row<eT>::operator=(text); Row<eT>::operator=(text);
} }
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
template<typename T1> template<typename T1>
const Row<eT>& const Row<eT>&
Row<eT>::fixed<fixed_n_elem>::operator=(const Base<eT,T1>& A) Row<eT>::fixed<fixed_n_elem>::operator=(const Base<eT,T1>& A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 786 skipping to change at line 764
return *this; return *this;
} }
#if defined(ARMA_USE_CXX11) #if defined(ARMA_USE_CXX11)
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
inline inline
Row<eT>::fixed<fixed_n_elem>::fixed(const std::initializer_list<eT>& list) Row<eT>::fixed<fixed_n_elem>::fixed(const std::initializer_list<eT>& list)
: Row<eT>( arma_fixed_indicator(), fixed_n_elem, ((use_extra) ? mem_local _extra : Mat<eT>::mem_local) )
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint_this(this);
mem_setup();
(*this).operator=(list); (*this).operator=(list);
} }
template<typename eT> template<typename eT>
template<uword fixed_n_elem> template<uword fixed_n_elem>
inline inline
const Row<eT>& const Row<eT>&
Row<eT>::fixed<fixed_n_elem>::operator=(const std::initializer_list<eT>& li st) Row<eT>::fixed<fixed_n_elem>::operator=(const std::initializer_list<eT>& li st)
{ {
skipping to change at line 993 skipping to change at line 970
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
eT* mem_use = (use_extra) ? &(mem_local_extra[0]) : &(Mat<eT>::mem_local[ 0]); eT* mem_use = (use_extra) ? &(mem_local_extra[0]) : &(Mat<eT>::mem_local[ 0]);
arrayops::inplace_set_fixed<eT,fixed_n_elem>( mem_use, eT(1) ); arrayops::inplace_set_fixed<eT,fixed_n_elem>( mem_use, eT(1) );
return *this; return *this;
} }
template<typename eT>
inline
Row<eT>::Row(const arma_fixed_indicator&, const uword in_n_elem, const eT*
in_mem)
: Mat<eT>(arma_fixed_indicator(), 1, in_n_elem, 2, in_mem)
{
arma_extra_debug_sigprint_this(this);
}
#ifdef ARMA_EXTRA_ROW_MEAT #ifdef ARMA_EXTRA_ROW_MEAT
#include ARMA_INCFILE_WRAP(ARMA_EXTRA_ROW_MEAT) #include ARMA_INCFILE_WRAP(ARMA_EXTRA_ROW_MEAT)
#endif #endif
//! @} //! @}
 End of changes. 21 change blocks. 
36 lines changed or deleted 21 lines changed or added


 arma_version.hpp   arma_version.hpp 
skipping to change at line 18 skipping to change at line 18
// Lesser General Public License (LGPL) as published // Lesser General Public License (LGPL) as published
// by the Free Software Foundation, either version 3 // by the Free Software Foundation, either version 3
// of the License or (at your option) any later version. // of the License or (at your option) any later version.
// (see http://www.opensource.org/licenses for more info) // (see http://www.opensource.org/licenses for more info)
//! \addtogroup arma_version //! \addtogroup arma_version
//! @{ //! @{
#define ARMA_VERSION_MAJOR 3 #define ARMA_VERSION_MAJOR 3
#define ARMA_VERSION_MINOR 1 #define ARMA_VERSION_MINOR 1
#define ARMA_VERSION_PATCH 91 #define ARMA_VERSION_PATCH 92
#define ARMA_VERSION_NAME "v3.2 beta 1" #define ARMA_VERSION_NAME "v3.2 beta 2"
struct arma_version struct arma_version
{ {
static const unsigned int major = ARMA_VERSION_MAJOR; static const unsigned int major = ARMA_VERSION_MAJOR;
static const unsigned int minor = ARMA_VERSION_MINOR; static const unsigned int minor = ARMA_VERSION_MINOR;
static const unsigned int patch = ARMA_VERSION_PATCH; static const unsigned int patch = ARMA_VERSION_PATCH;
static static
inline inline
std::string std::string
 End of changes. 1 change blocks. 
2 lines changed or deleted 2 lines changed or added


 config.hpp   config.hpp 
skipping to change at line 72 skipping to change at line 72
#define ARMA_USE_ATLAS #define ARMA_USE_ATLAS
#define ARMA_ATLAS_INCLUDE_DIR /usr/include/ #define ARMA_ATLAS_INCLUDE_DIR /usr/include/
//// If you're using ATLAS and the compiler can't find cblas.h and/or clapa ck.h //// If you're using ATLAS and the compiler can't find cblas.h and/or clapa ck.h
//// uncomment the above define and specify the appropriate include directo ry. //// uncomment the above define and specify the appropriate include directo ry.
//// Make sure the directory has a trailing / //// Make sure the directory has a trailing /
#define ARMA_USE_BOOST #define ARMA_USE_BOOST
#define ARMA_USE_BOOST_DATE #define ARMA_USE_BOOST_DATE
#define ARMA_USE_WRAPPER #define ARMA_USE_WRAPPER
/* #undef ARMA_USE_HDF5 */
#if !defined(ARMA_DEFAULT_OSTREAM) #if !defined(ARMA_DEFAULT_OSTREAM)
#define ARMA_DEFAULT_OSTREAM std::cout #define ARMA_DEFAULT_OSTREAM std::cout
#endif #endif
#define ARMA_PRINT_LOGIC_ERRORS #define ARMA_PRINT_LOGIC_ERRORS
#define ARMA_PRINT_RUNTIME_ERRORS #define ARMA_PRINT_RUNTIME_ERRORS
#define ARMA_HAVE_STD_ISFINITE #define ARMA_HAVE_STD_ISFINITE
#define ARMA_HAVE_STD_ISINF #define ARMA_HAVE_STD_ISINF
 End of changes. 1 change blocks. 
0 lines changed or deleted 1 lines changed or added


 debug.hpp   debug.hpp 
skipping to change at line 390 skipping to change at line 390
<< 1 << 'x' << A.n_rows << 'x' << A.n_cols << 1 << 'x' << A.n_rows << 'x' << A.n_cols
<< " is incompatible with cube dimensions: " << " is incompatible with cube dimensions: "
<< Q.n_rows << 'x' << Q.n_cols << 'x' << Q.n_slices; << Q.n_rows << 'x' << Q.n_cols << 'x' << Q.n_slices;
return tmp.str(); return tmp.str();
} }
// //
// functions for checking whether two matrices have the same dimensions // functions for checking whether two matrices have the same dimensions
inline arma_inline
void
arma_hot arma_hot
void
arma_assert_same_size(const uword A_n_rows, const uword A_n_cols, const uwo rd B_n_rows, const uword B_n_cols, const char* x) arma_assert_same_size(const uword A_n_rows, const uword A_n_cols, const uwo rd B_n_rows, const uword B_n_cols, const char* x)
{ {
if( (A_n_rows != B_n_rows) || (A_n_cols != B_n_cols) ) if( (A_n_rows != B_n_rows) || (A_n_cols != B_n_cols) )
{ {
arma_stop( arma_incompat_size_string(A_n_rows, A_n_cols, B_n_rows, B_n_ cols, x) ); arma_stop( arma_incompat_size_string(A_n_rows, A_n_cols, B_n_rows, B_n_ cols, x) );
} }
} }
//! stop if given matrices have different sizes //! stop if given matrices have different sizes
template<typename eT1, typename eT2> template<typename eT1, typename eT2>
 End of changes. 2 change blocks. 
2 lines changed or deleted 2 lines changed or added


 eGlue_bones.hpp   eGlue_bones.hpp 
skipping to change at line 29 skipping to change at line 29
public: public:
typedef typename T1::elem_type elem_type; typedef typename T1::elem_type elem_type;
typedef typename get_pod_type<elem_type>::result pod_type; typedef typename get_pod_type<elem_type>::result pod_type;
typedef Proxy<T1> proxy1_type; typedef Proxy<T1> proxy1_type;
typedef Proxy<T2> proxy2_type; typedef Proxy<T2> proxy2_type;
static const bool prefer_at_accessor = (Proxy<T1>::prefer_at_accessor || Proxy<T2>::prefer_at_accessor); static const bool prefer_at_accessor = (Proxy<T1>::prefer_at_accessor || Proxy<T2>::prefer_at_accessor);
static const bool has_subview = (Proxy<T1>::has_subview || Proxy<T2>::has_subview ); static const bool has_subview = (Proxy<T1>::has_subview || Proxy<T2>::has_subview );
static const bool is_fixed = (Proxy<T1>::is_fixed || Proxy<T2>::is_fixed ); static const bool is_fixed = (Proxy<T1>::is_fixed || Proxy<T2>::is_fixed );
static const bool fake_mat = (Proxy<T1>::fake_mat || Proxy<T2>::fake_mat );
static const bool is_col = (Proxy<T1>::is_col || Proxy<T2>::is_col); static const bool is_col = (Proxy<T1>::is_col || Proxy<T2>::is_col);
static const bool is_row = (Proxy<T1>::is_row || Proxy<T2>::is_row); static const bool is_row = (Proxy<T1>::is_row || Proxy<T2>::is_row);
arma_aligned const Proxy<T1> P1; arma_aligned const Proxy<T1> P1;
arma_aligned const Proxy<T2> P2; arma_aligned const Proxy<T2> P2;
arma_inline ~eGlue(); arma_inline ~eGlue();
arma_inline eGlue(const T1& in_A, const T2& in_B); arma_inline eGlue(const T1& in_A, const T2& in_B);
 End of changes. 1 change blocks. 
0 lines changed or deleted 1 lines changed or added


 eOp_bones.hpp   eOp_bones.hpp 
skipping to change at line 28 skipping to change at line 28
{ {
public: public:
typedef typename T1::elem_type elem_type; typedef typename T1::elem_type elem_type;
typedef typename get_pod_type<elem_type>::result pod_type; typedef typename get_pod_type<elem_type>::result pod_type;
typedef Proxy<T1> proxy_type; typedef Proxy<T1> proxy_type;
static const bool prefer_at_accessor = Proxy<T1>::prefer_at_accessor; static const bool prefer_at_accessor = Proxy<T1>::prefer_at_accessor;
static const bool has_subview = Proxy<T1>::has_subview; static const bool has_subview = Proxy<T1>::has_subview;
static const bool is_fixed = Proxy<T1>::is_fixed; static const bool is_fixed = Proxy<T1>::is_fixed;
static const bool fake_mat = Proxy<T1>::fake_mat;
static const bool is_row = Proxy<T1>::is_row; static const bool is_row = Proxy<T1>::is_row;
static const bool is_col = Proxy<T1>::is_col; static const bool is_col = Proxy<T1>::is_col;
arma_aligned const Proxy<T1> P; arma_aligned const Proxy<T1> P;
arma_aligned elem_type aux; //!< storage of auxiliary data , user defined format arma_aligned elem_type aux; //!< storage of auxiliary data , user defined format
arma_aligned uword aux_uword_a; //!< storage of auxiliary data , uword format arma_aligned uword aux_uword_a; //!< storage of auxiliary data , uword format
arma_aligned uword aux_uword_b; //!< storage of auxiliary data , uword format arma_aligned uword aux_uword_b; //!< storage of auxiliary data , uword format
 End of changes. 1 change blocks. 
0 lines changed or deleted 1 lines changed or added


 eglue_core_bones.hpp   eglue_core_bones.hpp 
// Copyright (C) 2010 NICTA (www.nicta.com.au) // Copyright (C) 2010-2012 NICTA (www.nicta.com.au)
// Copyright (C) 2010 Conrad Sanderson // Copyright (C) 2010-2012 Conrad Sanderson
// //
// This file is part of the Armadillo C++ library. // This file is part of the Armadillo C++ library.
// It is provided without any warranty of fitness // It is provided without any warranty of fitness
// for any purpose. You can redistribute this file // for any purpose. You can redistribute this file
// and/or modify it under the terms of the GNU // and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published // Lesser General Public License (LGPL) as published
// by the Free Software Foundation, either version 3 // by the Free Software Foundation, either version 3
// of the License or (at your option) any later version. // of the License or (at your option) any later version.
// (see http://www.opensource.org/licenses for more info) // (see http://www.opensource.org/licenses for more info)
skipping to change at line 39 skipping to change at line 39
// cubes // cubes
template<typename T1, typename T2> arma_hot inline static void apply(Cube <typename T1::elem_type>& out, const eGlueCube<T1, T2, eglue_type>& x); template<typename T1, typename T2> arma_hot inline static void apply(Cube <typename T1::elem_type>& out, const eGlueCube<T1, T2, eglue_type>& x);
template<typename T1, typename T2> arma_hot inline static void apply_inpl ace_plus (Cube<typename T1::elem_type>& out, const eGlueCube<T1, T2, eglue_ type>& x); template<typename T1, typename T2> arma_hot inline static void apply_inpl ace_plus (Cube<typename T1::elem_type>& out, const eGlueCube<T1, T2, eglue_ type>& x);
template<typename T1, typename T2> arma_hot inline static void apply_inpl ace_minus(Cube<typename T1::elem_type>& out, const eGlueCube<T1, T2, eglue_ type>& x); template<typename T1, typename T2> arma_hot inline static void apply_inpl ace_minus(Cube<typename T1::elem_type>& out, const eGlueCube<T1, T2, eglue_ type>& x);
template<typename T1, typename T2> arma_hot inline static void apply_inpl ace_schur(Cube<typename T1::elem_type>& out, const eGlueCube<T1, T2, eglue_ type>& x); template<typename T1, typename T2> arma_hot inline static void apply_inpl ace_schur(Cube<typename T1::elem_type>& out, const eGlueCube<T1, T2, eglue_ type>& x);
template<typename T1, typename T2> arma_hot inline static void apply_inpl ace_div (Cube<typename T1::elem_type>& out, const eGlueCube<T1, T2, eglue_ type>& x); template<typename T1, typename T2> arma_hot inline static void apply_inpl ace_div (Cube<typename T1::elem_type>& out, const eGlueCube<T1, T2, eglue_ type>& x);
}; };
class eglue_plus; class eglue_plus : public eglue_core<eglue_plus>
class eglue_minus; {
class eglue_div; public:
class eglue_schur;
inline static const char* text() { return "addition"; }
};
class eglue_minus : public eglue_core<eglue_minus>
{
public:
inline static const char* text() { return "subtraction"; }
};
class eglue_div : public eglue_core<eglue_div>
{
public:
inline static const char* text() { return "element-wise division"; }
};
class eglue_schur : public eglue_core<eglue_schur>
{
public:
inline static const char* text() { return "element-wise multiplication";
}
};
//! @} //! @}
 End of changes. 2 change blocks. 
6 lines changed or deleted 30 lines changed or added


 eglue_core_meat.hpp   eglue_core_meat.hpp 
skipping to change at line 16 skipping to change at line 16
// for any purpose. You can redistribute this file // for any purpose. You can redistribute this file
// and/or modify it under the terms of the GNU // and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published // Lesser General Public License (LGPL) as published
// by the Free Software Foundation, either version 3 // by the Free Software Foundation, either version 3
// of the License or (at your option) any later version. // of the License or (at your option) any later version.
// (see http://www.opensource.org/licenses for more info) // (see http://www.opensource.org/licenses for more info)
//! \addtogroup eglue_core //! \addtogroup eglue_core
//! @{ //! @{
class eglue_plus : public eglue_core<eglue_plus>
{
public:
inline static const char* text() { return "addition"; }
};
class eglue_minus : public eglue_core<eglue_minus>
{
public:
inline static const char* text() { return "subtraction"; }
};
class eglue_div : public eglue_core<eglue_div>
{
public:
inline static const char* text() { return "element-wise division"; }
};
class eglue_schur : public eglue_core<eglue_schur>
{
public:
inline static const char* text() { return "element-wise multiplication";
}
};
#undef arma_applier_1 #undef arma_applier_1
#undef arma_applier_2 #undef arma_applier_2
#undef arma_applier_3 #undef arma_applier_3
#undef operatorA #undef operatorA
#undef operatorB #undef operatorB
#define arma_applier_1(operatorA, operatorB) \ #define arma_applier_1(operatorA, operatorB) \
{\ {\
uword i,j;\ uword i,j;\
\ \
 End of changes. 1 change blocks. 
29 lines changed or deleted 0 lines changed or added


 fn_strans.hpp   fn_strans.hpp 
skipping to change at line 33 skipping to change at line 33
const typename arma_cx_only<typename T1::elem_type>::result* junk2 = 0 const typename arma_cx_only<typename T1::elem_type>::result* junk2 = 0
) )
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_ignore(junk1); arma_ignore(junk1);
arma_ignore(junk2); arma_ignore(junk2);
return Op<T1, op_strans>(X.get_ref()); return Op<T1, op_strans>(X.get_ref());
} }
// NOTE: deliberately returning op_htrans instead of op_strans,
// NOTE: due to currently more optimisations available when using op_htrans
, especially by glue_times
template<typename T1> template<typename T1>
arma_inline arma_inline
const Op<T1, op_htrans> const Op<T1, op_htrans>
strans strans
( (
const Base<typename T1::elem_type,T1>& X, const Base<typename T1::elem_type,T1>& X,
const typename enable_if<is_basevec<T1>::value == false>::result* junk1 = 0, const typename enable_if<is_basevec<T1>::value == false>::result* junk1 = 0,
const typename arma_not_cx<typename T1::elem_type>::result* junk2 = 0 const typename arma_not_cx<typename T1::elem_type>::result* junk2 = 0
) )
{ {
skipping to change at line 67 skipping to change at line 69
const typename arma_cx_only<typename T1::elem_type>::result* junk2 = 0 const typename arma_cx_only<typename T1::elem_type>::result* junk2 = 0
) )
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_ignore(junk1); arma_ignore(junk1);
arma_ignore(junk2); arma_ignore(junk2);
return Op<T1, op_strans>(X); return Op<T1, op_strans>(X);
} }
// NOTE: deliberately returning op_htrans instead of op_strans,
// NOTE: due to currently more optimisations available when using op_htrans
, especially by glue_times
template<typename T1> template<typename T1>
arma_inline arma_inline
const Op<T1, op_htrans> const Op<T1, op_htrans>
strans strans
( (
const T1& X, const T1& X,
const typename enable_if<is_basevec<T1>::value == true>::result* junk1 = 0, const typename enable_if<is_basevec<T1>::value == true>::result* junk1 = 0,
const typename arma_not_cx<typename T1::elem_type>::result* junk2 = 0 const typename arma_not_cx<typename T1::elem_type>::result* junk2 = 0
) )
{ {
 End of changes. 2 change blocks. 
0 lines changed or deleted 6 lines changed or added


 forward_bones.hpp   forward_bones.hpp 
skipping to change at line 128 skipping to change at line 128
template< typename T1, typename eop_type> class eOpCube; template< typename T1, typename eop_type> class eOpCube;
template<typename out_eT, typename T1, typename op_type> class mtOpCube; template<typename out_eT, typename T1, typename op_type> class mtOpCube;
template< typename T1, typename T2, typename glue_type> cl ass GlueCube; template< typename T1, typename T2, typename glue_type> cl ass GlueCube;
template< typename T1, typename T2, typename eglue_type> cl ass eGlueCube; template< typename T1, typename T2, typename eglue_type> cl ass eGlueCube;
template<typename out_eT, typename T1, typename T2, typename glue_type> cl ass mtGlueCube; template<typename out_eT, typename T1, typename T2, typename glue_type> cl ass mtGlueCube;
template<typename T1> class Proxy; template<typename T1> class Proxy;
template<typename T1> class ProxyCube; template<typename T1> class ProxyCube;
struct arma_vec_indicator {}; struct arma_vec_indicator {};
struct arma_fixed_indicator {};
//! \addtogroup injector //! \addtogroup injector
//! @{ //! @{
template<typename Dummy = int> struct injector_end_of_row {}; template<typename Dummy = int> struct injector_end_of_row {};
static const injector_end_of_row<> endr = injector_end_of_row<>(); static const injector_end_of_row<> endr = injector_end_of_row<>();
//!< endr indicates "end of row" when using the << operator; //!< endr indicates "end of row" when using the << operator;
//!< similar conceptual meaning to std::endl //!< similar conceptual meaning to std::endl
 End of changes. 1 change blocks. 
1 lines changed or deleted 2 lines changed or added


 op_htrans_bones.hpp   op_htrans_bones.hpp 
skipping to change at line 39 skipping to change at line 39
template<typename eT> template<typename eT>
arma_hot arma_inline static void apply(Mat<eT>& out, const Mat<eT>& A, co nst typename arma_not_cx<eT>::result* junk = 0); arma_hot arma_inline static void apply(Mat<eT>& out, const Mat<eT>& A, co nst typename arma_not_cx<eT>::result* junk = 0);
template<typename eT> template<typename eT>
arma_hot inline static void apply(Mat<eT>& out, const Mat<eT>& A, const t ypename arma_cx_only<eT>::result* junk = 0); arma_hot inline static void apply(Mat<eT>& out, const Mat<eT>& A, const t ypename arma_cx_only<eT>::result* junk = 0);
// //
template<typename T1> template<typename T1>
arma_hot inline static void apply(Mat<typename T1::elem_type>& out, const arma_hot inline static void apply_proxy(Mat<typename T1::elem_type>& out,
Op<T1,op_htrans>& in); const T1& X);
//
template<typename T1>
arma_hot inline static void apply(Mat<typename T1::elem_type>& out, const
Op<T1,op_htrans>& in, const typename arma_not_cx<typename T1::elem_type>::
result* junk = 0);
template<typename T1>
arma_hot inline static void apply(Mat<typename T1::elem_type>& out, const
Op<T1,op_htrans>& in, const typename arma_cx_only<typename T1::elem_type>:
:result* junk = 0);
//
template<typename T1> template<typename T1>
arma_hot inline static void apply(Mat<typename T1::elem_type>& out, const Op< Op<T1, op_trimat>, op_htrans>& in); arma_hot inline static void apply(Mat<typename T1::elem_type>& out, const Op< Op<T1, op_trimat>, op_htrans>& in);
}; };
class op_htrans2 class op_htrans2
{ {
public: public:
template<typename eT> template<typename eT>
arma_hot arma_inline static void apply(Mat<eT>& out, const Mat<eT>& A, co nst eT val, const typename arma_not_cx<eT>::result* junk = 0); arma_hot inline static void apply_noalias(Mat<eT>& out, const Mat<eT>& A, const eT val);
template<typename eT> template<typename eT>
arma_hot inline static void apply(Mat<eT>& out, const Mat<eT>& A, const e arma_hot inline static void apply(Mat<eT>& out, const Mat<eT>& A, const e
T val, const typename arma_cx_only<eT>::result* junk = 0); T val);
//
template<typename T1>
arma_hot inline static void apply_proxy(Mat<typename T1::elem_type>& out,
const T1& X, const typename T1::elem_type val);
//
template<typename T1>
arma_hot inline static void apply(Mat<typename T1::elem_type>& out, const
Op<T1,op_htrans2>& in, const typename arma_not_cx<typename T1::elem_type>:
:result* junk = 0);
template<typename T1> template<typename T1>
arma_hot inline static void apply(Mat<typename T1::elem_type>& out, const Op<T1,op_htrans2>& in); arma_hot inline static void apply(Mat<typename T1::elem_type>& out, const Op<T1,op_htrans2>& in, const typename arma_cx_only<typename T1::elem_type> ::result* junk = 0);
}; };
//! @} //! @}
 End of changes. 4 change blocks. 
6 lines changed or deleted 33 lines changed or added


 op_htrans_meat.hpp   op_htrans_meat.hpp 
skipping to change at line 42 skipping to change at line 42
op_htrans::apply_noalias(Mat<eT>& out, const Mat<eT>& A, const typename arm a_cx_only<eT>::result* junk) op_htrans::apply_noalias(Mat<eT>& out, const Mat<eT>& A, const typename arm a_cx_only<eT>::result* junk)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_ignore(junk); arma_ignore(junk);
const uword A_n_rows = A.n_rows; const uword A_n_rows = A.n_rows;
const uword A_n_cols = A.n_cols; const uword A_n_cols = A.n_cols;
out.set_size(A_n_cols, A_n_rows); out.set_size(A_n_cols, A_n_rows);
for(uword in_row = 0; in_row < A_n_rows; ++in_row) if( (A_n_cols == 1) || (A_n_rows == 1) )
{ {
const uword out_col = in_row; const uword n_elem = A.n_elem;
for(uword in_col = 0; in_col < A_n_cols; ++in_col) const eT* A_mem = A.memptr();
eT* out_mem = out.memptr();
for(uword i=0; i < n_elem; ++i)
{ {
const uword out_row = in_col; out_mem[i] = std::conj(A_mem[i]);
out.at(out_row, out_col) = std::conj( A.at(in_row, in_col) );
} }
} }
else
{
for(uword in_row = 0; in_row < A_n_rows; ++in_row)
{
const uword out_col = in_row;
for(uword in_col = 0; in_col < A_n_cols; ++in_col)
{
const uword out_row = in_col;
out.at(out_row, out_col) = std::conj( A.at(in_row, in_col) );
}
}
}
} }
template<typename eT> template<typename eT>
arma_hot arma_hot
arma_inline arma_inline
void void
op_htrans::apply(Mat<eT>& out, const Mat<eT>& A, const typename arma_not_cx <eT>::result* junk) op_htrans::apply(Mat<eT>& out, const Mat<eT>& A, const typename arma_not_cx <eT>::result* junk)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_ignore(junk); arma_ignore(junk);
skipping to change at line 82 skipping to change at line 96
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_ignore(junk); arma_ignore(junk);
if(&out != &A) if(&out != &A)
{ {
op_htrans::apply_noalias(out, A); op_htrans::apply_noalias(out, A);
} }
else else
{ {
if(out.n_rows == out.n_cols) const uword n_rows = out.n_rows;
const uword n_cols = out.n_cols;
if(n_rows == n_cols)
{ {
arma_extra_debug_print("doing in-place hermitian transpose of a squar e matrix"); arma_extra_debug_print("doing in-place hermitian transpose of a squar e matrix");
const uword n_rows = out.n_rows; for(uword col=0; col < n_cols; ++col)
const uword n_cols = out.n_cols;
for(uword col=0; col<n_cols; ++col)
{ {
eT* coldata = out.colptr(col); eT* coldata = out.colptr(col);
out.at(col,col) = std::conj( out.at(col,col) ); out.at(col,col) = std::conj( out.at(col,col) );
for(uword row=(col+1); row<n_rows; ++row) for(uword row=(col+1); row < n_rows; ++row)
{ {
const eT val1 = std::conj(coldata[row]); const eT val1 = std::conj(coldata[row]);
const eT val2 = std::conj(out.at(col,row)); const eT val2 = std::conj(out.at(col,row));
out.at(col,row) = val1; out.at(col,row) = val1;
coldata[row] = val2; coldata[row] = val2;
} }
} }
} }
else else
skipping to change at line 120 skipping to change at line 134
out.steal_mem(tmp); out.steal_mem(tmp);
} }
} }
} }
template<typename T1> template<typename T1>
arma_hot arma_hot
inline inline
void void
op_htrans::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_htrans>& in) op_htrans::apply_proxy(Mat<typename T1::elem_type>& out, const T1& X)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
typedef typename T1::elem_type eT; typedef typename T1::elem_type eT;
const unwrap<T1> tmp(in.m); const Proxy<T1> P(X);
const Mat<eT>& A = tmp.M;
// allow detection of in-place transpose
if( (is_Mat<typename Proxy<T1>::stored_type>::value == true) && (Proxy<T1
>::fake_mat == false) )
{
const unwrap<typename Proxy<T1>::stored_type> tmp(P.Q);
op_htrans::apply(out, tmp.M);
}
else
{
const uword n_rows = P.get_n_rows();
const uword n_cols = P.get_n_cols();
const bool is_alias = P.is_alias(out);
if( (resolves_to_vector<T1>::value == true) && (Proxy<T1>::prefer_at_ac
cessor == false) )
{
if(is_alias == false)
{
out.set_size(n_cols, n_rows);
eT* out_mem = out.memptr();
const uword n_elem = P.get_n_elem();
typename Proxy<T1>::ea_type Pea = P.get_ea();
for(uword i=0; i < n_elem; ++i)
{
out_mem[i] = std::conj(Pea[i]);
}
}
else // aliasing
{
Mat<eT> out2(n_cols, n_rows);
eT* out_mem = out2.memptr();
const uword n_elem = P.get_n_elem();
typename Proxy<T1>::ea_type Pea = P.get_ea();
for(uword i=0; i < n_elem; ++i)
{
out_mem[i] = std::conj(Pea[i]);
}
out.steal_mem(out2);
}
}
else
{
if(is_alias == false)
{
out.set_size(n_cols, n_rows);
for(uword k=0; k < n_cols; ++k)
for(uword i=0; i < n_rows; ++i)
{
out.at(k,i) = std::conj(P.at(i,k));
}
}
else // aliasing
{
Mat<eT> out2(n_cols, n_rows);
op_htrans::apply(out, A); for(uword k=0; k < n_cols; ++k)
for(uword i=0; i < n_rows; ++i)
{
out2.at(k,i) = std::conj(P.at(i,k));
}
out.steal_mem(out2);
}
}
}
}
template<typename T1>
arma_hot
inline
void
op_htrans::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_htrans>&
in, const typename arma_not_cx<typename T1::elem_type>::result* junk)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
op_strans::apply_proxy(out, in.m);
}
template<typename T1>
arma_hot
inline
void
op_htrans::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_htrans>&
in, const typename arma_cx_only<typename T1::elem_type>::result* junk)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
op_htrans::apply_proxy(out, in.m);
} }
template<typename T1> template<typename T1>
arma_hot arma_hot
inline inline
void void
op_htrans::apply(Mat<typename T1::elem_type>& out, const Op< Op<T1, op_trim at>, op_htrans>& in) op_htrans::apply(Mat<typename T1::elem_type>& out, const Op< Op<T1, op_trim at>, op_htrans>& in)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 157 skipping to change at line 268
op_trimat::apply_htrans(out, A, upper); op_trimat::apply_htrans(out, A, upper);
} }
// //
// op_htrans2 // op_htrans2
template<typename eT> template<typename eT>
arma_hot arma_hot
arma_inline arma_inline
void void
op_htrans2::apply(Mat<eT>& out, const Mat<eT>& A, const eT val, const typen ame arma_not_cx<eT>::result* junk) op_htrans2::apply_noalias(Mat<eT>& out, const Mat<eT>& A, const eT val)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_ignore(junk);
op_strans2::apply(out, A, val); const uword A_n_rows = A.n_rows;
const uword A_n_cols = A.n_cols;
out.set_size(A_n_cols, A_n_rows);
if( (A_n_cols == 1) || (A_n_rows == 1) )
{
const uword n_elem = A.n_elem;
const eT* A_mem = A.memptr();
eT* out_mem = out.memptr();
for(uword i=0; i < n_elem; ++i)
{
out_mem[i] = val * std::conj(A_mem[i]);
}
}
else
{
for(uword in_row = 0; in_row < A_n_rows; ++in_row)
{
const uword out_col = in_row;
for(uword in_col = 0; in_col < A_n_cols; ++in_col)
{
const uword out_row = in_col;
out.at(out_row, out_col) = val * std::conj( A.at(in_row, in_col) );
}
}
}
} }
template<typename eT> template<typename eT>
arma_hot arma_hot
inline inline
void void
op_htrans2::apply(Mat<eT>& out, const Mat<eT>& A, const eT val, const typen ame arma_cx_only<eT>::result* junk) op_htrans2::apply(Mat<eT>& out, const Mat<eT>& A, const eT val)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_ignore(junk);
// TODO: replace with specialised implementation if(&out != &A)
{
op_htrans2::apply_noalias(out, A, val);
}
else
{
const uword n_rows = out.n_rows;
const uword n_cols = out.n_cols;
if(n_rows == n_cols)
{
arma_extra_debug_print("doing in-place hermitian transpose of a squar
e matrix");
// TODO: do multiplication while swapping
for(uword col=0; col < n_cols; ++col)
{
eT* coldata = out.colptr(col);
out.at(col,col) = std::conj( out.at(col,col) );
for(uword row=(col+1); row < n_rows; ++row)
{
const eT val1 = std::conj(coldata[row]);
const eT val2 = std::conj(out.at(col,row));
out.at(col,row) = val1;
coldata[row] = val2;
}
}
op_htrans::apply(out, A); arrayops::inplace_mul( out.memptr(), val, out.n_elem );
}
else
{
Mat<eT> tmp;
op_htrans2::apply_noalias(tmp, A, val);
arrayops::inplace_mul( out.memptr(), val, out.n_elem ); out.steal_mem(tmp);
}
}
} }
template<typename T1> template<typename T1>
arma_hot arma_hot
inline inline
void void
op_htrans2::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_htrans2> & in) op_htrans2::apply_proxy(Mat<typename T1::elem_type>& out, const T1& X, cons t typename T1::elem_type val)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
typedef typename T1::elem_type eT; typedef typename T1::elem_type eT;
const unwrap<T1> tmp(in.m); const Proxy<T1> P(X);
if(
(is_Mat<typename Proxy<T1>::stored_type>::value || is_Mat_fixed<typenam
e Proxy<T1>::stored_type>::value)
&&
(Proxy<T1>::fake_mat == false) // can't rely on simple alias checking
for matrices constructed out of auxiliary memory
)
{
const unwrap<typename Proxy<T1>::stored_type> tmp(P.Q); // need this u
nwrap to keep stupid compilers happy
op_htrans2::apply(out, tmp.M, val);
}
else
{
const uword n_rows = P.get_n_rows();
const uword n_cols = P.get_n_cols();
const bool is_alias = P.is_alias(out);
if( (resolves_to_vector<T1>::value == true) && (Proxy<T1>::prefer_at_ac
cessor == false) )
{
if(is_alias == false)
{
out.set_size(n_cols, n_rows);
eT* out_mem = out.memptr();
const uword n_elem = P.get_n_elem();
typename Proxy<T1>::ea_type Pea = P.get_ea();
for(uword i=0; i < n_elem; ++i)
{
out_mem[i] = val * std::conj(Pea[i]);
}
}
else // aliasing
{
Mat<eT> out2(n_cols, n_rows);
eT* out_mem = out2.memptr();
const uword n_elem = P.get_n_elem();
typename Proxy<T1>::ea_type Pea = P.get_ea();
for(uword i=0; i < n_elem; ++i)
{
out_mem[i] = val * std::conj(Pea[i]);
}
out.steal_mem(out2);
}
}
else
{
if(is_alias == false)
{
out.set_size(n_cols, n_rows);
for(uword k=0; k < n_cols; ++k)
for(uword i=0; i < n_rows; ++i)
{
out.at(k,i) = val * std::conj(P.at(i,k));
}
}
else // aliasing
{
Mat<eT> out2(n_cols, n_rows);
for(uword k=0; k < n_cols; ++k)
for(uword i=0; i < n_rows; ++i)
{
out2.at(k,i) = val * std::conj(P.at(i,k));
}
out.steal_mem(out2);
}
}
}
}
template<typename T1>
arma_hot
inline
void
op_htrans2::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_htrans2>
& in, const typename arma_not_cx<typename T1::elem_type>::result* junk)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
op_strans2::apply_proxy(out, in.m, in.aux);
}
template<typename T1>
arma_hot
inline
void
op_htrans2::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_htrans2>
& in, const typename arma_cx_only<typename T1::elem_type>::result* junk)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
op_htrans2::apply(out, tmp.M, in.aux); op_htrans2::apply_proxy(out, in.m, in.aux);
} }
//! @} //! @}
 End of changes. 23 change blocks. 
26 lines changed or deleted 312 lines changed or added


 op_strans_bones.hpp   op_strans_bones.hpp 
skipping to change at line 40 skipping to change at line 40
template<typename eT> template<typename eT>
arma_hot inline static void apply_noalias_tinysq(Mat<eT>& out, const Mat< eT>& A); arma_hot inline static void apply_noalias_tinysq(Mat<eT>& out, const Mat< eT>& A);
template<typename eT> template<typename eT>
arma_hot inline static void apply_noalias(Mat<eT>& out, const Mat<eT>& A) ; arma_hot inline static void apply_noalias(Mat<eT>& out, const Mat<eT>& A) ;
template<typename eT> template<typename eT>
arma_hot inline static void apply(Mat<eT>& out, const Mat<eT>& A); arma_hot inline static void apply(Mat<eT>& out, const Mat<eT>& A);
template<typename T1> template<typename T1>
arma_hot inline static void apply_proxy(Mat<typename T1::elem_type>& out,
const T1& X);
template<typename T1>
arma_hot inline static void apply(Mat<typename T1::elem_type>& out, const Op<T1,op_strans>& in); arma_hot inline static void apply(Mat<typename T1::elem_type>& out, const Op<T1,op_strans>& in);
}; };
class op_strans2 class op_strans2
{ {
public: public:
template<const bool do_flip, const uword row, const uword col> template<const bool do_flip, const uword row, const uword col>
struct pos struct pos
{ {
skipping to change at line 63 skipping to change at line 66
}; };
template<typename eT> template<typename eT>
arma_hot inline static void apply_noalias_tinysq(Mat<eT>& out, const Mat< eT>& A, const eT val); arma_hot inline static void apply_noalias_tinysq(Mat<eT>& out, const Mat< eT>& A, const eT val);
template<typename eT> template<typename eT>
arma_hot inline static void apply_noalias(Mat<eT>& out, const Mat<eT>& A, const eT val); arma_hot inline static void apply_noalias(Mat<eT>& out, const Mat<eT>& A, const eT val);
template<typename eT> template<typename eT>
arma_hot inline static void apply(Mat<eT>& out, const Mat<eT>& A, const e T val); arma_hot inline static void apply(Mat<eT>& out, const Mat<eT>& A, const e T val);
template<typename T1>
arma_hot inline static void apply_proxy(Mat<typename T1::elem_type>& out,
const T1& X, const typename T1::elem_type val);
}; };
//! @} //! @}
 End of changes. 2 change blocks. 
0 lines changed or deleted 8 lines changed or added


 op_strans_meat.hpp   op_strans_meat.hpp 
skipping to change at line 195 skipping to change at line 195
out.steal_mem(tmp); out.steal_mem(tmp);
} }
} }
} }
template<typename T1> template<typename T1>
arma_hot arma_hot
inline inline
void void
op_strans::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_strans>& in) op_strans::apply_proxy(Mat<typename T1::elem_type>& out, const T1& X)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
typedef typename T1::elem_type eT; typedef typename T1::elem_type eT;
const unwrap<T1> tmp(in.m); const Proxy<T1> P(X);
const Mat<eT>& A = tmp.M;
if(
(is_Mat<typename Proxy<T1>::stored_type>::value || is_Mat_fixed<typenam
e Proxy<T1>::stored_type>::value)
&&
(Proxy<T1>::fake_mat == false) // can't rely on simple alias checking
for matrices constructed out of auxiliary memory
)
{
const unwrap<typename Proxy<T1>::stored_type> tmp(P.Q); // need this u
nwrap to keep stupid compilers happy
op_strans::apply(out, tmp.M);
}
else
{
const uword n_rows = P.get_n_rows();
const uword n_cols = P.get_n_cols();
const bool is_alias = P.is_alias(out);
if( (resolves_to_vector<T1>::value == true) && (Proxy<T1>::prefer_at_ac
cessor == false) )
{
if(is_alias == false)
{
out.set_size(n_cols, n_rows);
eT* out_mem = out.memptr();
const uword n_elem = P.get_n_elem();
typename Proxy<T1>::ea_type Pea = P.get_ea();
uword i,j;
for(i=0, j=1; j < n_elem; i+=2, j+=2)
{
const eT tmp_i = Pea[i];
const eT tmp_j = Pea[j];
out_mem[i] = tmp_i;
out_mem[j] = tmp_j;
}
if(i < n_elem)
{
out_mem[i] = Pea[i];
}
}
else // aliasing
{
Mat<eT> out2(n_cols, n_rows);
eT* out_mem = out2.memptr();
const uword n_elem = P.get_n_elem();
typename Proxy<T1>::ea_type Pea = P.get_ea();
uword i,j;
for(i=0, j=1; j < n_elem; i+=2, j+=2)
{
const eT tmp_i = Pea[i];
const eT tmp_j = Pea[j];
out_mem[i] = tmp_i;
out_mem[j] = tmp_j;
}
if(i < n_elem)
{
out_mem[i] = Pea[i];
}
out.steal_mem(out2);
}
}
else // general matrix transpose
{
if(is_alias == false)
{
out.set_size(n_cols, n_rows);
for(uword k=0; k < n_cols; ++k)
{
uword i, j;
for(i=0, j=1; j < n_rows; i+=2, j+=2)
{
const eT tmp_i = P.at(i,k);
const eT tmp_j = P.at(j,k);
out.at(k,i) = tmp_i;
out.at(k,j) = tmp_j;
}
if(i < n_rows)
{
out.at(k,i) = P.at(i,k);
}
}
}
else // aliasing
{
Mat<eT> out2(n_cols, n_rows);
for(uword k=0; k < n_cols; ++k)
{
uword i, j;
for(i=0, j=1; j < n_rows; i+=2, j+=2)
{
const eT tmp_i = P.at(i,k);
const eT tmp_j = P.at(j,k);
out2.at(k,i) = tmp_i;
out2.at(k,j) = tmp_j;
}
if(i < n_rows)
{
out2.at(k,i) = P.at(i,k);
}
}
out.steal_mem(out2);
}
}
}
}
template<typename T1>
arma_hot
inline
void
op_strans::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_strans>&
in)
{
arma_extra_debug_sigprint();
op_strans::apply(out, A); op_strans::apply_proxy(out, in.m);
} }
// //
// op_strans2 // op_strans2
//! for tiny square matrices (size <= 4x4) //! for tiny square matrices (size <= 4x4)
template<typename eT> template<typename eT>
arma_hot arma_hot
inline inline
void void
skipping to change at line 284 skipping to change at line 417
outm[pos<false,3,3>::n4] = val * Am[pos<true,3,3>::n4]; outm[pos<false,3,3>::n4] = val * Am[pos<true,3,3>::n4];
} }
break; break;
default: default:
; ;
} }
} }
//! Immediate transpose of a dense matrix
template<typename eT> template<typename eT>
arma_hot arma_hot
inline inline
void void
op_strans2::apply_noalias(Mat<eT>& out, const Mat<eT>& A, const eT val) op_strans2::apply_noalias(Mat<eT>& out, const Mat<eT>& A, const eT val)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
const uword A_n_cols = A.n_cols; const uword A_n_cols = A.n_cols;
const uword A_n_rows = A.n_rows; const uword A_n_rows = A.n_rows;
skipping to change at line 407 skipping to change at line 539
else else
{ {
Mat<eT> tmp; Mat<eT> tmp;
op_strans2::apply_noalias(tmp, A, val); op_strans2::apply_noalias(tmp, A, val);
out.steal_mem(tmp); out.steal_mem(tmp);
} }
} }
} }
template<typename T1>
arma_hot
inline
void
op_strans2::apply_proxy(Mat<typename T1::elem_type>& out, const T1& X, cons
t typename T1::elem_type val)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT;
const Proxy<T1> P(X);
// allow detection of in-place transpose
if( (is_Mat<typename Proxy<T1>::stored_type>::value == true) && (Proxy<T1
>::fake_mat == false) )
{
const unwrap<typename Proxy<T1>::stored_type> tmp(P.Q);
op_strans2::apply(out, tmp.M, val);
}
else
{
const uword n_rows = P.get_n_rows();
const uword n_cols = P.get_n_cols();
const bool is_alias = P.is_alias(out);
if( (resolves_to_vector<T1>::value == true) && (Proxy<T1>::prefer_at_ac
cessor == false) )
{
if(is_alias == false)
{
out.set_size(n_cols, n_rows);
eT* out_mem = out.memptr();
const uword n_elem = P.get_n_elem();
typename Proxy<T1>::ea_type Pea = P.get_ea();
uword i,j;
for(i=0, j=1; j < n_elem; i+=2, j+=2)
{
const eT tmp_i = Pea[i];
const eT tmp_j = Pea[j];
out_mem[i] = val * tmp_i;
out_mem[j] = val * tmp_j;
}
if(i < n_elem)
{
out_mem[i] = val * Pea[i];
}
}
else // aliasing
{
Mat<eT> out2(n_cols, n_rows);
eT* out_mem = out2.memptr();
const uword n_elem = P.get_n_elem();
typename Proxy<T1>::ea_type Pea = P.get_ea();
uword i,j;
for(i=0, j=1; j < n_elem; i+=2, j+=2)
{
const eT tmp_i = Pea[i];
const eT tmp_j = Pea[j];
out_mem[i] = val * tmp_i;
out_mem[j] = val * tmp_j;
}
if(i < n_elem)
{
out_mem[i] = val * Pea[i];
}
out.steal_mem(out2);
}
}
else // general matrix transpose
{
if(is_alias == false)
{
out.set_size(n_cols, n_rows);
for(uword k=0; k < n_cols; ++k)
{
uword i, j;
for(i=0, j=1; j < n_rows; i+=2, j+=2)
{
const eT tmp_i = P.at(i,k);
const eT tmp_j = P.at(j,k);
out.at(k,i) = val * tmp_i;
out.at(k,j) = val * tmp_j;
}
if(i < n_rows)
{
out.at(k,i) = val * P.at(i,k);
}
}
}
else // aliasing
{
Mat<eT> out2(n_cols, n_rows);
for(uword k=0; k < n_cols; ++k)
{
uword i, j;
for(i=0, j=1; j < n_rows; i+=2, j+=2)
{
const eT tmp_i = P.at(i,k);
const eT tmp_j = P.at(j,k);
out2.at(k,i) = val * tmp_i;
out2.at(k,j) = val * tmp_j;
}
if(i < n_rows)
{
out2.at(k,i) = val * P.at(i,k);
}
}
out.steal_mem(out2);
}
}
}
}
//! @} //! @}
 End of changes. 5 change blocks. 
5 lines changed or deleted 280 lines changed or added


 op_unique_meat.hpp   op_unique_meat.hpp 
skipping to change at line 52 skipping to change at line 52
out[0] = tmp; out[0] = tmp;
} }
else else
{ {
out.set_size(in_n_rows, in_n_cols); out.set_size(in_n_rows, in_n_cols);
} }
return; return;
} }
std::vector<eT> vec(in_n_elem); std::vector<eT> lvec(in_n_elem);
if(Proxy<T1>::prefer_at_accessor == false) if(Proxy<T1>::prefer_at_accessor == false)
{ {
typename Proxy<T1>::ea_type Pea = P.get_ea(); typename Proxy<T1>::ea_type Pea = P.get_ea();
uword i,j; uword i,j;
for(i=0, j=1; j < in_n_elem; i+=2, j+=2) for(i=0, j=1; j < in_n_elem; i+=2, j+=2)
{ {
const eT tmp_i = Pea[i]; const eT tmp_i = Pea[i];
const eT tmp_j = Pea[j]; const eT tmp_j = Pea[j];
vec[i] = tmp_i; lvec[i] = tmp_i;
vec[j] = tmp_j; lvec[j] = tmp_j;
} }
if(i < in_n_elem) if(i < in_n_elem)
{ {
vec[i] = Pea[i]; lvec[i] = Pea[i];
} }
} }
else else
{ {
uword i = 0; uword i = 0;
for(uword col=0; col < in_n_cols; ++col) for(uword col=0; col < in_n_cols; ++col)
for(uword row=0; row < in_n_rows; ++row, ++i) for(uword row=0; row < in_n_rows; ++row, ++i)
{ {
vec[i] = P.at(row,col); lvec[i] = P.at(row,col);
} }
} }
std::sort( vec.begin(), vec.end() ); std::sort( lvec.begin(), lvec.end() );
uword N_unique = 1; uword N_unique = 1;
for(uword i=1; i < in_n_elem; ++i) for(uword i=1; i < in_n_elem; ++i)
{ {
const eT a = vec[i-1]; const eT a = lvec[i-1];
const eT b = vec[i ]; const eT b = lvec[i ];
const eT diff = a - b; const eT diff = a - b;
if(diff != eT(0)) { ++N_unique; } if(diff != eT(0)) { ++N_unique; }
} }
uword out_n_rows; uword out_n_rows;
uword out_n_cols; uword out_n_cols;
if( (in_n_rows == 1) || (in_n_cols == 1) ) if( (in_n_rows == 1) || (in_n_cols == 1) )
skipping to change at line 120 skipping to change at line 120
out_n_rows = N_unique; out_n_rows = N_unique;
out_n_cols = 1; out_n_cols = 1;
} }
} }
else else
{ {
out_n_rows = N_unique; out_n_rows = N_unique;
out_n_cols = 1; out_n_cols = 1;
} }
// we don't need to worry about aliasing at this stage, as all the data i s stored in vec // we don't need to worry about aliasing at this stage, as all the data i s stored in lvec
out.set_size(out_n_rows, out_n_cols); out.set_size(out_n_rows, out_n_cols);
eT* out_mem = out.memptr(); eT* out_mem = out.memptr();
if(in_n_elem > 0) { out_mem[0] = vec[0]; } if(in_n_elem > 0) { out_mem[0] = lvec[0]; }
N_unique = 1; N_unique = 1;
for(uword i=1; i < in_n_elem; ++i) for(uword i=1; i < in_n_elem; ++i)
{ {
const eT a = vec[i-1]; const eT a = lvec[i-1];
const eT b = vec[i ]; const eT b = lvec[i ];
const eT diff = a - b; const eT diff = a - b;
if(diff != eT(0)) if(diff != eT(0))
{ {
out_mem[N_unique] = b; out_mem[N_unique] = b;
++N_unique; ++N_unique;
} }
} }
 End of changes. 9 change blocks. 
12 lines changed or deleted 12 lines changed or added


 podarray_meat.hpp   podarray_meat.hpp 
skipping to change at line 29 skipping to change at line 29
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
if(n_elem > sizeof(mem_local)/sizeof(eT) ) if(n_elem > sizeof(mem_local)/sizeof(eT) )
{ {
memory::release( access::rw(mem) ); memory::release( access::rw(mem) );
} }
if(arma_config::debug == true) if(arma_config::debug == true)
{ {
access::rw(n_elem) = 0; access::rw(mem) = 0;
access::rw(mem) = 0;
} }
} }
template<typename eT> template<typename eT>
inline inline
podarray<eT>::podarray() podarray<eT>::podarray()
: n_elem(0) : n_elem(0)
, mem (0) , mem (0)
{ {
arma_extra_debug_sigprint_this(this); arma_extra_debug_sigprint_this(this);
 End of changes. 1 change blocks. 
2 lines changed or deleted 1 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/