Fn_trace

Functions

template<typename T1 >
T1::elem_type trace (const Base< typename T1::elem_type, T1 > &X)
 Immediate trace (sum of diagonal elements) of a square dense matrix.
template<typename T1 , typename T2 >
T1::elem_type trace (const Glue< T1, T2, glue_plus > &X)
 Immediate trace (sum of diagonal elements) of A + B. A and B must be square and have the same dimensions.
template<typename T1 , typename T2 >
T1::elem_type trace (const Glue< T1, T2, glue_minus > &X)
 Immediate trace (sum of diagonal elements) of A - B. A and B must be square and have the same dimensions.
template<typename T1 , typename T2 >
T1::elem_type trace (const Glue< T1, T2, glue_schur > &X)
 Immediate trace (sum of diagonal elements) of A % B (where % is the element-wise multiplication operator). A and B must be square and have the same dimensions.
template<typename T1 >
T1::elem_type trace (const Op< T1, op_scalar_times > &in)
 trace (sum of diagonal elements) of k * T1, where k is a scalar and T1 is converted to a dense matrix.
template<typename eT >
eT trace (const Op< Mat< eT >, op_diagmat > &X)
 trace (sum of diagonal elements) of a diagonal matrix
template<typename eT >
eT trace (const Op< Mat< eT >, op_diagmat_vec > &X)

Function Documentation

template<typename T1 >
T1::elem_type trace ( const Base< typename T1::elem_type, T1 > &  X  )  [inline]

Immediate trace (sum of diagonal elements) of a square dense matrix.

Definition at line 24 of file fn_trace.hpp.

References Base< elem_type, derived >::get_ref().

Referenced by trace().

00025   {
00026   arma_extra_debug_sigprint();
00027   
00028   typedef typename T1::elem_type eT;
00029   
00030   const unwrap<T1> A_tmp(X.get_ref());
00031   const Mat<eT>& A = A_tmp.M;
00032 
00033   arma_debug_check( !A.is_square(), "trace(): matrix must be square" );
00034   
00035   eT val = eT(0);
00036   
00037   for(u32 i=0; i<A.n_rows; ++i)
00038     {
00039     val += A.at(i,i);
00040     }
00041   
00042   return val;
00043   }

template<typename T1 , typename T2 >
T1::elem_type trace ( const Glue< T1, T2, glue_plus > &  X  )  [inline]

Immediate trace (sum of diagonal elements) of A + B. A and B must be square and have the same dimensions.

Definition at line 57 of file fn_trace.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, isnt_same_type< T1, T2 >::check(), Mat< eT >::is_square(), and trace().

00058   {
00059   arma_extra_debug_sigprint();
00060 
00061   isnt_same_type<typename T1::elem_type, typename T2::elem_type>::check();
00062   
00063   const unwrap<T1> tmp1(X.A);
00064   const unwrap<T2> tmp2(X.B);
00065   
00066   typedef typename T1::elem_type eT;
00067   
00068   const Mat<eT>& A = tmp1.M;
00069   const Mat<eT>& B = tmp2.M;
00070   
00071   arma_debug_assert_same_size(A, B, "matrix addition");
00072   arma_debug_check( !A.is_square(), "trace(): matrices must be square");
00073   
00074   return trace(A) + trace(B);
00075   }

template<typename T1 , typename T2 >
T1::elem_type trace ( const Glue< T1, T2, glue_minus > &  X  )  [inline]

Immediate trace (sum of diagonal elements) of A - B. A and B must be square and have the same dimensions.

Definition at line 85 of file fn_trace.hpp.

References Glue< T1, T2, glue_type >::A, Glue< T1, T2, glue_type >::B, isnt_same_type< T1, T2 >::check(), Mat< eT >::is_square(), and trace().

00086   {
00087   arma_extra_debug_sigprint();
00088 
00089   isnt_same_type<typename T1::elem_type, typename T2::elem_type>::check();
00090   
00091   const unwrap<T1> tmp1(X.A);
00092   const unwrap<T2> tmp2(X.B);
00093   
00094   typedef typename T1::elem_type eT;
00095   
00096   const Mat<eT>& A = tmp1.M;
00097   const Mat<eT>& B = tmp2.M;
00098 
00099   arma_debug_assert_same_size(A, B, "matrix subtraction");
00100   arma_debug_check( !A.is_square(), "trace(): matrices must be square");
00101   
00102   return trace(A) - trace(B);
00103   }

template<typename T1 , typename T2 >
T1::elem_type trace ( const Glue< T1, T2, glue_schur > &  X  )  [inline]

Immediate trace (sum of diagonal elements) of A % B (where % is the element-wise multiplication operator). A and B must be square and have the same dimensions.

Definition at line 113 of file fn_trace.hpp.

References Glue< T1, T2, glue_type >::A, Mat< eT >::at(), Glue< T1, T2, glue_type >::B, isnt_same_type< T1, T2 >::check(), Mat< eT >::is_square(), and Mat< eT >::n_rows.

00114   {
00115   arma_extra_debug_sigprint();
00116   
00117   isnt_same_type<typename T1::elem_type, typename T2::elem_type>::check();
00118 
00119   const unwrap<T1> tmp1(X.A);
00120   const unwrap<T2> tmp2(X.B);
00121   
00122   typedef typename T1::elem_type eT;
00123   
00124   const Mat<eT>& A = tmp1.M;
00125   const Mat<eT>& B = tmp2.M;
00126   
00127   arma_debug_assert_same_size(A, B, "matrix schur product");
00128   arma_debug_check( !A.is_square(), "trace(): matrices must be square" );
00129   
00130   eT val = eT(0);
00131   for(u32 i=0; i<A.n_rows; ++i)
00132     {
00133     val += A.at(i,i) * B.at(i,i);
00134     }
00135   
00136   return val;
00137   }

template<typename T1 >
T1::elem_type trace ( const Op< T1, op_scalar_times > &  in  )  [inline]

trace (sum of diagonal elements) of k * T1, where k is a scalar and T1 is converted to a dense matrix.

Definition at line 147 of file fn_trace.hpp.

References Op< T1, op_type >::aux, Op< T1, op_type >::m, and trace().

00148   {
00149   arma_extra_debug_sigprint();
00150   
00151   typedef typename T1::elem_type eT;
00152   
00153   const unwrap<T1> tmp(in.m);
00154   const Mat<eT>& X = tmp.M;
00155   
00156   return trace(X) * in.aux;
00157   }

template<typename eT >
eT trace ( const Op< Mat< eT >, op_diagmat > &  X  )  [inline]

trace (sum of diagonal elements) of a diagonal matrix

Definition at line 165 of file fn_trace.hpp.

References trace().

00166   {
00167   arma_extra_debug_sigprint();
00168   
00169   return trace(X.m);
00170   }

template<typename eT >
eT trace ( const Op< Mat< eT >, op_diagmat_vec > &  X  )  [inline]

Definition at line 177 of file fn_trace.hpp.

References accu(), and Mat< eT >::is_vec().

00178   {
00179   arma_extra_debug_sigprint();
00180   
00181   const Mat<eT>& A = X.m;
00182   arma_debug_check( !A.is_vec(), "trace(): internal error: can't interpret as a vector" );
00183   
00184   
00185   return accu(X.m);
00186   }