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 2 #define ARMA_VERSION_MAJOR 2
#define ARMA_VERSION_MINOR 99 #define ARMA_VERSION_MINOR 99
#define ARMA_VERSION_PATCH 2 #define ARMA_VERSION_PATCH 3
#define ARMA_VERSION_NAME "Antarctic Chilli Ranch (Beta 2)" #define ARMA_VERSION_NAME "Antarctic Chilli Ranch (Beta 3)"
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


 glue_times_bones.hpp   glue_times_bones.hpp 
skipping to change at line 33 skipping to change at line 33
{ {
static const uword num = 0; static const uword num = 0;
}; };
template<typename glue_type, typename T1, typename T2> template<typename glue_type, typename T1, typename T2>
struct depth_lhs< glue_type, Glue<T1,T2,glue_type> > struct depth_lhs< glue_type, Glue<T1,T2,glue_type> >
{ {
static const uword num = 1 + depth_lhs<glue_type, T1>::num; static const uword num = 1 + depth_lhs<glue_type, T1>::num;
}; };
template<bool is_eT_blas_type>
struct glue_times_redirect2_helper
{
template<typename T1, typename T2>
arma_hot inline static void apply(Mat<typename T1::elem_type>& out, const
Glue<T1,T2,glue_times>& X);
};
template<>
struct glue_times_redirect2_helper<true>
{
template<typename T1, typename T2>
arma_hot inline static void apply(Mat<typename T1::elem_type>& out, const
Glue<T1,T2,glue_times>& X);
};
template<uword N> template<uword N>
struct glue_times_redirect struct glue_times_redirect
{ {
template<typename T1, typename T2> template<typename T1, typename T2>
arma_hot inline static void apply(Mat<typename T1::elem_type>& out, const Glue<T1,T2,glue_times>& X); arma_hot inline static void apply(Mat<typename T1::elem_type>& out, const Glue<T1,T2,glue_times>& X);
}; };
template<> template<>
struct glue_times_redirect<2> struct glue_times_redirect<2>
{ {
template<typename T1, typename T2> template<typename T1, typename T2>
arma_hot inline static void apply(Mat<typename T1::elem_type>& out, const arma_hot inline static void apply(Mat<typename T1::elem_type>& out, const
Glue<T1,T2,glue_times>& X, const typename arma_blas_type_only<typename T1: Glue<T1,T2,glue_times>& X);
:elem_type>::result* junk = 0);
template<typename T1, typename T2>
arma_hot inline static void apply(Mat<typename T1::elem_type>& out, const
Glue<T1,T2,glue_times>& X, const typename arma_not_blas_type<typename T1::
elem_type>::result* junk = 0);
}; };
template<> template<>
struct glue_times_redirect<3> struct glue_times_redirect<3>
{ {
template<typename T1, typename T2, typename T3> template<typename T1, typename T2, typename T3>
arma_hot inline static void apply(Mat<typename T1::elem_type>& out, const Glue< Glue<T1,T2,glue_times>,T3,glue_times>& X); arma_hot inline static void apply(Mat<typename T1::elem_type>& out, const Glue< Glue<T1,T2,glue_times>,T3,glue_times>& X);
}; };
template<> template<>
 End of changes. 2 change blocks. 
8 lines changed or deleted 18 lines changed or added


 glue_times_meat.hpp   glue_times_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 glue_times //! \addtogroup glue_times
//! @{ //! @{
template<uword N> template<bool is_eT_blas_type>
template<typename T1, typename T2> template<typename T1, typename T2>
arma_hot arma_hot
inline inline
void void
glue_times_redirect<N>::apply(Mat<typename T1::elem_type>& out, const Glue< T1,T2,glue_times>& X) glue_times_redirect2_helper<is_eT_blas_type>::apply(Mat<typename T1::elem_t ype>& out, const Glue<T1,T2,glue_times>& X)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
typedef typename T1::elem_type eT; typedef typename T1::elem_type eT;
const partial_unwrap_check<T1> tmp1(X.A, out); const partial_unwrap_check<T1> tmp1(X.A, out);
const partial_unwrap_check<T2> tmp2(X.B, out); const partial_unwrap_check<T2> tmp2(X.B, out);
const Mat<eT>& A = tmp1.M; const Mat<eT>& A = tmp1.M;
const Mat<eT>& B = tmp2.M; const Mat<eT>& B = tmp2.M;
skipping to change at line 50 skipping to change at line 50
partial_unwrap_check<T2>::do_trans, partial_unwrap_check<T2>::do_trans,
(partial_unwrap_check<T1>::do_times || partial_unwrap_check<T2>::do_tim es) (partial_unwrap_check<T1>::do_times || partial_unwrap_check<T2>::do_tim es)
> >
(out, A, B, alpha); (out, A, B, alpha);
} }
template<typename T1, typename T2> template<typename T1, typename T2>
arma_hot arma_hot
inline inline
void void
glue_times_redirect<2>::apply(Mat<typename T1::elem_type>& out, const Glue< T1,T2,glue_times>& X, const typename arma_blas_type_only<typename T1::elem_ type>::result* junk) glue_times_redirect2_helper<true>::apply(Mat<typename T1::elem_type>& out, const Glue<T1,T2,glue_times>& X)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_ignore(junk);
typedef typename T1::elem_type eT; typedef typename T1::elem_type eT;
if(strip_inv<T1>::do_inv == false) if(strip_inv<T1>::do_inv == false)
{ {
const partial_unwrap_check<T1> tmp1(X.A, out); const partial_unwrap_check<T1> tmp1(X.A, out);
const partial_unwrap_check<T2> tmp2(X.B, out); const partial_unwrap_check<T2> tmp2(X.B, out);
const Mat<eT>& A = tmp1.M; const Mat<eT>& A = tmp1.M;
const Mat<eT>& B = tmp2.M; const Mat<eT>& B = tmp2.M;
skipping to change at line 96 skipping to change at line 95
arma_debug_check( (A.is_square() == false), "inv(): given matrix is not square" ); arma_debug_check( (A.is_square() == false), "inv(): given matrix is not square" );
const unwrap_check<T2> B_tmp(X.B, out); const unwrap_check<T2> B_tmp(X.B, out);
const Mat<eT>& B = B_tmp.M; const Mat<eT>& B = B_tmp.M;
glue_solve::solve_direct( out, A, B, A_strip.slow ); glue_solve::solve_direct( out, A, B, A_strip.slow );
} }
} }
template<uword N>
template<typename T1, typename T2> template<typename T1, typename T2>
arma_hot arma_hot
inline inline
void void
glue_times_redirect<2>::apply(Mat<typename T1::elem_type>& out, const Glue< T1,T2,glue_times>& X, const typename arma_not_blas_type<typename T1::elem_t ype>::result* junk) glue_times_redirect<N>::apply(Mat<typename T1::elem_type>& out, const Glue< T1,T2,glue_times>& X)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_ignore(junk);
typedef typename T1::elem_type eT; typedef typename T1::elem_type eT;
const partial_unwrap_check<T1> tmp1(X.A, out); const partial_unwrap_check<T1> tmp1(X.A, out);
const partial_unwrap_check<T2> tmp2(X.B, out); const partial_unwrap_check<T2> tmp2(X.B, out);
const Mat<eT>& A = tmp1.M; const Mat<eT>& A = tmp1.M;
const Mat<eT>& B = tmp2.M; const Mat<eT>& B = tmp2.M;
const bool use_alpha = partial_unwrap_check<T1>::do_times || partial_unwr ap_check<T2>::do_times; const bool use_alpha = partial_unwrap_check<T1>::do_times || partial_unwr ap_check<T2>::do_times;
skipping to change at line 126 skipping to change at line 125
glue_times::apply glue_times::apply
< <
eT, eT,
partial_unwrap_check<T1>::do_trans, partial_unwrap_check<T1>::do_trans,
partial_unwrap_check<T2>::do_trans, partial_unwrap_check<T2>::do_trans,
(partial_unwrap_check<T1>::do_times || partial_unwrap_check<T2>::do_tim es) (partial_unwrap_check<T1>::do_times || partial_unwrap_check<T2>::do_tim es)
> >
(out, A, B, alpha); (out, A, B, alpha);
} }
template<typename T1, typename T2>
arma_hot
inline
void
glue_times_redirect<2>::apply(Mat<typename T1::elem_type>& out, const Glue<
T1,T2,glue_times>& X)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT;
glue_times_redirect2_helper< is_supported_blas_type<eT>::value >::apply(o
ut, X);
}
template<typename T1, typename T2, typename T3> template<typename T1, typename T2, typename T3>
arma_hot arma_hot
inline inline
void void
glue_times_redirect<3>::apply(Mat<typename T1::elem_type>& out, const Glue< Glue<T1,T2,glue_times>, T3, glue_times>& X) glue_times_redirect<3>::apply(Mat<typename T1::elem_type>& out, const Glue< Glue<T1,T2,glue_times>, T3, glue_times>& X)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
typedef typename T1::elem_type eT; typedef typename T1::elem_type eT;
 End of changes. 8 change blocks. 
6 lines changed or deleted 20 lines changed or added


 op_dot_bones.hpp   op_dot_bones.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 24 skipping to change at line 24
//! @{ //! @{
//! \brief //! \brief
//! dot product operation //! dot product operation
class op_dot class op_dot
{ {
public: public:
template<typename eT> template<typename eT>
arma_hot arma_pure inline static eT direct_dot_arma(const uword n_elem, c onst eT* const A, const eT* const B); arma_hot arma_pure arma_inline static eT direct_dot_arma(const uword n_el em, const eT* const A, const eT* const B);
template<typename eT> template<typename eT>
arma_hot arma_pure inline static typename arma_float_only<eT>::result arma_hot arma_pure inline static typename arma_float_only<eT>::result
direct_dot(const uword n_elem, const eT* const A, const eT* const B); direct_dot(const uword n_elem, const eT* const A, const eT* const B);
template<typename eT> template<typename eT>
arma_hot arma_pure inline static typename arma_cx_only<eT>::result arma_hot arma_pure inline static typename arma_cx_only<eT>::result
direct_dot(const uword n_elem, const eT* const A, const eT* const B); direct_dot(const uword n_elem, const eT* const A, const eT* const B);
template<typename eT> template<typename eT>
 End of changes. 2 change blocks. 
3 lines changed or deleted 3 lines changed or added


 op_dot_meat.hpp   op_dot_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)
//! \addtogroup op_dot //! \addtogroup op_dot
//! @{ //! @{
//! for two arrays, generic version //! for two arrays, generic version
template<typename eT> template<typename eT>
arma_hot arma_hot
arma_pure arma_pure
inline arma_inline
eT eT
op_dot::direct_dot_arma(const uword n_elem, const eT* const A, const eT* co nst B) op_dot::direct_dot_arma(const uword n_elem, const eT* const A, const eT* co nst B)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
eT val1 = eT(0); eT val1 = eT(0);
eT val2 = eT(0); eT val2 = eT(0);
uword i, j; uword i, j;
 End of changes. 2 change blocks. 
3 lines changed or deleted 3 lines changed or added


 op_repmat_meat.hpp   op_repmat_meat.hpp 
// Copyright (C) 2009-2011 NICTA (www.nicta.com.au) // Copyright (C) 2009-2012 NICTA (www.nicta.com.au)
// Copyright (C) 2009-2011 Conrad Sanderson // Copyright (C) 2009-2012 Conrad Sanderson
// Copyright (C) 2009-2010 Dimitrios Bouzas // Copyright (C) 2009-2010 Dimitrios Bouzas
// //
// 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 42 skipping to change at line 42
const uword copies_per_col = in.aux_uword_b; const uword copies_per_col = in.aux_uword_b;
const uword X_n_rows = X.n_rows; const uword X_n_rows = X.n_rows;
const uword X_n_cols = X.n_cols; const uword X_n_cols = X.n_cols;
out.set_size(X_n_rows * copies_per_row, X_n_cols * copies_per_col); out.set_size(X_n_rows * copies_per_row, X_n_cols * copies_per_col);
const uword out_n_rows = out.n_rows; const uword out_n_rows = out.n_rows;
const uword out_n_cols = out.n_cols; const uword out_n_cols = out.n_cols;
// if( (out_n_rows > 0) && (out_n_cols > 0) )
// {
// for(uword col = 0; col < out_n_cols; col += X_n_cols)
// for(uword row = 0; row < out_n_rows; row += X_n_rows)
// {
// out.submat(row, col, row+X_n_rows-1, col+X_n_cols-1) = X;
// }
// }
if( (out_n_rows > 0) && (out_n_cols > 0) ) if( (out_n_rows > 0) && (out_n_cols > 0) )
{ {
for(uword col = 0; col < out_n_cols; col += X_n_cols) if(copies_per_row != 1)
{ {
for(uword row = 0; row < out_n_rows; row += X_n_rows) for(uword col_copy=0; col_copy < copies_per_col; ++col_copy)
{ {
out.submat(row, col, row+X_n_rows-1, col+X_n_cols-1) = X; const uword out_col_offset = X_n_cols * col_copy;
for(uword col=0; col < X_n_cols; ++col)
{
eT* out_colptr = out.colptr(col + out_col_offset);
const eT* X_colptr = X.colptr(col);
for(uword row_copy=0; row_copy < copies_per_row; ++row_copy)
{
const uword out_row_offset = X_n_rows * row_copy;
arrayops::copy( &out_colptr[out_row_offset], X_colptr, X_n_rows
);
}
}
}
}
else
{
for(uword col_copy=0; col_copy < copies_per_col; ++col_copy)
{
const uword out_col_offset = X_n_cols * col_copy;
for(uword col=0; col < X_n_cols; ++col)
{
eT* out_colptr = out.colptr(col + out_col_offset);
const eT* X_colptr = X.colptr(col);
arrayops::copy( out_colptr, X_colptr, X_n_rows );
}
} }
} }
} }
} }
//! @} //! @}
 End of changes. 6 change blocks. 
5 lines changed or deleted 44 lines changed or added


 strip.hpp   strip.hpp 
skipping to change at line 21 skipping to change at line 21
// (see http://www.opensource.org/licenses for more info) // (see http://www.opensource.org/licenses for more info)
//! \addtogroup strip //! \addtogroup strip
//! @{ //! @{
template<typename T1> template<typename T1>
struct strip_diagmat struct strip_diagmat
{ {
typedef T1 stored_type; typedef T1 stored_type;
inline strip_diagmat(const T1& X) arma_hot inline
strip_diagmat(const T1& X)
: M(X) : M(X)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
static const bool do_diagmat = false; static const bool do_diagmat = false;
const T1& M; const T1& M;
}; };
template<typename T1> template<typename T1>
struct strip_diagmat< Op<T1, op_diagmat> > struct strip_diagmat< Op<T1, op_diagmat> >
{ {
typedef T1 stored_type; typedef T1 stored_type;
inline strip_diagmat(const Op<T1, op_diagmat>& X) arma_hot inline
strip_diagmat(const Op<T1, op_diagmat>& X)
: M(X.m) : M(X.m)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
static const bool do_diagmat = true; static const bool do_diagmat = true;
const T1& M; const T1& M;
}; };
template<typename T1> template<typename T1>
struct strip_inv struct strip_inv
{ {
typedef T1 stored_type; typedef T1 stored_type;
inline strip_inv(const T1& X) arma_hot inline
strip_inv(const T1& X)
: M(X) : M(X)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
const T1& M; const T1& M;
static const bool slow = false; static const bool slow = false;
static const bool do_inv = false; static const bool do_inv = false;
}; };
template<typename T1> template<typename T1>
struct strip_inv< Op<T1, op_inv> > struct strip_inv< Op<T1, op_inv> >
{ {
typedef T1 stored_type; typedef T1 stored_type;
inline strip_inv(const Op<T1, op_inv>& X) arma_hot inline
strip_inv(const Op<T1, op_inv>& X)
: M(X.m) : M(X.m)
, slow(X.aux_uword_a == 1) , slow(X.aux_uword_a == 1)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
const T1& M; const T1& M;
const bool slow; const bool slow;
static const bool do_inv = true; static const bool do_inv = true;
 End of changes. 4 change blocks. 
4 lines changed or deleted 8 lines changed or added


 subview_bones.hpp   subview_bones.hpp 
skipping to change at line 89 skipping to change at line 89
inline eT& operator()(const uword i); inline eT& operator()(const uword i);
inline eT operator()(const uword i) const; inline eT operator()(const uword i) const;
inline eT& operator()(const uword in_row, const uword in_col); inline eT& operator()(const uword in_row, const uword in_col);
inline eT operator()(const uword in_row, const uword in_col) const; inline eT operator()(const uword in_row, const uword in_col) const;
inline eT& at(const uword in_row, const uword in_col); inline eT& at(const uword in_row, const uword in_col);
inline eT at(const uword in_row, const uword in_col) const; inline eT at(const uword in_row, const uword in_col) const;
inline eT& at_slow(const uword in_row, const uword in_col);
inline eT at_slow(const uword in_row, const uword in_col) const;
arma_inline eT* colptr(const uword in_col); arma_inline eT* colptr(const uword in_col);
arma_inline const eT* colptr(const uword in_col) const; arma_inline const eT* colptr(const uword in_col) const;
inline bool check_overlap(const subview& x) const; inline bool check_overlap(const subview& x) const;
inline bool is_vec() const; inline bool is_vec() const;
inline subview_row<eT> row(const uword row_num); inline subview_row<eT> row(const uword row_num);
inline const subview_row<eT> row(const uword row_num) const; inline const subview_row<eT> row(const uword row_num) const;
 End of changes. 1 change blocks. 
3 lines changed or deleted 0 lines changed or added


 subview_meat.hpp   subview_meat.hpp 
skipping to change at line 1217 skipping to change at line 1217
inline inline
eT eT
subview<eT>::at(const uword in_row, const uword in_col) const subview<eT>::at(const uword in_row, const uword in_col) const
{ {
const uword index = (in_col + aux_col1)*m.n_rows + aux_row1 + in_row; const uword index = (in_col + aux_col1)*m.n_rows + aux_row1 + in_row;
return m.mem[index]; return m.mem[index];
} }
template<typename eT> template<typename eT>
inline
eT&
subview<eT>::at_slow(const uword in_row, const uword in_col)
{
const uword index = (in_col + aux_col1)*m.n_rows + aux_row1 + in_row;
return access::rw( (const_cast< Mat<eT>& >(m)).mem[index] );
}
template<typename eT>
inline
eT
subview<eT>::at_slow(const uword in_row, const uword in_col) const
{
const uword index = (in_col + aux_col1)*m.n_rows + aux_row1 + in_row;
return m.mem[index];
}
template<typename eT>
arma_inline arma_inline
eT* eT*
subview<eT>::colptr(const uword in_col) subview<eT>::colptr(const uword in_col)
{ {
return & access::rw((const_cast< Mat<eT>& >(m)).mem[ (in_col + aux_col1)* m.n_rows + aux_row1 ]); return & access::rw((const_cast< Mat<eT>& >(m)).mem[ (in_col + aux_col1)* m.n_rows + aux_row1 ]);
} }
template<typename eT> template<typename eT>
arma_inline arma_inline
const eT* const eT*
 End of changes. 1 change blocks. 
20 lines changed or deleted 0 lines changed or added


 unwrap.hpp   unwrap.hpp 
skipping to change at line 114 skipping to change at line 114
// //
template<typename T1> template<typename T1>
class unwrap_check class unwrap_check
{ {
public: public:
typedef typename T1::elem_type eT; typedef typename T1::elem_type eT;
inline inline
unwrap_check(const T1& A, const Mat<eT>& B) unwrap_check(const T1& A, const Mat<eT>&)
: M(A) : M(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_ignore(B);
} }
inline inline
~unwrap_check() ~unwrap_check()
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
const Mat<eT> M; const Mat<eT> M;
}; };
skipping to change at line 231 skipping to change at line 230
template<typename T1> template<typename T1>
class unwrap_check_mixed class unwrap_check_mixed
{ {
public: public:
typedef typename T1::elem_type eT1; typedef typename T1::elem_type eT1;
template<typename eT2> template<typename eT2>
inline inline
unwrap_check_mixed(const T1& A, const Mat<eT2>& B) unwrap_check_mixed(const T1& A, const Mat<eT2>&)
: M(A) : M(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_ignore(B);
} }
inline inline
~unwrap_check_mixed() ~unwrap_check_mixed()
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
const Mat<eT1> M; const Mat<eT1> M;
}; };
skipping to change at line 787 skipping to change at line 785
// //
template<typename T1> template<typename T1>
class partial_unwrap_check class partial_unwrap_check
{ {
public: public:
typedef typename T1::elem_type eT; typedef typename T1::elem_type eT;
inline partial_unwrap_check(const T1& A, const Mat<eT>& B) arma_hot inline
partial_unwrap_check(const T1& A, const Mat<eT>&)
: M(A) : M(A)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_ignore(B);
} }
inline inline
~partial_unwrap_check() ~partial_unwrap_check()
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
inline eT get_val() const { return eT(1); } arma_hot arma_inline eT get_val() const { return eT(1); }
static const bool do_trans = false; static const bool do_trans = false;
static const bool do_times = false; static const bool do_times = false;
const Mat<eT> M; const Mat<eT> M;
}; };
template<typename eT> template<typename eT>
class partial_unwrap_check< Mat<eT> > class partial_unwrap_check< Mat<eT> >
{ {
public: public:
inline arma_hot inline
partial_unwrap_check(const Mat<eT>& A, const Mat<eT>& B) partial_unwrap_check(const Mat<eT>& A, const Mat<eT>& B)
: M_local ( (&A == &B) ? new Mat<eT>(A) : 0 ) : M_local ( (&A == &B) ? new Mat<eT>(A) : 0 )
, M ( (&A == &B) ? (*M_local) : A ) , M ( (&A == &B) ? (*M_local) : A )
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
inline inline
~partial_unwrap_check() ~partial_unwrap_check()
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
if(M_local) if(M_local)
{ {
delete M_local; delete M_local;
} }
} }
inline eT get_val() const { return eT(1); } arma_hot arma_inline eT get_val() const { return eT(1); }
static const bool do_trans = false; static const bool do_trans = false;
static const bool do_times = false; static const bool do_times = false;
// the order below is important // the order below is important
const Mat<eT>* M_local; const Mat<eT>* M_local;
const Mat<eT>& M; const Mat<eT>& M;
}; };
template<typename eT> template<typename eT>
class partial_unwrap_check< Row<eT> > class partial_unwrap_check< Row<eT> >
{ {
public: public:
inline arma_hot inline
partial_unwrap_check(const Row<eT>& A, const Mat<eT>& B) partial_unwrap_check(const Row<eT>& A, const Mat<eT>& B)
: M_local ( (&A == &B) ? new Mat<eT>(A) : 0 ) : M_local ( (&A == &B) ? new Mat<eT>(A) : 0 )
, M ( (&A == &B) ? (*M_local) : A ) , M ( (&A == &B) ? (*M_local) : A )
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
inline inline
~partial_unwrap_check() ~partial_unwrap_check()
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
if(M_local) if(M_local)
{ {
delete M_local; delete M_local;
} }
} }
inline eT get_val() const { return eT(1); } arma_hot arma_inline eT get_val() const { return eT(1); }
static const bool do_trans = false; static const bool do_trans = false;
static const bool do_times = false; static const bool do_times = false;
// the order below is important // the order below is important
const Mat<eT>* M_local; const Mat<eT>* M_local;
const Mat<eT>& M; const Mat<eT>& M;
}; };
template<typename eT> template<typename eT>
class partial_unwrap_check< Col<eT> > class partial_unwrap_check< Col<eT> >
{ {
public: public:
inline arma_hot inline
partial_unwrap_check(const Col<eT>& A, const Mat<eT>& B) partial_unwrap_check(const Col<eT>& A, const Mat<eT>& B)
: M_local ( (&A == &B) ? new Mat<eT>(A) : 0 ) : M_local ( (&A == &B) ? new Mat<eT>(A) : 0 )
, M ( (&A == &B) ? (*M_local) : A ) , M ( (&A == &B) ? (*M_local) : A )
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
inline inline
~partial_unwrap_check() ~partial_unwrap_check()
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
if(M_local) if(M_local)
{ {
delete M_local; delete M_local;
} }
} }
inline eT get_val() const { return eT(1); } arma_hot arma_inline eT get_val() const { return eT(1); }
static const bool do_trans = false; static const bool do_trans = false;
static const bool do_times = false; static const bool do_times = false;
// the order below is important // the order below is important
const Mat<eT>* M_local; const Mat<eT>* M_local;
const Mat<eT>& M; const Mat<eT>& M;
}; };
template<typename T1> template<typename T1>
class partial_unwrap_check< Op<T1, op_htrans> > class partial_unwrap_check< Op<T1, op_htrans> >
{ {
public: public:
typedef typename T1::elem_type eT; typedef typename T1::elem_type eT;
inline arma_hot inline
partial_unwrap_check(const Op<T1,op_htrans>& A, const Mat<eT>& B) partial_unwrap_check(const Op<T1,op_htrans>& A, const Mat<eT>&)
: M(A.m) : M(A.m)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_ignore(B);
} }
inline inline
~partial_unwrap_check() ~partial_unwrap_check()
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
inline eT get_val() const { return eT(1); } arma_hot arma_inline eT get_val() const { return eT(1); }
static const bool do_trans = true; static const bool do_trans = true;
static const bool do_times = false; static const bool do_times = false;
const Mat<eT> M; const Mat<eT> M;
}; };
template<typename eT> template<typename eT>
class partial_unwrap_check< Op< Mat<eT>, op_htrans> > class partial_unwrap_check< Op< Mat<eT>, op_htrans> >
{ {
public: public:
inline arma_hot inline
partial_unwrap_check(const Op< Mat<eT>, op_htrans>& A, const Mat<eT>& B) partial_unwrap_check(const Op< Mat<eT>, op_htrans>& A, const Mat<eT>& B)
: M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 ) : M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 )
, M ( (&A.m == &B) ? (*M_local) : A.m ) , M ( (&A.m == &B) ? (*M_local) : A.m )
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
inline inline
~partial_unwrap_check() ~partial_unwrap_check()
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
if(M_local) if(M_local)
{ {
delete M_local; delete M_local;
} }
} }
inline eT get_val() const { return eT(1); } arma_hot arma_inline eT get_val() const { return eT(1); }
static const bool do_trans = true; static const bool do_trans = true;
static const bool do_times = false; static const bool do_times = false;
// the order below is important // the order below is important
const Mat<eT>* M_local; const Mat<eT>* M_local;
const Mat<eT>& M; const Mat<eT>& M;
}; };
template<typename eT> template<typename eT>
class partial_unwrap_check< Op< Row<eT>, op_htrans> > class partial_unwrap_check< Op< Row<eT>, op_htrans> >
{ {
public: public:
inline arma_hot inline
partial_unwrap_check(const Op< Row<eT>, op_htrans>& A, const Mat<eT>& B) partial_unwrap_check(const Op< Row<eT>, op_htrans>& A, const Mat<eT>& B)
: M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 ) : M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 )
, M ( (&A.m == &B) ? (*M_local) : A.m ) , M ( (&A.m == &B) ? (*M_local) : A.m )
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
inline inline
~partial_unwrap_check() ~partial_unwrap_check()
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
if(M_local) if(M_local)
{ {
delete M_local; delete M_local;
} }
} }
inline eT get_val() const { return eT(1); } arma_hot arma_inline eT get_val() const { return eT(1); }
static const bool do_trans = true; static const bool do_trans = true;
static const bool do_times = false; static const bool do_times = false;
// the order below is important // the order below is important
const Mat<eT>* M_local; const Mat<eT>* M_local;
const Mat<eT>& M; const Mat<eT>& M;
}; };
template<typename eT> template<typename eT>
class partial_unwrap_check< Op< Col<eT>, op_htrans> > class partial_unwrap_check< Op< Col<eT>, op_htrans> >
{ {
public: public:
inline arma_hot inline
partial_unwrap_check(const Op< Col<eT>, op_htrans>& A, const Mat<eT>& B) partial_unwrap_check(const Op< Col<eT>, op_htrans>& A, const Mat<eT>& B)
: M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 ) : M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 )
, M ( (&A.m == &B) ? (*M_local) : A.m ) , M ( (&A.m == &B) ? (*M_local) : A.m )
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
inline inline
~partial_unwrap_check() ~partial_unwrap_check()
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
if(M_local) if(M_local)
{ {
delete M_local; delete M_local;
} }
} }
inline eT get_val() const { return eT(1); } arma_hot arma_inline eT get_val() const { return eT(1); }
static const bool do_trans = true; static const bool do_trans = true;
static const bool do_times = false; static const bool do_times = false;
// the order below is important // the order below is important
const Mat<eT>* M_local; const Mat<eT>* M_local;
const Mat<eT>& M; const Mat<eT>& M;
}; };
template<typename T1> template<typename T1>
class partial_unwrap_check< Op<T1, op_htrans2> > class partial_unwrap_check< Op<T1, op_htrans2> >
{ {
public: public:
typedef typename T1::elem_type eT; typedef typename T1::elem_type eT;
inline arma_hot inline
partial_unwrap_check(const Op<T1,op_htrans2>& A, const Mat<eT>&) partial_unwrap_check(const Op<T1,op_htrans2>& A, const Mat<eT>&)
: val(A.aux) : val(A.aux)
, M (A.m) , M (A.m)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
inline inline
~partial_unwrap_check() ~partial_unwrap_check()
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
inline eT get_val() const { return val; } arma_hot arma_inline eT get_val() const { return val; }
static const bool do_trans = true; static const bool do_trans = true;
static const bool do_times = true; static const bool do_times = true;
const eT val; const eT val;
const Mat<eT> M; const Mat<eT> M;
}; };
template<typename eT> template<typename eT>
class partial_unwrap_check< Op< Mat<eT>, op_htrans2> > class partial_unwrap_check< Op< Mat<eT>, op_htrans2> >
{ {
public: public:
inline arma_hot inline
partial_unwrap_check(const Op< Mat<eT>, op_htrans2>& A, const Mat<eT>& B) partial_unwrap_check(const Op< Mat<eT>, op_htrans2>& A, const Mat<eT>& B)
: val (A.aux) : val (A.aux)
, M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 ) , M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 )
, M ( (&A.m == &B) ? (*M_local) : A.m ) , M ( (&A.m == &B) ? (*M_local) : A.m )
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
inline inline
~partial_unwrap_check() ~partial_unwrap_check()
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
if(M_local) if(M_local)
{ {
delete M_local; delete M_local;
} }
} }
inline eT get_val() const { return val; } arma_hot arma_inline eT get_val() const { return val; }
static const bool do_trans = true; static const bool do_trans = true;
static const bool do_times = true; static const bool do_times = true;
// the order below is important // the order below is important
const eT val; const eT val;
const Mat<eT>* M_local; const Mat<eT>* M_local;
const Mat<eT>& M; const Mat<eT>& M;
}; };
template<typename eT> template<typename eT>
class partial_unwrap_check< Op< Row<eT>, op_htrans2> > class partial_unwrap_check< Op< Row<eT>, op_htrans2> >
{ {
public: public:
inline arma_hot inline
partial_unwrap_check(const Op< Row<eT>, op_htrans2>& A, const Mat<eT>& B) partial_unwrap_check(const Op< Row<eT>, op_htrans2>& A, const Mat<eT>& B)
: val (A.aux) : val (A.aux)
, M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 ) , M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 )
, M ( (&A.m == &B) ? (*M_local) : A.m ) , M ( (&A.m == &B) ? (*M_local) : A.m )
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
inline inline
~partial_unwrap_check() ~partial_unwrap_check()
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
if(M_local) if(M_local)
{ {
delete M_local; delete M_local;
} }
} }
inline eT get_val() const { return val; } arma_hot arma_inline eT get_val() const { return val; }
static const bool do_trans = true; static const bool do_trans = true;
static const bool do_times = true; static const bool do_times = true;
// the order below is important // the order below is important
const eT val; const eT val;
const Mat<eT>* M_local; const Mat<eT>* M_local;
const Mat<eT>& M; const Mat<eT>& M;
}; };
template<typename eT> template<typename eT>
class partial_unwrap_check< Op< Col<eT>, op_htrans2> > class partial_unwrap_check< Op< Col<eT>, op_htrans2> >
{ {
public: public:
inline arma_hot inline
partial_unwrap_check(const Op< Mat<eT>, op_htrans2>& A, const Mat<eT>& B) partial_unwrap_check(const Op< Mat<eT>, op_htrans2>& A, const Mat<eT>& B)
: val (A.aux) : val (A.aux)
, M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 ) , M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 )
, M ( (&A.m == &B) ? (*M_local) : A.m ) , M ( (&A.m == &B) ? (*M_local) : A.m )
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
inline inline
~partial_unwrap_check() ~partial_unwrap_check()
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
if(M_local) if(M_local)
{ {
delete M_local; delete M_local;
} }
} }
inline eT get_val() const { return val; } arma_hot arma_inline eT get_val() const { return val; }
static const bool do_trans = true; static const bool do_trans = true;
static const bool do_times = true; static const bool do_times = true;
// the order below is important // the order below is important
const eT val; const eT val;
const Mat<eT>* M_local; const Mat<eT>* M_local;
const Mat<eT>& M; const Mat<eT>& M;
}; };
template<typename T1> template<typename T1>
class partial_unwrap_check< eOp<T1, eop_scalar_times> > class partial_unwrap_check< eOp<T1, eop_scalar_times> >
{ {
public: public:
typedef typename T1::elem_type eT; typedef typename T1::elem_type eT;
inline arma_hot inline
partial_unwrap_check(const eOp<T1,eop_scalar_times>& A, const Mat<eT>& B) partial_unwrap_check(const eOp<T1,eop_scalar_times>& A, const Mat<eT>&)
: val(A.aux) : val(A.aux)
, M (A.P.Q) , M (A.P.Q)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_ignore(B);
} }
inline inline
~partial_unwrap_check() ~partial_unwrap_check()
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
inline eT get_val() const { return val; } arma_hot arma_inline eT get_val() const { return val; }
static const bool do_trans = false; static const bool do_trans = false;
static const bool do_times = true; static const bool do_times = true;
const eT val; const eT val;
const Mat<eT> M; const Mat<eT> M;
}; };
template<typename eT> template<typename eT>
class partial_unwrap_check< eOp<Mat<eT>, eop_scalar_times> > class partial_unwrap_check< eOp<Mat<eT>, eop_scalar_times> >
{ {
public: public:
inline arma_hot inline
partial_unwrap_check(const eOp<Mat<eT>,eop_scalar_times>& A, const Mat<eT partial_unwrap_check(const eOp<Mat<eT>,eop_scalar_times>& A, const Mat<eT
>& B) >&)
: val(A.aux) : val(A.aux)
, M (A.P.Q) , M (A.P.Q)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_ignore(B);
} }
inline inline
~partial_unwrap_check() ~partial_unwrap_check()
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
inline eT get_val() const { return val; } arma_hot arma_inline eT get_val() const { return val; }
static const bool do_trans = false; static const bool do_trans = false;
static const bool do_times = true; static const bool do_times = true;
const eT val; const eT val;
const Mat<eT>& M; const Mat<eT>& M;
}; };
template<typename eT> template<typename eT>
class partial_unwrap_check< eOp<Row<eT>, eop_scalar_times> > class partial_unwrap_check< eOp<Row<eT>, eop_scalar_times> >
{ {
public: public:
inline arma_hot inline
partial_unwrap_check(const eOp<Row<eT>,eop_scalar_times>& A, const Mat<eT partial_unwrap_check(const eOp<Row<eT>,eop_scalar_times>& A, const Mat<eT
>& B) >&)
: val(A.aux) : val(A.aux)
, M (A.P.Q) , M (A.P.Q)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_ignore(B);
} }
inline inline
~partial_unwrap_check() ~partial_unwrap_check()
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
inline eT get_val() const { return val; } arma_hot arma_inline eT get_val() const { return val; }
static const bool do_trans = false; static const bool do_trans = false;
static const bool do_times = true; static const bool do_times = true;
const eT val; const eT val;
const Mat<eT>& M; const Mat<eT>& M;
}; };
template<typename eT> template<typename eT>
class partial_unwrap_check< eOp<Col<eT>, eop_scalar_times> > class partial_unwrap_check< eOp<Col<eT>, eop_scalar_times> >
{ {
public: public:
inline arma_hot inline
partial_unwrap_check(const eOp<Col<eT>,eop_scalar_times>& A, const Mat<eT partial_unwrap_check(const eOp<Col<eT>,eop_scalar_times>& A, const Mat<eT
>& B) >&)
: val(A.aux) : val(A.aux)
, M (A.P.Q) , M (A.P.Q)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_ignore(B);
} }
inline inline
~partial_unwrap_check() ~partial_unwrap_check()
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
} }
inline eT get_val() const { return val; } arma_hot arma_inline eT get_val() const { return val; }
static const bool do_trans = false; static const bool do_trans = false;
static const bool do_times = true; static const bool do_times = true;
const eT val; const eT val;
const Mat<eT>& M; const Mat<eT>& M;
}; };
//! @} //! @}
 End of changes. 42 change blocks. 
50 lines changed or deleted 43 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/