Cube_meat.hpp   Cube_meat.hpp 
// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) // Copyright (C) 2008-2011 NICTA (www.nicta.com.au)
// Copyright (C) 2008-2010 Conrad Sanderson // Copyright (C) 2008-2011 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 2164 skipping to change at line 2164
template<typename T1> template<typename T1>
inline inline
void void
Cube<eT>::set_imag(const BaseCube<typename Cube<eT>::pod_type,T1>& X) Cube<eT>::set_imag(const BaseCube<typename Cube<eT>::pod_type,T1>& X)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
Cube_aux::set_imag(*this, X); Cube_aux::set_imag(*this, X);
} }
template<typename eT>
inline
eT
Cube<eT>::min() const
{
arma_extra_debug_sigprint();
arma_debug_check( (n_elem == 0), "min(): object has no elements" );
return op_min::direct_min(memptr(), n_elem);
}
template<typename eT>
inline
eT
Cube<eT>::max() const
{
arma_extra_debug_sigprint();
arma_debug_check( (n_elem == 0), "max(): object has no elements" );
return op_max::direct_max(memptr(), n_elem);
}
template<typename eT>
inline
eT
Cube<eT>::min(u32& index_of_min_val) const
{
arma_extra_debug_sigprint();
arma_debug_check( (n_elem == 0), "min(): object has no elements" );
return op_min::direct_min(memptr(), n_elem, index_of_min_val);
}
template<typename eT>
inline
eT
Cube<eT>::max(u32& index_of_max_val) const
{
arma_extra_debug_sigprint();
arma_debug_check( (n_elem == 0), "max(): object has no elements" );
return op_max::direct_max(memptr(), n_elem, index_of_max_val);
}
template<typename eT>
inline
eT
Cube<eT>::min(u32& row_of_min_val, u32& col_of_min_val, u32& slice_of_min_v
al) const
{
arma_extra_debug_sigprint();
arma_debug_check( (n_elem == 0), "min(): object has no elements" );
u32 i;
eT val = op_min::direct_min(memptr(), n_elem, i);
const u32 in_slice = i / n_elem_slice;
const u32 offset = in_slice * n_elem_slice;
const u32 j = i - offset;
row_of_min_val = j % n_rows;
col_of_min_val = j / n_rows;
slice_of_min_val = in_slice;
return val;
}
template<typename eT>
inline
eT
Cube<eT>::max(u32& row_of_max_val, u32& col_of_max_val, u32& slice_of_max_v
al) const
{
arma_extra_debug_sigprint();
arma_debug_check( (n_elem == 0), "max(): object has no elements" );
u32 i;
eT val = op_max::direct_max(memptr(), n_elem, i);
const u32 in_slice = i / n_elem_slice;
const u32 offset = in_slice * n_elem_slice;
const u32 j = i - offset;
row_of_max_val = j % n_rows;
col_of_max_val = j / n_rows;
slice_of_max_val = in_slice;
return val;
}
//! save the cube to a file //! save the cube to a file
template<typename eT> template<typename eT>
inline inline
bool bool
Cube<eT>::save(const std::string name, const file_type type, const bool pri nt_status) const Cube<eT>::save(const std::string name, const file_type type, const bool pri nt_status) const
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
bool save_okay; bool save_okay;
 End of changes. 2 change blocks. 
2 lines changed or deleted 100 lines changed or added


 Cube_proto.hpp   Cube_proto.hpp 
// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) // Copyright (C) 2008-2011 NICTA (www.nicta.com.au)
// Copyright (C) 2008-2010 Conrad Sanderson // Copyright (C) 2008-2011 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 219 skipping to change at line 219
inline const Cube& randu(const u32 in_rows, const u32 in_cols, const u32 in_slices); inline const Cube& randu(const u32 in_rows, const u32 in_cols, const u32 in_slices);
inline const Cube& randn(); inline const Cube& randn();
inline const Cube& randn(const u32 in_rows, const u32 in_cols, const u32 in_slices); inline const Cube& randn(const u32 in_rows, const u32 in_cols, const u32 in_slices);
inline void reset(); inline void reset();
template<typename T1> inline void set_real(const BaseCube<pod_type,T1>& X ); template<typename T1> inline void set_real(const BaseCube<pod_type,T1>& X );
template<typename T1> inline void set_imag(const BaseCube<pod_type,T1>& X ); template<typename T1> inline void set_imag(const BaseCube<pod_type,T1>& X );
inline eT min() const;
inline eT max() const;
inline eT min(u32& index_of_min_val) const;
inline eT max(u32& index_of_max_val) const;
inline eT min(u32& row_of_min_val, u32& col_of_min_val, u32& slice_of_min
_val) const;
inline eT max(u32& row_of_max_val, u32& col_of_max_val, u32& slice_of_max
_val) const;
inline bool save(const std::string name, const file_type type = arma_bi nary, const bool print_status = true) const; inline bool save(const std::string name, const file_type type = arma_bi nary, const bool print_status = true) const;
inline bool save( std::ostream& os, const file_type type = arma_bi nary, const bool print_status = true) const; inline bool save( std::ostream& os, const file_type type = arma_bi nary, const bool print_status = true) const;
inline bool load(const std::string name, const file_type type = auto_de tect, const bool print_status = true); inline bool load(const std::string name, const file_type type = auto_de tect, const bool print_status = true);
inline bool load( std::istream& is, const file_type type = auto_de tect, const bool print_status = true); inline bool load( std::istream& is, const file_type type = auto_de tect, const bool print_status = true);
inline bool quiet_save(const std::string name, const file_type type = a rma_binary) const; inline bool quiet_save(const std::string name, const file_type type = a rma_binary) const;
inline bool quiet_save( std::ostream& os, const file_type type = a rma_binary) const; inline bool quiet_save( std::ostream& os, const file_type type = a rma_binary) const;
inline bool quiet_load(const std::string name, const file_type type = a uto_detect); inline bool quiet_load(const std::string name, const file_type type = a uto_detect);
 End of changes. 2 change blocks. 
2 lines changed or deleted 13 lines changed or added


 Mat_meat.hpp   Mat_meat.hpp 
skipping to change at line 3740 skipping to change at line 3740
template<typename T1> template<typename T1>
inline inline
void void
Mat<eT>::set_imag(const Base<typename Mat<eT>::pod_type,T1>& X) Mat<eT>::set_imag(const Base<typename Mat<eT>::pod_type,T1>& X)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
Mat_aux::set_imag(*this, X); Mat_aux::set_imag(*this, X);
} }
template<typename eT>
inline
eT
Mat<eT>::min() const
{
arma_extra_debug_sigprint();
arma_debug_check( (n_elem == 0), "min(): object has no elements" );
return op_min::direct_min(memptr(), n_elem);
}
template<typename eT>
inline
eT
Mat<eT>::max() const
{
arma_extra_debug_sigprint();
arma_debug_check( (n_elem == 0), "max(): object has no elements" );
return op_max::direct_max(memptr(), n_elem);
}
template<typename eT>
inline
eT
Mat<eT>::min(u32& index_of_min_val) const
{
arma_extra_debug_sigprint();
arma_debug_check( (n_elem == 0), "min(): object has no elements" );
return op_min::direct_min(memptr(), n_elem, index_of_min_val);
}
template<typename eT>
inline
eT
Mat<eT>::max(u32& index_of_max_val) const
{
arma_extra_debug_sigprint();
arma_debug_check( (n_elem == 0), "max(): object has no elements" );
return op_max::direct_max(memptr(), n_elem, index_of_max_val);
}
template<typename eT>
inline
eT
Mat<eT>::min(u32& row_of_min_val, u32& col_of_min_val) const
{
arma_extra_debug_sigprint();
arma_debug_check( (n_elem == 0), "min(): object has no elements" );
u32 i;
eT val = op_min::direct_min(memptr(), n_elem, i);
row_of_min_val = i % n_rows;
col_of_min_val = i / n_rows;
return val;
}
template<typename eT>
inline
eT
Mat<eT>::max(u32& row_of_max_val, u32& col_of_max_val) const
{
arma_extra_debug_sigprint();
arma_debug_check( (n_elem == 0), "max(): object has no elements" );
u32 i;
eT val = op_max::direct_max(memptr(), n_elem, i);
row_of_max_val = i % n_rows;
col_of_max_val = i / n_rows;
return val;
}
//! save the matrix to a file //! save the matrix to a file
template<typename eT> template<typename eT>
inline inline
bool bool
Mat<eT>::save(const std::string name, const file_type type, const bool prin t_status) const Mat<eT>::save(const std::string name, const file_type type, const bool prin t_status) const
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
bool save_okay; bool save_okay;
 End of changes. 1 change blocks. 
0 lines changed or deleted 86 lines changed or added


 Mat_proto.hpp   Mat_proto.hpp 
skipping to change at line 306 skipping to change at line 306
inline const Mat& randn(const u32 in_rows, const u32 in_cols); inline const Mat& randn(const u32 in_rows, const u32 in_cols);
inline const Mat& eye(); inline const Mat& eye();
inline const Mat& eye(const u32 in_rows, const u32 in_cols); inline const Mat& eye(const u32 in_rows, const u32 in_cols);
inline void reset(); inline void reset();
template<typename T1> inline void set_real(const Base<pod_type,T1>& X); template<typename T1> inline void set_real(const Base<pod_type,T1>& X);
template<typename T1> inline void set_imag(const Base<pod_type,T1>& X); template<typename T1> inline void set_imag(const Base<pod_type,T1>& X);
inline eT min() const;
inline eT max() const;
inline eT min(u32& index_of_min_val) const;
inline eT max(u32& index_of_max_val) const;
inline eT min(u32& row_of_min_val, u32& col_of_min_val) const;
inline eT max(u32& row_of_max_val, u32& col_of_max_val) const;
inline bool save(const std::string name, const file_type type = arma_bi nary, const bool print_status = true) const; inline bool save(const std::string name, const file_type type = arma_bi nary, const bool print_status = true) const;
inline bool save( std::ostream& os, const file_type type = arma_bi nary, const bool print_status = true) const; inline bool save( std::ostream& os, const file_type type = arma_bi nary, const bool print_status = true) const;
inline bool load(const std::string name, const file_type type = auto_de tect, const bool print_status = true); inline bool load(const std::string name, const file_type type = auto_de tect, const bool print_status = true);
inline bool load( std::istream& is, const file_type type = auto_de tect, const bool print_status = true); inline bool load( std::istream& is, const file_type type = auto_de tect, const bool print_status = true);
inline bool quiet_save(const std::string name, const file_type type = a rma_binary) const; inline bool quiet_save(const std::string name, const file_type type = a rma_binary) const;
inline bool quiet_save( std::ostream& os, const file_type type = a rma_binary) const; inline bool quiet_save( std::ostream& os, const file_type type = a rma_binary) const;
inline bool quiet_load(const std::string name, const file_type type = a uto_detect); inline bool quiet_load(const std::string name, const file_type type = a uto_detect);
 End of changes. 1 change blocks. 
0 lines changed or deleted 9 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 1 #define ARMA_VERSION_MAJOR 1
#define ARMA_VERSION_MINOR 1 #define ARMA_VERSION_MINOR 1
#define ARMA_VERSION_PATCH 8 #define ARMA_VERSION_PATCH 90
#define ARMA_VERSION_NAME "Kangaroo Steak" #define ARMA_VERSION_NAME "Inside Job"
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


 fn_prod.hpp   fn_prod.hpp 
skipping to change at line 81 skipping to change at line 81
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_extra_debug_print("prod(): two consecutive prod() calls detected"); arma_extra_debug_print("prod(): two consecutive prod() calls detected");
typedef typename T1::elem_type eT; typedef typename T1::elem_type eT;
const unwrap<T1> tmp(in.m); const unwrap<T1> tmp(in.m);
const Mat<eT>& X = tmp.M; const Mat<eT>& X = tmp.M;
arma_debug_check( (X.n_elem < 1), "prod(): given object has no elements" ); arma_debug_check( (X.n_elem < 1), "prod(): given object has no elements" );
const u32 n_elem = X.n_elem; return arrayops::product(X.memptr(), X.n_elem);
const eT* X_mem = X.memptr();
eT val = X_mem[0];
for(u32 i=1; i<n_elem; ++i)
{
val *= X_mem[i];
}
return val;
} }
template<typename T1> template<typename T1>
inline inline
const Op<Op<T1, op_prod>, op_prod> const Op<Op<T1, op_prod>, op_prod>
prod(const Op<T1, op_prod>& in, const u32 dim) prod(const Op<T1, op_prod>& in, const u32 dim)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
return Op<Op<T1, op_prod>, op_prod>(in, dim, 0); return Op<Op<T1, op_prod>, op_prod>(in, dim, 0);
 End of changes. 1 change blocks. 
11 lines changed or deleted 1 lines changed or added


 fn_stddev.hpp   fn_stddev.hpp 
// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) // Copyright (C) 2009-2011 NICTA (www.nicta.com.au)
// Copyright (C) 2009-2010 Conrad Sanderson // Copyright (C) 2009-2011 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 fn_stddev //! \addtogroup fn_stddev
//! @{ //! @{
template<typename T1> template<typename T1>
inline inline
Mat<typename T1::pod_type> const mtOp<typename T1::pod_type, T1, op_stddev>
stddev(const Base<typename T1::elem_type,T1>& X, const u32 norm_type = 0, c onst u32 dim = 0) stddev(const Base<typename T1::elem_type,T1>& X, const u32 norm_type = 0, c onst u32 dim = 0)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
typedef typename T1::elem_type in_eT; return mtOp<typename T1::pod_type, T1, op_stddev>(X.get_ref(), norm_type,
typedef typename T1::pod_type out_eT; dim);
const unwrap<T1> tmp(X.get_ref());
const Mat<in_eT>& A = tmp.M;
Mat<out_eT> out;
op_stddev::apply(out, A, norm_type, dim);
return out;
} }
//! Immediate 'find the standard deviation of a row vector' operation //! Immediate 'find the standard deviation of a row vector' operation
template<typename eT> template<typename eT>
inline inline
arma_warn_unused arma_warn_unused
typename get_pod_type<eT>::result typename get_pod_type<eT>::result
stddev(const Row<eT>& A, const u32 norm_type = 0) stddev(const Row<eT>& A, const u32 norm_type = 0)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
 End of changes. 3 change blocks. 
14 lines changed or deleted 5 lines changed or added


 fn_var.hpp   fn_var.hpp 
// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) // Copyright (C) 2009-2011 NICTA (www.nicta.com.au)
// Copyright (C) 2009-2010 Conrad Sanderson // Copyright (C) 2009-2011 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 fn_var //! \addtogroup fn_var
//! @{ //! @{
template<typename T1> template<typename T1>
inline inline
Mat<typename T1::pod_type> const mtOp<typename T1::pod_type, T1, op_var>
var(const Base<typename T1::elem_type,T1>& X, const u32 norm_type = 0, cons t u32 dim = 0) var(const Base<typename T1::elem_type,T1>& X, const u32 norm_type = 0, cons t u32 dim = 0)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
typedef typename T1::elem_type in_eT; return mtOp<typename T1::pod_type, T1, op_var>(X.get_ref(), norm_type, di
typedef typename T1::pod_type out_eT; m);
const unwrap<T1> tmp(X.get_ref());
const Mat<in_eT>& A = tmp.M;
Mat<out_eT> out;
op_var::apply(out, A, norm_type, dim);
return out;
} }
//! Immediate 'find the variance of a row vector' operation //! Immediate 'find the variance of a row vector' operation
template<typename eT> template<typename eT>
inline inline
arma_warn_unused arma_warn_unused
typename get_pod_type<eT>::result typename get_pod_type<eT>::result
var(const Row<eT>& A, const u32 norm_type = 0) var(const Row<eT>& A, const u32 norm_type = 0)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
 End of changes. 3 change blocks. 
14 lines changed or deleted 5 lines changed or added


 glue_mixed_meat.hpp   glue_mixed_meat.hpp 
// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) // Copyright (C) 2009-2011 NICTA (www.nicta.com.au)
// Copyright (C) 2009-2010 Conrad Sanderson // Copyright (C) 2009-2011 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 44 skipping to change at line 44
const bool A_is_alias = ( ((void *)&out) == ((void *)&A) ); const bool A_is_alias = ( ((void *)&out) == ((void *)&A) );
const bool B_is_alias = ( ((void *)&out) == ((void *)&B) ); const bool B_is_alias = ( ((void *)&out) == ((void *)&B) );
const Mat<eT1>* AA_ptr = A_is_alias ? new Mat<eT1>(A) : 0; const Mat<eT1>* AA_ptr = A_is_alias ? new Mat<eT1>(A) : 0;
const Mat<eT2>* BB_ptr = B_is_alias ? new Mat<eT2>(B) : 0; const Mat<eT2>* BB_ptr = B_is_alias ? new Mat<eT2>(B) : 0;
const Mat<eT1>& AA = A_is_alias ? *AA_ptr : A; const Mat<eT1>& AA = A_is_alias ? *AA_ptr : A;
const Mat<eT2>& BB = B_is_alias ? *BB_ptr : B; const Mat<eT2>& BB = B_is_alias ? *BB_ptr : B;
arma_debug_assert_mul_size(AA, BB, "matrix multiplication"); arma_debug_assert_mul_size(AA, BB, "multiplication");
out.set_size(AA.n_rows, BB.n_cols); out.set_size(AA.n_rows, BB.n_cols);
gemm_mixed<>::apply(out, AA, BB); gemm_mixed<>::apply(out, AA, BB);
if(A_is_alias == true) if(A_is_alias == true)
{ {
delete AA_ptr; delete AA_ptr;
} }
skipping to change at line 79 skipping to change at line 79
typedef typename T1::elem_type eT1; typedef typename T1::elem_type eT1;
typedef typename T2::elem_type eT2; typedef typename T2::elem_type eT2;
typedef typename promote_type<eT1,eT2>::result out_eT; typedef typename promote_type<eT1,eT2>::result out_eT;
promote_type<eT1,eT2>::check(); promote_type<eT1,eT2>::check();
const Proxy<T1> A(X.A); const Proxy<T1> A(X.A);
const Proxy<T2> B(X.B); const Proxy<T2> B(X.B);
arma_debug_assert_same_size(A, B, "matrix addition"); arma_debug_assert_same_size(A, B, "addition");
out.set_size(A.get_n_rows(), A.get_n_cols()); out.set_size(A.get_n_rows(), A.get_n_cols());
out_eT* out_mem = out.memptr(); out_eT* out_mem = out.memptr();
const u32 n_elem = out.n_elem; const u32 n_elem = out.n_elem;
for(u32 i=0; i<n_elem; ++i) for(u32 i=0; i<n_elem; ++i)
{ {
out_mem[i] = upgrade_val<eT1,eT2>::apply(A[i]) + upgrade_val<eT1,eT2>:: apply(B[i]); out_mem[i] = upgrade_val<eT1,eT2>::apply(A[i]) + upgrade_val<eT1,eT2>:: apply(B[i]);
} }
skipping to change at line 110 skipping to change at line 110
typedef typename T1::elem_type eT1; typedef typename T1::elem_type eT1;
typedef typename T2::elem_type eT2; typedef typename T2::elem_type eT2;
typedef typename promote_type<eT1,eT2>::result out_eT; typedef typename promote_type<eT1,eT2>::result out_eT;
promote_type<eT1,eT2>::check(); promote_type<eT1,eT2>::check();
const Proxy<T1> A(X.A); const Proxy<T1> A(X.A);
const Proxy<T2> B(X.B); const Proxy<T2> B(X.B);
arma_debug_assert_same_size(A, B, "matrix subtraction"); arma_debug_assert_same_size(A, B, "subtraction");
out.set_size(A.get_n_rows(), A.get_n_cols()); out.set_size(A.get_n_rows(), A.get_n_cols());
out_eT* out_mem = out.memptr(); out_eT* out_mem = out.memptr();
const u32 n_elem = out.n_elem; const u32 n_elem = out.n_elem;
for(u32 i=0; i<n_elem; ++i) for(u32 i=0; i<n_elem; ++i)
{ {
out_mem[i] = upgrade_val<eT1,eT2>::apply(A[i]) - upgrade_val<eT1,eT2>:: apply(B[i]); out_mem[i] = upgrade_val<eT1,eT2>::apply(A[i]) - upgrade_val<eT1,eT2>:: apply(B[i]);
} }
skipping to change at line 141 skipping to change at line 141
typedef typename T1::elem_type eT1; typedef typename T1::elem_type eT1;
typedef typename T2::elem_type eT2; typedef typename T2::elem_type eT2;
typedef typename promote_type<eT1,eT2>::result out_eT; typedef typename promote_type<eT1,eT2>::result out_eT;
promote_type<eT1,eT2>::check(); promote_type<eT1,eT2>::check();
const Proxy<T1> A(X.A); const Proxy<T1> A(X.A);
const Proxy<T2> B(X.B); const Proxy<T2> B(X.B);
arma_debug_assert_same_size(A, B, "element-wise matrix division"); arma_debug_assert_same_size(A, B, "element-wise division");
out.set_size(A.get_n_rows(), A.get_n_cols()); out.set_size(A.get_n_rows(), A.get_n_cols());
out_eT* out_mem = out.memptr(); out_eT* out_mem = out.memptr();
const u32 n_elem = out.n_elem; const u32 n_elem = out.n_elem;
for(u32 i=0; i<n_elem; ++i) for(u32 i=0; i<n_elem; ++i)
{ {
out_mem[i] = upgrade_val<eT1,eT2>::apply(A[i]) / upgrade_val<eT1,eT2>:: apply(B[i]); out_mem[i] = upgrade_val<eT1,eT2>::apply(A[i]) / upgrade_val<eT1,eT2>:: apply(B[i]);
} }
skipping to change at line 172 skipping to change at line 172
typedef typename T1::elem_type eT1; typedef typename T1::elem_type eT1;
typedef typename T2::elem_type eT2; typedef typename T2::elem_type eT2;
typedef typename promote_type<eT1,eT2>::result out_eT; typedef typename promote_type<eT1,eT2>::result out_eT;
promote_type<eT1,eT2>::check(); promote_type<eT1,eT2>::check();
const Proxy<T1> A(X.A); const Proxy<T1> A(X.A);
const Proxy<T2> B(X.B); const Proxy<T2> B(X.B);
arma_debug_assert_same_size(A, B, "element-wise matrix multiplication"); arma_debug_assert_same_size(A, B, "element-wise multiplication");
out.set_size(A.get_n_rows(), A.get_n_cols()); out.set_size(A.get_n_rows(), A.get_n_cols());
out_eT* out_mem = out.memptr(); out_eT* out_mem = out.memptr();
const u32 n_elem = out.n_elem; const u32 n_elem = out.n_elem;
for(u32 i=0; i<n_elem; ++i) for(u32 i=0; i<n_elem; ++i)
{ {
out_mem[i] = upgrade_val<eT1,eT2>::apply(A[i]) * upgrade_val<eT1,eT2>:: apply(B[i]); out_mem[i] = upgrade_val<eT1,eT2>::apply(A[i]) * upgrade_val<eT1,eT2>:: apply(B[i]);
} }
skipping to change at line 207 skipping to change at line 207
typedef typename T1::elem_type eT1; typedef typename T1::elem_type eT1;
typedef typename T2::elem_type eT2; typedef typename T2::elem_type eT2;
typedef typename promote_type<eT1,eT2>::result out_eT; typedef typename promote_type<eT1,eT2>::result out_eT;
promote_type<eT1,eT2>::check(); promote_type<eT1,eT2>::check();
const ProxyCube<T1> A(X.A); const ProxyCube<T1> A(X.A);
const ProxyCube<T2> B(X.B); const ProxyCube<T2> B(X.B);
arma_debug_assert_same_size(A, B, "cube addition"); arma_debug_assert_same_size(A, B, "addition");
out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices()); out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices());
out_eT* out_mem = out.memptr(); out_eT* out_mem = out.memptr();
const u32 n_elem = out.n_elem; const u32 n_elem = out.n_elem;
for(u32 i=0; i<n_elem; ++i) for(u32 i=0; i<n_elem; ++i)
{ {
out_mem[i] = upgrade_val<eT1,eT2>::apply(A[i]) + upgrade_val<eT1,eT2>:: apply(B[i]); out_mem[i] = upgrade_val<eT1,eT2>::apply(A[i]) + upgrade_val<eT1,eT2>:: apply(B[i]);
} }
skipping to change at line 238 skipping to change at line 238
typedef typename T1::elem_type eT1; typedef typename T1::elem_type eT1;
typedef typename T2::elem_type eT2; typedef typename T2::elem_type eT2;
typedef typename promote_type<eT1,eT2>::result out_eT; typedef typename promote_type<eT1,eT2>::result out_eT;
promote_type<eT1,eT2>::check(); promote_type<eT1,eT2>::check();
const ProxyCube<T1> A(X.A); const ProxyCube<T1> A(X.A);
const ProxyCube<T2> B(X.B); const ProxyCube<T2> B(X.B);
arma_debug_assert_same_size(A, B, "cube subtraction"); arma_debug_assert_same_size(A, B, "subtraction");
out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices()); out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices());
out_eT* out_mem = out.memptr(); out_eT* out_mem = out.memptr();
const u32 n_elem = out.n_elem; const u32 n_elem = out.n_elem;
for(u32 i=0; i<n_elem; ++i) for(u32 i=0; i<n_elem; ++i)
{ {
out_mem[i] = upgrade_val<eT1,eT2>::apply(A[i]) - upgrade_val<eT1,eT2>:: apply(B[i]); out_mem[i] = upgrade_val<eT1,eT2>::apply(A[i]) - upgrade_val<eT1,eT2>:: apply(B[i]);
} }
skipping to change at line 269 skipping to change at line 269
typedef typename T1::elem_type eT1; typedef typename T1::elem_type eT1;
typedef typename T2::elem_type eT2; typedef typename T2::elem_type eT2;
typedef typename promote_type<eT1,eT2>::result out_eT; typedef typename promote_type<eT1,eT2>::result out_eT;
promote_type<eT1,eT2>::check(); promote_type<eT1,eT2>::check();
const ProxyCube<T1> A(X.A); const ProxyCube<T1> A(X.A);
const ProxyCube<T2> B(X.B); const ProxyCube<T2> B(X.B);
arma_debug_assert_same_size(A, B, "element-wise cube division"); arma_debug_assert_same_size(A, B, "element-wise division");
out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices()); out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices());
out_eT* out_mem = out.memptr(); out_eT* out_mem = out.memptr();
const u32 n_elem = out.n_elem; const u32 n_elem = out.n_elem;
for(u32 i=0; i<n_elem; ++i) for(u32 i=0; i<n_elem; ++i)
{ {
out_mem[i] = upgrade_val<eT1,eT2>::apply(A[i]) / upgrade_val<eT1,eT2>:: apply(B[i]); out_mem[i] = upgrade_val<eT1,eT2>::apply(A[i]) / upgrade_val<eT1,eT2>:: apply(B[i]);
} }
skipping to change at line 300 skipping to change at line 300
typedef typename T1::elem_type eT1; typedef typename T1::elem_type eT1;
typedef typename T2::elem_type eT2; typedef typename T2::elem_type eT2;
typedef typename promote_type<eT1,eT2>::result out_eT; typedef typename promote_type<eT1,eT2>::result out_eT;
promote_type<eT1,eT2>::check(); promote_type<eT1,eT2>::check();
const ProxyCube<T1> A(X.A); const ProxyCube<T1> A(X.A);
const ProxyCube<T2> B(X.B); const ProxyCube<T2> B(X.B);
arma_debug_assert_same_size(A, B, "element-wise cube multiplication"); arma_debug_assert_same_size(A, B, "element-wise multiplication");
out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices()); out.set_size(A.get_n_rows(), A.get_n_cols(), A.get_n_slices());
out_eT* out_mem = out.memptr(); out_eT* out_mem = out.memptr();
const u32 n_elem = out.n_elem; const u32 n_elem = out.n_elem;
for(u32 i=0; i<n_elem; ++i) for(u32 i=0; i<n_elem; ++i)
{ {
out_mem[i] = upgrade_val<eT1,eT2>::apply(A[i]) * upgrade_val<eT1,eT2>:: apply(B[i]); out_mem[i] = upgrade_val<eT1,eT2>::apply(A[i]) * upgrade_val<eT1,eT2>:: apply(B[i]);
} }
 End of changes. 10 change blocks. 
11 lines changed or deleted 11 lines changed or added


 op_max_meat.hpp   op_max_meat.hpp 
skipping to change at line 58 skipping to change at line 58
if(X_i > max_val) if(X_i > max_val)
{ {
max_val = X_i; max_val = X_i;
} }
} }
return max_val; return max_val;
} }
template<typename eT>
inline
eT
op_max::direct_max(const eT* const X, const u32 n_elem, u32& index_of_max_v
al)
{
arma_extra_debug_sigprint();
eT max_val = (n_elem != 1) ? priv::most_neg<eT>() : X[0];
u32 best_index = 0;
u32 i,j;
for(i=0, j=1; j<n_elem; i+=2, j+=2)
{
const eT X_i = X[i];
const eT X_j = X[j];
if(X_i > max_val)
{
max_val = X_i;
best_index = i;
}
if(X_j > max_val)
{
max_val = X_j;
best_index = j;
}
}
if(i < n_elem)
{
const eT X_i = X[i];
if(X_i > max_val)
{
max_val = X_i;
best_index = i;
}
}
index_of_max_val = best_index;
return max_val;
}
template<typename eT>
inline
eT
op_max::direct_max(const Mat<eT>& X, const u32 row)
{
arma_extra_debug_sigprint();
const u32 X_n_cols = X.n_cols;
eT max_val = (X_n_cols != 1) ? priv::most_neg<eT>() : X.at(row,0);
for(u32 col=0; col<X_n_cols; ++col)
{
const eT tmp_val = X.at(row,col);
if(tmp_val > max_val)
{
max_val = tmp_val;
}
}
return max_val;
}
//! find the maximum value in a subview //! find the maximum value in a subview
template<typename eT> template<typename eT>
inline inline
eT eT
op_max::direct_max(const subview<eT>& X) op_max::direct_max(const subview<eT>& X)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
const u32 X_n_elem = X.n_elem; const u32 X_n_elem = X.n_elem;
eT max_val = (X_n_elem != 1) ? priv::most_neg<eT>() : X[0]; eT max_val = (X_n_elem != 1) ? priv::most_neg<eT>() : X[0];
skipping to change at line 150 skipping to change at line 221
} }
else else
if(dim == 1) if(dim == 1)
{ {
arma_extra_debug_print("op_max::apply(), dim = 1"); arma_extra_debug_print("op_max::apply(), dim = 1");
out.set_size(X_n_rows, 1); out.set_size(X_n_rows, 1);
for(u32 row=0; row<X_n_rows; ++row) for(u32 row=0; row<X_n_rows; ++row)
{ {
eT max_val = (X_n_cols != 1) ? priv::most_neg<eT>() : X.at(row,0); out[row] = op_max::direct_max( X, row );
for(u32 col=0; col<X_n_cols; ++col)
{
const eT tmp_val = X.at(row,col);
if(tmp_val > max_val)
{
max_val = tmp_val;
}
}
out[row] = max_val;
} }
} }
} }
//! Find the maximum value in an array (version for complex numbers) //! Find the maximum value in an array (version for complex numbers)
template<typename T> template<typename T>
inline inline
std::complex<T> std::complex<T>
op_max::direct_max(const std::complex<T>* const X, const u32 n_elem) op_max::direct_max(const std::complex<T>* const X, const u32 n_elem)
{ {
skipping to change at line 192 skipping to change at line 251
if(tmp_val > max_val) if(tmp_val > max_val)
{ {
max_val = tmp_val; max_val = tmp_val;
index = i; index = i;
} }
} }
return X[index]; return X[index];
} }
//! Find the maximum value in a subview (version for complex numbers)
template<typename T> template<typename T>
inline inline
std::complex<T> std::complex<T>
op_max::direct_max(const subview< std::complex<T> >& X) op_max::direct_max(const std::complex<T>* const X, const u32 n_elem, u32& i ndex_of_max_val)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
const u32 X_n_elem = X.n_elem; u32 index = 0;
u32 index = 0; T max_val = (n_elem != 1) ? priv::most_neg<T>() : std::abs(X[0]);
T max_val = (X_n_elem != 1) ? priv::most_neg<T>() : std::abs(X[0
]);
for(u32 i=0; i<X_n_elem; ++i) for(u32 i=0; i<n_elem; ++i)
{ {
const T tmp_val = std::abs(X[i]); const T tmp_val = std::abs(X[i]);
if(tmp_val > max_val) if(tmp_val > max_val)
{ {
max_val = tmp_val; max_val = tmp_val;
index = i; index = i;
} }
} }
index_of_max_val = index;
return X[index]; return X[index];
} }
//! Find the maximum value in a diagview (version for complex numbers)
template<typename T> template<typename T>
inline inline
std::complex<T> std::complex<T>
op_max::direct_max(const diagview< std::complex<T> >& X) op_max::direct_max(const Mat< std::complex<T> >& X, const u32 row)
{
arma_extra_debug_sigprint();
const u32 X_n_cols = X.n_cols;
u32 index = 0;
T max_val = (X_n_cols != 1) ? priv::most_neg<T>() : std::abs(X.at(row,0
));
for(u32 col=0; col<X_n_cols; ++col)
{
const T tmp_val = std::abs(X.at(row,col));
if(tmp_val > max_val)
{
max_val = tmp_val;
index = col;
}
}
return X.at(row,index);
}
//! Find the maximum value in a subview (version for complex numbers)
template<typename T>
inline
std::complex<T>
op_max::direct_max(const subview< std::complex<T> >& X)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
const u32 X_n_elem = X.n_elem; const u32 X_n_elem = X.n_elem;
u32 index = 0; u32 index = 0;
T max_val = (X_n_elem != 1) ? priv::most_neg<T>() : std::abs(X[0 ]); T max_val = (X_n_elem != 1) ? priv::most_neg<T>() : std::abs(X[0 ]);
for(u32 i=0; i<X_n_elem; ++i) for(u32 i=0; i<X_n_elem; ++i)
{ {
const T tmp_val = std::abs(X[i]); const T tmp_val = std::abs(X[i]);
skipping to change at line 244 skipping to change at line 329
if(tmp_val > max_val) if(tmp_val > max_val)
{ {
max_val = tmp_val; max_val = tmp_val;
index = i; index = i;
} }
} }
return X[index]; return X[index];
} }
//! Implementation for complex numbers //! Find the maximum value in a diagview (version for complex numbers)
template<typename T, typename T1> template<typename T>
inline void op_max::apply(Mat< std::complex<T> >& out, const Op<T1,op_max>& inline
in) std::complex<T>
op_max::direct_max(const diagview< std::complex<T> >& X)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
typedef typename std::complex<T> eT; const u32 X_n_elem = X.n_elem;
isnt_same_type<eT, typename T1::elem_type>::check(); u32 index = 0;
T max_val = (X_n_elem != 1) ? priv::most_neg<T>() : std::abs(X[0
const unwrap_check<T1> tmp(in.m, out); ]);
const Mat<eT>& X = tmp.M;
arma_debug_check( (X.n_elem == 0), "max(): given matrix has no elements"
);
const u32 dim = in.aux_u32_a;
arma_debug_check( (dim > 1), "max(): incorrect usage. dim must be 0 or 1"
);
const u32 X_n_rows = X.n_rows;
const u32 X_n_cols = X.n_cols;
if(dim == 0) // column-wise max
{
arma_extra_debug_print("op_max::apply(), dim = 0");
out.set_size(1, X_n_cols);
for(u32 col=0; col<X_n_cols; ++col) for(u32 i=0; i<X_n_elem; ++i)
{
out[col] = op_max::direct_max( X.colptr(col), X_n_rows );
}
}
else
if(dim == 1) // row-wise max
{ {
arma_extra_debug_print("op_max::apply(), dim = 1"); const T tmp_val = std::abs(X[i]);
out.set_size(X_n_rows, 1);
for(u32 row=0; row<X_n_rows; ++row) if(tmp_val > max_val)
{ {
u32 index = 0; max_val = tmp_val;
T max_val = (X_n_cols != 1) ? priv::most_neg<T>() : std::abs(X.at(r index = i;
ow,0));
for(u32 col=0; col<X_n_cols; ++col)
{
const T tmp_val = std::abs(X.at(row,col));
if(tmp_val > max_val)
{
max_val = tmp_val;
index = col;
}
}
out[row] = X.at(row,index);
} }
} }
return X[index];
} }
//! @} //! @}
 End of changes. 17 change blocks. 
75 lines changed or deleted 123 lines changed or added


 op_max_proto.hpp   op_max_proto.hpp 
// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) // Copyright (C) 2008-2011 NICTA (www.nicta.com.au)
// Copyright (C) 2008-2010 Conrad Sanderson // Copyright (C) 2008-2011 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 25 skipping to change at line 25
//! Class for finding maximum values in a matrix //! Class for finding maximum values in a matrix
class op_max class op_max
{ {
public: public:
template<typename eT> template<typename eT>
inline static eT direct_max(const eT* const X, const u32 N); inline static eT direct_max(const eT* const X, const u32 N);
template<typename eT> template<typename eT>
inline static eT direct_max(const eT* const X, const u32 N, u32& index_of
_max_val);
template<typename eT>
inline static eT direct_max(const Mat<eT>& X, const u32 row);
template<typename eT>
inline static eT direct_max(const subview<eT>& X); inline static eT direct_max(const subview<eT>& X);
template<typename eT> template<typename eT>
inline static eT direct_max(const diagview<eT>& X); inline static eT direct_max(const diagview<eT>& X);
template<typename T1> template<typename T1>
inline static void apply(Mat<typename T1::elem_type>& out, const Op<T1,op _max>& in); inline static void apply(Mat<typename T1::elem_type>& out, const Op<T1,op _max>& in);
// //
// for complex numbers // for complex numbers
template<typename T> template<typename T>
inline static std::complex<T> direct_max(const std::complex<T>* const X, const u32 n_elem); inline static std::complex<T> direct_max(const std::complex<T>* const X, const u32 n_elem);
template<typename T> template<typename T>
inline static std::complex<T> direct_max(const std::complex<T>* const X,
const u32 n_elem, u32& index_of_max_val);
template<typename T>
inline static std::complex<T> direct_max(const Mat< std::complex<T> >& X,
const u32 row);
template<typename T>
inline static std::complex<T> direct_max(const subview< std::complex<T> > &X); inline static std::complex<T> direct_max(const subview< std::complex<T> > &X);
template<typename T> template<typename T>
inline static std::complex<T> direct_max(const diagview< std::complex<T> >&X); inline static std::complex<T> direct_max(const diagview< std::complex<T> >&X);
template<typename T, typename T1>
inline static void apply(Mat< std::complex<T> >& out, const Op<T1,op_max>
& in);
}; };
//! @} //! @}
 End of changes. 4 change blocks. 
6 lines changed or deleted 17 lines changed or added


 op_mean_meat.hpp   op_mean_meat.hpp 
skipping to change at line 27 skipping to change at line 27
template<typename eT> template<typename eT>
arma_pure arma_pure
inline inline
eT eT
op_mean::direct_mean(const eT* const X, const u32 n_elem) op_mean::direct_mean(const eT* const X, const u32 n_elem)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
typedef typename get_pod_type<eT>::result T; typedef typename get_pod_type<eT>::result T;
return arrayops::accumulate(X, n_elem) / T(n_elem); const eT result = arrayops::accumulate(X, n_elem) / T(n_elem);
return arma_isfinite(result) ? result : op_mean::direct_mean_robust(X, n_
elem);
}
template<typename eT>
inline
eT
op_mean::direct_mean(const Mat<eT>& X, const u32 row)
{
arma_extra_debug_sigprint();
typedef typename get_pod_type<eT>::result T;
const u32 X_n_cols = X.n_cols;
eT val = eT(0);
for(u32 col=0; col<X_n_cols; ++col)
{
val += X.at(row,col);
}
const eT result = val / T(X_n_cols);
return arma_isfinite(result) ? result : direct_mean_robust(X, row);
} }
//! find the mean value of a subview //! find the mean value of a subview
template<typename eT> template<typename eT>
inline inline
eT eT
op_mean::direct_mean(const subview<eT>& X) op_mean::direct_mean(const subview<eT>& X)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
typedef typename get_pod_type<eT>::result T; typedef typename get_pod_type<eT>::result T;
const u32 X_n_elem = X.n_elem; const u32 X_n_elem = X.n_elem;
eT val = eT(0); eT val = eT(0);
for(u32 i=0; i<X_n_elem; ++i) for(u32 i=0; i<X_n_elem; ++i)
{ {
val += X[i]; val += X[i];
} }
return val / T(X_n_elem); const eT result = val / T(X_n_elem);
return arma_isfinite(result) ? result : direct_mean_robust(X);
} }
//! find the mean value of a diagview //! find the mean value of a diagview
template<typename eT> template<typename eT>
inline inline
eT eT
op_mean::direct_mean(const diagview<eT>& X) op_mean::direct_mean(const diagview<eT>& X)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
typedef typename get_pod_type<eT>::result T; typedef typename get_pod_type<eT>::result T;
const u32 X_n_elem = X.n_elem; const u32 X_n_elem = X.n_elem;
eT val = eT(0); eT val = eT(0);
for(u32 i=0; i<X_n_elem; ++i) for(u32 i=0; i<X_n_elem; ++i)
{ {
val += X[i]; val += X[i];
} }
return val / T(X_n_elem); const eT result = val / T(X_n_elem);
return arma_isfinite(result) ? result : direct_mean_robust(X);
} }
//! \brief //! \brief
//! For each row or for each column, find the mean value. //! For each row or for each column, find the mean value.
//! The result is stored in a dense matrix that has either one column or on e row. //! The result is stored in a dense matrix that has either one column or on e row.
//! The dimension, for which the means are found, is set via the mean() fun ction. //! The dimension, for which the means are found, is set via the mean() fun ction.
template<typename T1> template<typename T1>
inline inline
void void
op_mean::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_mean>& in) op_mean::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_mean>& in)
skipping to change at line 117 skipping to change at line 146
} }
else else
if(dim == 1) if(dim == 1)
{ {
arma_extra_debug_print("op_mean::apply(), dim = 1"); arma_extra_debug_print("op_mean::apply(), dim = 1");
out.set_size(X_n_rows, 1); out.set_size(X_n_rows, 1);
for(u32 row=0; row<X_n_rows; ++row) for(u32 row=0; row<X_n_rows; ++row)
{ {
eT val = eT(0); out[row] = op_mean::direct_mean( X, row );
}
}
}
for(u32 col=0; col<X_n_cols; ++col) template<typename eT>
{ arma_pure
val += X.at(row,col); inline
} eT
op_mean::direct_mean_robust(const eT* const X, const u32 n_elem)
{
arma_extra_debug_sigprint();
out[row] = val / T(X_n_cols); // use an adapted form of the mean finding algorithm from the running_sta
} t class
typedef typename get_pod_type<eT>::result T;
u32 i,j;
eT r_mean = eT(0);
for(i=0, j=1; j<n_elem; i+=2, j+=2)
{
const eT Xi = X[i];
const eT Xj = X[j];
r_mean = r_mean + (Xi - r_mean)/T(j); // we need i+1, and j is equiv
alent to i+1 here
r_mean = r_mean + (Xj - r_mean)/T(j+1);
}
if(i < n_elem)
{
const eT Xi = X[i];
r_mean = r_mean + (Xi - r_mean)/T(i+1);
}
return r_mean;
}
template<typename eT>
inline
eT
op_mean::direct_mean_robust(const Mat<eT>& X, const u32 row)
{
arma_extra_debug_sigprint();
typedef typename get_pod_type<eT>::result T;
const u32 X_n_cols = X.n_cols;
eT r_mean = eT(0);
for(u32 col=0; col<X_n_cols; ++col)
{
r_mean = r_mean + (X.at(row,col) - r_mean)/T(col+1);
}
return r_mean;
}
template<typename eT>
inline
eT
op_mean::direct_mean_robust(const subview<eT>& X)
{
arma_extra_debug_sigprint();
typedef typename get_pod_type<eT>::result T;
const u32 X_n_elem = X.n_elem;
eT r_mean = eT(0);
for(u32 i=0; i<X_n_elem; ++i)
{
r_mean = r_mean + (X[i] - r_mean)/T(i+1);
} }
return r_mean;
}
template<typename eT>
inline
eT
op_mean::direct_mean_robust(const diagview<eT>& X)
{
arma_extra_debug_sigprint();
typedef typename get_pod_type<eT>::result T;
const u32 X_n_elem = X.n_elem;
eT r_mean = eT(0);
for(u32 i=0; i<X_n_elem; ++i)
{
r_mean = r_mean + (X[i] - r_mean)/T(i+1);
}
return r_mean;
} }
//! @} //! @}
 End of changes. 7 change blocks. 
10 lines changed or deleted 133 lines changed or added


 op_mean_proto.hpp   op_mean_proto.hpp 
// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) // Copyright (C) 2009-2011 NICTA (www.nicta.com.au)
// Copyright (C) 2009-2010 Conrad Sanderson // Copyright (C) 2009-2011 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 25 skipping to change at line 25
//! Class for finding mean values of a matrix //! Class for finding mean values of a matrix
class op_mean class op_mean
{ {
public: public:
template<typename eT> template<typename eT>
inline static eT direct_mean(const eT* const X, const u32 N); inline static eT direct_mean(const eT* const X, const u32 N);
template<typename eT> template<typename eT>
inline static eT direct_mean(const Mat<eT>& X, const u32 row);
template<typename eT>
inline static eT direct_mean(const subview<eT>& X); inline static eT direct_mean(const subview<eT>& X);
template<typename eT> template<typename eT>
inline static eT direct_mean(const diagview<eT>& X); inline static eT direct_mean(const diagview<eT>& X);
template<typename T1> template<typename T1>
inline static void apply(Mat<typename T1::elem_type>& out, const Op<T1,op _mean>& in); inline static void apply(Mat<typename T1::elem_type>& out, const Op<T1,op _mean>& in);
template<typename eT>
inline static eT direct_mean_robust(const eT* const X, const u32 N);
template<typename eT>
inline static eT direct_mean_robust(const Mat<eT>& X, const u32 row);
template<typename eT>
inline static eT direct_mean_robust(const subview<eT>& X);
template<typename eT>
inline static eT direct_mean_robust(const diagview<eT>& X);
}; };
//! @} //! @}
 End of changes. 3 change blocks. 
2 lines changed or deleted 16 lines changed or added


 op_min_meat.hpp   op_min_meat.hpp 
skipping to change at line 58 skipping to change at line 58
if(X_i < min_val) if(X_i < min_val)
{ {
min_val = X_i; min_val = X_i;
} }
} }
return min_val; return min_val;
} }
template<typename eT>
inline
eT
op_min::direct_min(const eT* const X, const u32 n_elem, u32& index_of_min_v
al)
{
arma_extra_debug_sigprint();
eT min_val = (n_elem != 1) ? priv::most_pos<eT>() : X[0];
u32 best_index = 0;
u32 i,j;
for(i=0, j=1; j<n_elem; i+=2, j+=2)
{
const eT X_i = X[i];
const eT X_j = X[j];
if(X_i < min_val)
{
min_val = X_i;
best_index = i;
}
if(X_j < min_val)
{
min_val = X_j;
best_index = j;
}
}
if(i < n_elem)
{
const eT X_i = X[i];
if(X_i < min_val)
{
min_val = X_i;
best_index = i;
}
}
index_of_min_val = best_index;
return min_val;
}
template<typename eT>
inline
eT
op_min::direct_min(const Mat<eT>& X, const u32 row)
{
arma_extra_debug_sigprint();
const u32 X_n_cols = X.n_cols;
eT min_val = (X_n_cols != 1) ? priv::most_pos<eT>() : X.at(row,0);
for(u32 col=0; col<X_n_cols; ++col)
{
const eT tmp_val = X.at(row,col);
if(tmp_val < min_val)
{
min_val = tmp_val;
}
}
return min_val;
}
//! find the minimum value in a subview //! find the minimum value in a subview
template<typename eT> template<typename eT>
inline inline
eT eT
op_min::direct_min(const subview<eT>& X) op_min::direct_min(const subview<eT>& X)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
const u32 X_n_elem = X.n_elem; const u32 X_n_elem = X.n_elem;
skipping to change at line 150 skipping to change at line 221
} }
else else
if(dim == 1) // min in each row if(dim == 1) // min in each row
{ {
arma_extra_debug_print("op_min::apply(), dim = 1"); arma_extra_debug_print("op_min::apply(), dim = 1");
out.set_size(X_n_rows, 1); out.set_size(X_n_rows, 1);
for(u32 row=0; row<X_n_rows; ++row) for(u32 row=0; row<X_n_rows; ++row)
{ {
eT min_val = (X_n_cols != 1) ? priv::most_pos<eT>() : X.at(row,0); out[row] = op_min::direct_min( X, row );
for(u32 col=0; col<X_n_cols; ++col)
{
const eT tmp_val = X.at(row,col);
if(tmp_val < min_val)
{
min_val = tmp_val;
}
}
out[row] = min_val;
} }
} }
} }
//! Find the minimum value in an array (version for complex numbers) //! Find the minimum value in an array (version for complex numbers)
template<typename T> template<typename T>
inline inline
std::complex<T> std::complex<T>
op_min::direct_min(const std::complex<T>* const X, const u32 n_elem) op_min::direct_min(const std::complex<T>* const X, const u32 n_elem)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 194 skipping to change at line 251
if(tmp_val < min_val) if(tmp_val < min_val)
{ {
min_val = tmp_val; min_val = tmp_val;
index = i; index = i;
} }
} }
return X[index]; return X[index];
} }
//! Find the minimum value in a subview (version for complex numbers)
template<typename T> template<typename T>
inline inline
std::complex<T> std::complex<T>
op_min::direct_min(const subview< std::complex<T> >& X) op_min::direct_min(const std::complex<T>* const X, const u32 n_elem, u32& i ndex_of_min_val)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
const u32 X_n_elem = X.n_elem; u32 index = 0;
u32 index = 0; T min_val = (n_elem != 1) ? priv::most_pos<T>() : std::abs(X[0]);
T min_val = (X_n_elem != 1) ? priv::most_pos<T>() : std::abs(X[0
]);
for(u32 i=0; i<X_n_elem; ++i) for(u32 i=0; i<n_elem; ++i)
{ {
const T tmp_val = std::abs(X[i]); const T tmp_val = std::abs(X[i]);
if(tmp_val < min_val) if(tmp_val < min_val)
{ {
min_val = tmp_val; min_val = tmp_val;
index = i; index = i;
} }
} }
index_of_min_val = index;
return X[index]; return X[index];
} }
//! Find the minimum value in a diagview (version for complex numbers)
template<typename T> template<typename T>
inline inline
std::complex<T> std::complex<T>
op_min::direct_min(const diagview< std::complex<T> >& X) op_min::direct_min(const Mat< std::complex<T> >& X, const u32 row)
{
arma_extra_debug_sigprint();
const u32 X_n_cols = X.n_cols;
u32 index = 0;
T min_val = (X_n_cols != 1) ? priv::most_pos<T>() : std::abs(X.at(row,0
));
for(u32 col=0; col<X_n_cols; ++col)
{
const T tmp_val = std::abs(X.at(row,col));
if(tmp_val < min_val)
{
min_val = tmp_val;
index = col;
}
}
return X.at(row,index);
}
//! Find the minimum value in a subview (version for complex numbers)
template<typename T>
inline
std::complex<T>
op_min::direct_min(const subview< std::complex<T> >& X)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
const u32 X_n_elem = X.n_elem; const u32 X_n_elem = X.n_elem;
u32 index = 0; u32 index = 0;
T min_val = (X_n_elem != 1) ? priv::most_pos<T>() : std::abs(X[0 ]); T min_val = (X_n_elem != 1) ? priv::most_pos<T>() : std::abs(X[0 ]);
for(u32 i=0; i<X_n_elem; ++i) for(u32 i=0; i<X_n_elem; ++i)
{ {
const T tmp_val = std::abs(X[i]); const T tmp_val = std::abs(X[i]);
skipping to change at line 246 skipping to change at line 329
if(tmp_val < min_val) if(tmp_val < min_val)
{ {
min_val = tmp_val; min_val = tmp_val;
index = i; index = i;
} }
} }
return X[index]; return X[index];
} }
//! Implementation for complex numbers //! Find the minimum value in a diagview (version for complex numbers)
template<typename T, typename T1> template<typename T>
inline void op_min::apply(Mat< std::complex<T> >& out, const Op<T1,op_min>& inline
in) std::complex<T>
op_min::direct_min(const diagview< std::complex<T> >& X)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
typedef typename std::complex<T> eT; const u32 X_n_elem = X.n_elem;
isnt_same_type<eT, typename T1::elem_type>::check(); u32 index = 0;
T min_val = (X_n_elem != 1) ? priv::most_pos<T>() : std::abs(X[0
const unwrap_check<T1> tmp(in.m, out); ]);
const Mat<eT>& X = tmp.M;
arma_debug_check( (X.n_elem == 0), "min(): given matrix has no elements"
);
const u32 dim = in.aux_u32_a;
arma_debug_check( (dim > 1), "min(): incorrect usage. dim must be 0 or 1"
);
const u32 X_n_rows = X.n_rows;
const u32 X_n_cols = X.n_cols;
if(dim == 0) // column-wise min
{
arma_extra_debug_print("op_min::apply(), dim = 0");
out.set_size(1, X_n_cols);
for(u32 col=0; col<X_n_cols; ++col) for(u32 i=0; i<X_n_elem; ++i)
{
out[col] = op_min::direct_min( X.colptr(col), X_n_rows );
}
}
else
if(dim == 1) // row-wise min
{ {
arma_extra_debug_print("op_min::apply(), dim = 1"); const T tmp_val = std::abs(X[i]);
out.set_size(X_n_rows, 1);
for(u32 row=0; row<X_n_rows; ++row) if(tmp_val < min_val)
{ {
u32 index = 0; min_val = tmp_val;
T min_val = (X_n_cols != 1) ? priv::most_pos<T>() : std::abs(X.at(r index = i;
ow,0));
for(u32 col=0; col<X_n_cols; ++col)
{
const T tmp_val = std::abs(X.at(row,col));
if(tmp_val < min_val)
{
min_val = tmp_val;
index = col;
}
}
out[row] = X.at(row,index);
} }
} }
return X[index];
} }
//! @} //! @}
 End of changes. 19 change blocks. 
77 lines changed or deleted 123 lines changed or added


 op_min_proto.hpp   op_min_proto.hpp 
// Copyright (C) 2008-2010 NICTA (www.nicta.com.au) // Copyright (C) 2008-2011 NICTA (www.nicta.com.au)
// Copyright (C) 2008-2010 Conrad Sanderson // Copyright (C) 2008-2011 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 25 skipping to change at line 25
//! Class for finding minimum values in a matrix //! Class for finding minimum values in a matrix
class op_min class op_min
{ {
public: public:
template<typename eT> template<typename eT>
inline static eT direct_min(const eT* const X, const u32 N); inline static eT direct_min(const eT* const X, const u32 N);
template<typename eT> template<typename eT>
inline static eT direct_min(const eT* const X, const u32 N, u32& index_of
_min_val);
template<typename eT>
inline static eT direct_min(const Mat<eT>& X, const u32 row);
template<typename eT>
inline static eT direct_min(const subview<eT>& X); inline static eT direct_min(const subview<eT>& X);
template<typename eT> template<typename eT>
inline static eT direct_min(const diagview<eT>& X); inline static eT direct_min(const diagview<eT>& X);
template<typename T1> template<typename T1>
inline static void apply(Mat<typename T1::elem_type>& out, const Op<T1,op _min>& in); inline static void apply(Mat<typename T1::elem_type>& out, const Op<T1,op _min>& in);
// //
// for complex numbers // for complex numbers
template<typename T> template<typename T>
inline static std::complex<T> direct_min(const std::complex<T>* const X, const u32 n_elem); inline static std::complex<T> direct_min(const std::complex<T>* const X, const u32 n_elem);
template<typename T> template<typename T>
inline static std::complex<T> direct_min(const std::complex<T>* const X,
const u32 n_elem, u32& index_of_min_val);
template<typename T>
inline static std::complex<T> direct_min(const Mat< std::complex<T> >& X,
const u32 row);
template<typename T>
inline static std::complex<T> direct_min(const subview< std::complex<T> > &X); inline static std::complex<T> direct_min(const subview< std::complex<T> > &X);
template<typename T> template<typename T>
inline static std::complex<T> direct_min(const diagview< std::complex<T> >&X); inline static std::complex<T> direct_min(const diagview< std::complex<T> >&X);
template<typename T, typename T1>
inline static void apply(Mat< std::complex<T> >& out, const Op<T1,op_min>
& in);
}; };
//! @} //! @}
 End of changes. 4 change blocks. 
6 lines changed or deleted 17 lines changed or added


 op_stddev_meat.hpp   op_stddev_meat.hpp 
// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) // Copyright (C) 2009-2011 NICTA (www.nicta.com.au)
// Copyright (C) 2009-2010 Conrad Sanderson // Copyright (C) 2009-2011 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_stddev //! \addtogroup op_stddev
//! @{ //! @{
//! \brief //! \brief
//! For each row or for each column, find the standard deviation. //! For each row or for each column, find the standard deviation.
//! The result is stored in a dense matrix that has either one column or on e row. //! The result is stored in a dense matrix that has either one column or on e row.
//! The dimension for which the standard deviations are found is set via th e stddev() function. //! The dimension for which the standard deviations are found is set via th e stddev() function.
template<typename eT> template<typename T1>
inline inline
void void
op_stddev::apply(Mat< typename get_pod_type<eT>::result >& out, const Mat<e T>& X, const u32 norm_type, const u32 dim) op_stddev::apply(Mat<typename T1::pod_type>& out, const mtOp<typename T1::p od_type, T1, op_stddev>& in)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_debug_check( (X.n_elem == 0), "stddev(): given matrix has no element typedef typename T1::elem_type in_eT;
s" ); typedef typename T1::pod_type out_eT;
const unwrap_check_mixed<T1> tmp(in.m, out);
const Mat<in_eT>& X = tmp.M;
const u32 norm_type = in.aux_u32_a;
const u32 dim = in.aux_u32_b;
arma_debug_check( (X.n_elem == 0), "stddev(): given matrix has no element
s" );
arma_debug_check( (norm_type > 1), "stddev(): incorrect usage. norm_type must be 0 or 1"); arma_debug_check( (norm_type > 1), "stddev(): incorrect usage. norm_type must be 0 or 1");
arma_debug_check( (dim > 1), "stddev(): incorrect usage. dim must b e 0 or 1" ); arma_debug_check( (dim > 1), "stddev(): incorrect usage. dim must b e 0 or 1" );
const u32 X_n_rows = X.n_rows;
const u32 X_n_cols = X.n_cols;
if(dim == 0) if(dim == 0)
{ {
arma_extra_debug_print("op_stddev::apply(), dim = 0"); arma_extra_debug_print("op_stddev::apply(), dim = 0");
out.set_size(1, X.n_cols); out.set_size(1, X_n_cols);
for(u32 col=0; col<X.n_cols; ++col) for(u32 col=0; col<X_n_cols; ++col)
{ {
out[col] = std::sqrt( op_var::direct_var( X.colptr(col), X.n_rows, no rm_type ) ); out[col] = std::sqrt( op_var::direct_var( X.colptr(col), X_n_rows, no rm_type ) );
} }
} }
else else
if(dim == 1) if(dim == 1)
{ {
arma_extra_debug_print("op_stddev::apply(), dim = 1"); arma_extra_debug_print("op_stddev::apply(), dim = 1");
const u32 n_rows = X.n_rows; out.set_size(X_n_rows, 1);
const u32 n_cols = X.n_cols;
out.set_size(n_rows, 1); podarray<in_eT> tmp(X_n_cols);
podarray<eT> tmp(n_cols); in_eT* tmp_mem = tmp.memptr();
eT* tmp_mem = tmp.memptr(); for(u32 row=0; row<X_n_rows; ++row)
for(u32 row=0; row<n_rows; ++row)
{ {
for(u32 col=0; col<n_cols; ++col) for(u32 col=0; col<X_n_cols; ++col)
{ {
tmp_mem[col] = X.at(row,col); tmp_mem[col] = X.at(row,col);
} }
out[row] = std::sqrt( op_var::direct_var(tmp_mem, n_cols, norm_type) ); out[row] = std::sqrt( op_var::direct_var(tmp_mem, X_n_cols, norm_type ) );
} }
} }
} }
//! @} //! @}
 End of changes. 17 change blocks. 
20 lines changed or deleted 26 lines changed or added


 op_stddev_proto.hpp   op_stddev_proto.hpp 
// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) // Copyright (C) 2009-2011 NICTA (www.nicta.com.au)
// Copyright (C) 2009-2010 Conrad Sanderson // Copyright (C) 2009-2011 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_stddev //! \addtogroup op_stddev
//! @{ //! @{
//! Class for finding the standard deviation //! Class for finding the standard deviation
class op_stddev class op_stddev
{ {
public: public:
template<typename eT> template<typename T1>
inline static void apply(Mat< typename get_pod_type<eT>::result >& out, c inline static void apply(Mat<typename T1::pod_type>& out, const mtOp<type
onst Mat<eT>& X, const u32 norm_type, const u32 dim); name T1::pod_type, T1, op_stddev>& in);
}; };
//! @} //! @}
 End of changes. 2 change blocks. 
6 lines changed or deleted 5 lines changed or added


 op_var_meat.hpp   op_var_meat.hpp 
skipping to change at line 24 skipping to change at line 24
//! @{ //! @{
//! find the variance of an array //! find the variance of an array
template<typename eT> template<typename eT>
inline inline
eT eT
op_var::direct_var(const eT* const X, const u32 n_elem, const u32 norm_type ) op_var::direct_var(const eT* const X, const u32 n_elem, const u32 norm_type )
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
const eT div_val = (n_elem > 0) ? eT(n_elem) : eT(1); if(n_elem > 1)
{
const eT acc1 = op_mean::direct_mean(X, n_elem);
const eT acc1 = arrayops::accumulate(X,n_elem) / div_val; eT acc2 = eT(0);
eT acc3 = eT(0);
eT acc2 = eT(0); u32 i,j;
eT acc3 = eT(0);
for(u32 i=0; i<n_elem; ++i) for(i=0, j=1; j<n_elem; i+=2, j+=2)
{ {
const eT tmp = acc1 - X[i]; const eT Xi = X[i];
const eT Xj = X[j];
acc2 += tmp*tmp; const eT tmpi = acc1 - Xi;
acc3 += tmp; const eT tmpj = acc1 - Xj;
}
acc2 += tmpi*tmpi + tmpj*tmpj;
acc3 += tmpi + tmpj;
}
if(i < n_elem)
{
const eT Xi = X[i];
const eT norm_val = (norm_type == 0) ? ( (n_elem > 1) ? eT(n_elem-1) : eT const eT tmpi = acc1 - Xi;
(1) ) : eT(n_elem);
const eT var_val = (acc2 - acc3*acc3/div_val) / norm_val;
return var_val; acc2 += tmpi*tmpi;
acc3 += tmpi;
}
const eT norm_val = (norm_type == 0) ? eT(n_elem-1) : eT(n_elem);
const eT var_val = (acc2 - acc3*acc3/eT(n_elem)) / norm_val;
return arma_isfinite(var_val) ? var_val : op_var::direct_var_robust(X,
n_elem, norm_type);
}
else
{
return eT(0);
}
} }
//! find the variance of an array (version for complex numbers) //! find the variance of an array (version for complex numbers)
template<typename T> template<typename T>
inline inline
T T
op_var::direct_var(const std::complex<T>* const X, const u32 n_elem, const u32 norm_type) op_var::direct_var(const std::complex<T>* const X, const u32 n_elem, const u32 norm_type)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
typedef typename std::complex<T> eT; typedef typename std::complex<T> eT;
const T div_val = (n_elem > 0) ? T(n_elem) : T(1); if(n_elem > 1)
{
const eT acc1 = arrayops::accumulate(X,n_elem) / div_val; const eT acc1 = op_mean::direct_mean(X, n_elem);
T acc2 = T(0); T acc2 = T(0);
eT acc3 = eT(0); eT acc3 = eT(0);
for(u32 i=0; i<n_elem; ++i) for(u32 i=0; i<n_elem; ++i)
{ {
const eT tmp = acc1 - X[i]; const eT tmp = acc1 - X[i];
acc2 += std::norm(tmp); acc2 += std::norm(tmp);
acc3 += tmp; acc3 += tmp;
} }
const T norm_val = (norm_type == 0) ? ( (n_elem > 1) ? T(n_elem-1) : T(1) const T norm_val = (norm_type == 0) ? T(n_elem-1) : T(n_elem);
) : T(n_elem); const T var_val = (acc2 - std::norm(acc3)/T(n_elem)) / norm_val;
const T var_val = (acc2 - std::norm(acc3)/div_val) / norm_val;
return var_val; return arma_isfinite(var_val) ? var_val : op_var::direct_var_robust(X,
n_elem, norm_type);
}
else
{
return T(0);
}
} }
//! find the variance of a subview_row //! find the variance of a subview_row
template<typename eT> template<typename eT>
inline inline
typename get_pod_type<eT>::result typename get_pod_type<eT>::result
op_var::direct_var(const subview_row<eT>& X, const u32 norm_type) op_var::direct_var(const subview_row<eT>& X, const u32 norm_type)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
skipping to change at line 135 skipping to change at line 161
tmp_mem[i] = X[i]; tmp_mem[i] = X[i];
} }
return op_var::direct_var(tmp_mem, n_elem, norm_type); return op_var::direct_var(tmp_mem, n_elem, norm_type);
} }
//! \brief //! \brief
//! For each row or for each column, find the variance. //! For each row or for each column, find the variance.
//! The result is stored in a dense matrix that has either one column or on e row. //! The result is stored in a dense matrix that has either one column or on e row.
//! The dimension, for which the variances are found, is set via the var() function. //! The dimension, for which the variances are found, is set via the var() function.
template<typename eT> template<typename T1>
inline inline
void void
op_var::apply(Mat< typename get_pod_type<eT>::result >& out, const Mat<eT>& X, const u32 norm_type, const u32 dim) op_var::apply(Mat<typename T1::pod_type>& out, const mtOp<typename T1::pod_ type, T1, op_var>& in)
{ {
arma_extra_debug_sigprint(); arma_extra_debug_sigprint();
arma_debug_check( (X.n_elem == 0), "var(): given matrix has no elements" typedef typename T1::elem_type in_eT;
); typedef typename T1::pod_type out_eT;
const unwrap_check_mixed<T1> tmp(in.m, out);
const Mat<in_eT>& X = tmp.M;
const u32 norm_type = in.aux_u32_a;
const u32 dim = in.aux_u32_b;
arma_debug_check( (X.n_elem == 0), "var(): given matrix has no elements" );
arma_debug_check( (norm_type > 1), "var(): incorrect usage. norm_type mus t be 0 or 1"); arma_debug_check( (norm_type > 1), "var(): incorrect usage. norm_type mus t be 0 or 1");
arma_debug_check( (dim > 1), "var(): incorrect usage. dim must be 0 or 1" ); arma_debug_check( (dim > 1), "var(): incorrect usage. dim must be 0 or 1" );
const u32 X_n_rows = X.n_rows;
const u32 X_n_cols = X.n_cols;
if(dim == 0) if(dim == 0)
{ {
arma_extra_debug_print("op_var::apply(), dim = 0"); arma_extra_debug_print("op_var::apply(), dim = 0");
out.set_size(1, X.n_cols); out.set_size(1, X_n_cols);
for(u32 col=0; col<X.n_cols; ++col) for(u32 col=0; col<X_n_cols; ++col)
{ {
out[col] = op_var::direct_var( X.colptr(col), X.n_rows, norm_type ); out[col] = op_var::direct_var( X.colptr(col), X_n_rows, norm_type );
} }
} }
else else
if(dim == 1) if(dim == 1)
{ {
arma_extra_debug_print("op_var::apply(), dim = 1"); arma_extra_debug_print("op_var::apply(), dim = 1");
const u32 n_rows = X.n_rows; out.set_size(X_n_rows, 1);
const u32 n_cols = X.n_cols;
out.set_size(n_rows, 1);
podarray<eT> tmp(n_cols); podarray<in_eT> tmp(X_n_cols);
eT* tmp_mem = tmp.memptr(); in_eT* tmp_mem = tmp.memptr();
for(u32 row=0; row<n_rows; ++row) for(u32 row=0; row<X_n_rows; ++row)
{ {
for(u32 col=0; col<n_cols; ++col) for(u32 col=0; col<X_n_cols; ++col)
{ {
tmp_mem[col] = X.at(row,col); tmp_mem[col] = X.at(row,col);
} }
out[row] = op_var::direct_var(tmp_mem, n_cols, norm_type); out[row] = op_var::direct_var(tmp_mem, X_n_cols, norm_type);
}
}
}
//! find the variance of an array (robust but slow)
template<typename eT>
inline
eT
op_var::direct_var_robust(const eT* const X, const u32 n_elem, const u32 no
rm_type)
{
arma_extra_debug_sigprint();
if(n_elem > 1)
{
eT r_mean = X[0];
eT r_var = eT(0);
for(u32 i=1; i<n_elem; ++i)
{
const eT tmp = X[i] - r_mean;
const eT i_plus_1 = eT(i+1);
r_var = eT(i-1)/eT(i) * r_var + (tmp*tmp)/i_plus_1;
r_mean = r_mean + tmp/i_plus_1;
}
return (norm_type == 0) ? r_var : (eT(n_elem-1)/eT(n_elem)) * r_var;
}
else
{
return eT(0);
}
}
//! find the variance of an array (version for complex numbers) (robust but
slow)
template<typename T>
inline
T
op_var::direct_var_robust(const std::complex<T>* const X, const u32 n_elem,
const u32 norm_type)
{
arma_extra_debug_sigprint();
typedef typename std::complex<T> eT;
if(n_elem > 1)
{
eT r_mean = X[0];
T r_var = T(0);
for(u32 i=1; i<n_elem; ++i)
{
const eT tmp = X[i] - r_mean;
const T i_plus_1 = T(i+1);
r_var = T(i-1)/T(i) * r_var + std::norm(tmp)/i_plus_1;
r_mean = r_mean + tmp/i_plus_1;
} }
return (norm_type == 0) ? r_var : (T(n_elem-1)/T(n_elem)) * r_var;
}
else
{
return T(0);
} }
} }
//! @} //! @}
 End of changes. 28 change blocks. 
45 lines changed or deleted 145 lines changed or added


 op_var_proto.hpp   op_var_proto.hpp 
// Copyright (C) 2009-2010 NICTA (www.nicta.com.au) // Copyright (C) 2009-2011 NICTA (www.nicta.com.au)
// Copyright (C) 2009-2010 Conrad Sanderson // Copyright (C) 2009-2011 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 25 skipping to change at line 25
//! Class for finding variance values of a matrix //! Class for finding variance values of a matrix
class op_var class op_var
{ {
public: public:
template<typename eT> template<typename eT>
inline static eT direct_var(const eT* const X, const u32 N, const u32 nor m_type = 0); inline static eT direct_var(const eT* const X, const u32 N, const u32 nor m_type = 0);
template<typename T> template<typename T>
inline static T direct_var(const std::complex<T>* const X, const u32 N, c onst u32 norm_type = 0); inline static T direct_var(const std::complex<T>* const X, const u32 N, const u32 norm_type = 0);
template<typename eT> template<typename eT>
inline static typename get_pod_type<eT>::result direct_var(const subview_ row<eT>& X, const u32 norm_type = 0); inline static typename get_pod_type<eT>::result direct_var(const subview_ row<eT>& X, const u32 norm_type = 0);
template<typename eT> template<typename eT>
inline static typename get_pod_type<eT>::result direct_var(const subview_ col<eT>& X, const u32 norm_type = 0); inline static typename get_pod_type<eT>::result direct_var(const subview_ col<eT>& X, const u32 norm_type = 0);
template<typename eT> template<typename eT>
inline static typename get_pod_type<eT>::result direct_var(const diagview <eT>& X, const u32 norm_type = 0); inline static typename get_pod_type<eT>::result direct_var(const diagview <eT>& X, const u32 norm_type = 0);
template<typename T1>
inline static void apply(Mat<typename T1::pod_type>& out, const mtOp<type
name T1::pod_type, T1, op_var>& in);
template<typename eT> template<typename eT>
inline static void apply(Mat< typename get_pod_type<eT>::result >& out, c onst Mat<eT>& X, const u32 norm_type, const u32 dim); inline static eT direct_var_robust(const eT* const X, const u32 N, const u32 norm_type = 0);
template<typename T>
inline static T direct_var_robust(const std::complex<T>* const X, const
u32 N, const u32 norm_type = 0);
}; };
//! @} //! @}
 End of changes. 5 change blocks. 
4 lines changed or deleted 11 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/