Running_stat_vec

Classes

class  running_stat_vec< eT >
 Class for keeping statistics of a continuously sampled process / signal. Useful if the storage of individual samples is not necessary or desired. Also useful if the number of samples is not known beforehand or exceeds available memory. More...
class  running_stat_vec_aux

Functions

 running_stat_vec::~running_stat_vec ()
 running_stat_vec::running_stat_vec (const bool in_calc_cov=false)
template<typename T1 >
void running_stat_vec::operator() (const Base< T, T1 > &X)
 update statistics to reflect new sample
template<typename T1 >
void running_stat_vec::operator() (const Base< std::complex< T >, T1 > &X)
 update statistics to reflect new sample (version for complex numbers)
void running_stat_vec::reset ()
 set all statistics to zero
Mat< eT > running_stat_vec::mean () const
 mean or average value
Mat< T > running_stat_vec::var (const u32 norm_type=0) const
 variance
Mat< T > running_stat_vec::stddev (const u32 norm_type=0) const
 standard deviation
Mat< eT > running_stat_vec::cov (const u32 norm_type=0) const
 covariance
Mat< eT > running_stat_vec::min () const
 vector with minimum values
Mat< eT > running_stat_vec::max () const
 vector with maximum values
template<typename eT >
static void running_stat_vec_aux::update_stats (running_stat_vec< eT > &x, const Mat< eT > &sample)
 update statistics to reflect new sample
template<typename T >
static void running_stat_vec_aux::update_stats (running_stat_vec< std::complex< T > > &x, const Mat< T > &sample)
 update statistics to reflect new sample (version for complex numbers)
template<typename T >
static void running_stat_vec_aux::update_stats (running_stat_vec< std::complex< T > > &x, const Mat< std::complex< T > > &sample)
 alter statistics to reflect new sample (version for complex numbers)

Function Documentation

template<typename eT >
running_stat_vec< eT >::~running_stat_vec (  )  [inline, inherited]

Definition at line 23 of file running_stat_vec_meat.hpp.

00024   {
00025   arma_extra_debug_sigprint_this(this);
00026   }

template<typename eT >
running_stat_vec< eT >::running_stat_vec ( const bool  in_calc_cov = false  )  [inline, inherited]

Definition at line 31 of file running_stat_vec_meat.hpp.

00032   : calc_cov(in_calc_cov)
00033   {
00034   arma_extra_debug_sigprint_this(this);
00035   }

template<typename eT >
template<typename T1 >
void running_stat_vec< eT >::operator() ( const Base< T, T1 > &  X  )  [inline, inherited]

update statistics to reflect new sample

Definition at line 44 of file running_stat_vec_meat.hpp.

References arma_check(), and running_stat_vec_aux::update_stats().

00045   {
00046   arma_extra_debug_sigprint();
00047   
00048   //typedef typename get_pod_type<eT>::result T;
00049   
00050   const unwrap<T1>        tmp(X.get_ref());
00051   const Mat<eT>& sample = tmp.M;
00052   
00053   arma_check( (sample.is_finite() == false), "running_stat_vec: given sample has non-finite elements" );
00054   
00055   running_stat_vec_aux::update_stats(*this, sample);
00056   }

template<typename eT >
template<typename T1 >
void running_stat_vec< eT >::operator() ( const Base< std::complex< T >, T1 > &  X  )  [inline, inherited]

update statistics to reflect new sample (version for complex numbers)

Definition at line 65 of file running_stat_vec_meat.hpp.

References arma_check(), and running_stat_vec_aux::update_stats().

00066   {
00067   arma_extra_debug_sigprint();
00068   
00069   //typedef typename std::complex<typename get_pod_type<eT>::result> eT;
00070   
00071   const unwrap<T1>        tmp(X.get_ref());
00072   const Mat<eT>& sample = tmp.M;
00073   
00074   arma_check( (sample.is_finite() == false), "running_stat_vec: given sample has non-finite elements" );
00075   
00076   running_stat_vec_aux::update_stats(*this, sample);
00077   }

template<typename eT >
void running_stat_vec< eT >::reset (  )  [inline, inherited]

set all statistics to zero

Definition at line 85 of file running_stat_vec_meat.hpp.

References running_stat_vec< eT >::counter, running_stat_vec< eT >::max_val, running_stat_vec< eT >::max_val_norm, running_stat_vec< eT >::min_val, running_stat_vec< eT >::min_val_norm, running_stat_vec< eT >::r_cov, running_stat_vec< eT >::r_mean, running_stat_vec< eT >::r_var, Mat< eT >::reset(), and arma_counter< eT >::reset().

00086   {
00087   arma_extra_debug_sigprint();
00088   
00089   counter.reset();
00090   
00091   r_mean.reset();
00092   r_var.reset();
00093   r_cov.reset();
00094   
00095   min_val.reset();
00096   max_val.reset();
00097   
00098   min_val_norm.reset();
00099   max_val_norm.reset();
00100   }

template<typename eT >
Mat< eT > running_stat_vec< eT >::mean (  )  const [inline, inherited]

mean or average value

Definition at line 108 of file running_stat_vec_meat.hpp.

References running_stat_vec< eT >::r_mean.

00110   {
00111   arma_extra_debug_sigprint();
00112   
00113   return r_mean;
00114   }

template<typename eT >
Mat< typename get_pod_type< eT >::result > running_stat_vec< eT >::var ( const u32  norm_type = 0  )  const [inline, inherited]

variance

Definition at line 122 of file running_stat_vec_meat.hpp.

References running_stat_vec< eT >::counter, running_stat_vec< eT >::r_mean, running_stat_vec< eT >::r_var, arma_counter< eT >::value(), and arma_counter< eT >::value_minus_1().

00124   {
00125   arma_extra_debug_sigprint();
00126   
00127   const T N = counter.value();
00128   
00129   if(N > T(1))
00130     {
00131     if(norm_type == 0)
00132       {
00133       return r_var;
00134       }
00135     else
00136       {
00137       const T N_minus_1 = counter.value_minus_1();
00138       return (N_minus_1/N) * r_var;
00139       }
00140     }
00141   else
00142     {
00143     return zeros< Mat<typename get_pod_type<eT>::result> >(r_mean.n_rows, r_mean.n_cols);
00144     }
00145   
00146   }

template<typename eT >
Mat< typename get_pod_type< eT >::result > running_stat_vec< eT >::stddev ( const u32  norm_type = 0  )  const [inline, inherited]

standard deviation

Definition at line 154 of file running_stat_vec_meat.hpp.

References sqrt().

00156   {
00157   arma_extra_debug_sigprint();
00158   
00159   return sqrt( (*this).var(norm_type) );
00160   }

template<typename eT >
Mat< eT > running_stat_vec< eT >::cov ( const u32  norm_type = 0  )  const [inline, inherited]

covariance

Definition at line 168 of file running_stat_vec_meat.hpp.

References running_stat_vec< eT >::calc_cov, running_stat_vec< eT >::counter, running_stat_vec< eT >::r_cov, running_stat_vec< eT >::r_mean, arma_counter< eT >::value(), and arma_counter< eT >::value_minus_1().

00170   {
00171   arma_extra_debug_sigprint();
00172   
00173   if(calc_cov == true)
00174     {
00175     const T N = counter.value();
00176     
00177     if(N > T(1))
00178       {
00179       if(norm_type == 0)
00180         {
00181         return r_cov;
00182         }
00183       else
00184         {
00185         const T N_minus_1 = counter.value_minus_1();
00186         return (N_minus_1/N) * r_cov;
00187         }
00188       }
00189     else
00190       {
00191       return zeros< Mat<eT> >(r_mean.n_rows, r_mean.n_cols);
00192       }
00193     }
00194   else
00195     {
00196     return Mat<eT>();
00197     }
00198   
00199   }

template<typename eT >
Mat< eT > running_stat_vec< eT >::min (  )  const [inline, inherited]

vector with minimum values

Definition at line 207 of file running_stat_vec_meat.hpp.

References running_stat_vec< eT >::min_val.

00209   {
00210   arma_extra_debug_sigprint();
00211 
00212   return min_val;
00213   }

template<typename eT >
Mat< eT > running_stat_vec< eT >::max (  )  const [inline, inherited]

vector with maximum values

Definition at line 221 of file running_stat_vec_meat.hpp.

References running_stat_vec< eT >::max_val.

00223   {
00224   arma_extra_debug_sigprint();
00225 
00226   return max_val;
00227   }

template<typename eT >
void running_stat_vec_aux::update_stats ( running_stat_vec< eT > &  x,
const Mat< eT > &  sample 
) [inline, static, inherited]

update statistics to reflect new sample

Definition at line 239 of file running_stat_vec_meat.hpp.

References running_stat_vec< eT >::calc_cov, running_stat_vec< eT >::counter, Mat< eT >::is_vec(), running_stat_vec< eT >::max_val, Mat< eT >::memptr(), running_stat_vec< eT >::min_val, Mat< eT >::n_cols, Mat< eT >::n_elem, Mat< eT >::n_rows, running_stat_vec< eT >::r_cov, running_stat_vec< eT >::r_mean, running_stat_vec< eT >::r_var, trans(), arma_counter< eT >::value(), arma_counter< eT >::value_minus_1(), arma_counter< eT >::value_plus_1(), and Mat< eT >::zeros().

Referenced by running_stat_vec< eT >::operator()(), and running_stat_vec_aux::update_stats().

00240   {
00241   arma_extra_debug_sigprint();
00242   
00243   typedef typename running_stat_vec<eT>::T T;
00244   
00245   const T N = x.counter.value();
00246   
00247   if(N > T(0))
00248     {
00249     arma_debug_assert_same_size(x.r_mean, sample, "running_stat_vec(): dimensionality mismatch");
00250     
00251     const u32 n_elem      = sample.n_elem;
00252     const eT* sample_mem  = sample.memptr();
00253           eT* r_mean_mem  = x.r_mean.memptr();
00254            T* r_var_mem   = x.r_var.memptr();
00255           eT* min_val_mem = x.min_val.memptr();
00256           eT* max_val_mem = x.max_val.memptr();
00257     
00258     const T  N_plus_1   = x.counter.value_plus_1();
00259     const T  N_minus_1  = x.counter.value_minus_1();
00260     
00261     if(x.calc_cov == true)
00262       {
00263       const Mat<eT> tmp1 = sample - x.r_mean;
00264       
00265       Mat<eT> tmp2;
00266       
00267       if(sample.n_cols == 1)
00268         {
00269         tmp2 = tmp1*trans(tmp1);
00270         }
00271       else
00272         {
00273         tmp2 = trans(tmp1)*tmp1;
00274         }
00275       
00276       x.r_cov *= (N_minus_1/N);
00277       x.r_cov += tmp2 / N_plus_1;
00278       }
00279     
00280     
00281     for(u32 i=0; i<n_elem; ++i)
00282       {
00283       const eT val = sample_mem[i];
00284       
00285       if(val < min_val_mem[i])
00286         {
00287         min_val_mem[i] = val;
00288         }
00289       
00290       if(val > max_val_mem[i])
00291         {
00292         max_val_mem[i] = val;
00293         }
00294         
00295       const eT r_mean_val = r_mean_mem[i];
00296       const eT tmp        = val - r_mean_val;
00297     
00298       r_var_mem[i] = N_minus_1/N * r_var_mem[i] + (tmp*tmp)/N_plus_1;
00299       
00300       r_mean_mem[i] = r_mean_val + (val - r_mean_val)/N_plus_1;
00301       }
00302     }
00303   else
00304     {
00305     arma_debug_check( (sample.is_vec() == false), "running_stat_vec(): given sample is not a vector");
00306     
00307     x.r_mean.set_size(sample.n_rows, sample.n_cols);
00308     
00309     x.r_var.zeros(sample.n_rows, sample.n_cols);
00310     
00311     if(x.calc_cov == true)
00312       {
00313       x.r_cov.zeros(sample.n_elem, sample.n_elem);
00314       }
00315     
00316     x.min_val.set_size(sample.n_rows, sample.n_cols);
00317     x.max_val.set_size(sample.n_rows, sample.n_cols);
00318     
00319     
00320     const u32 n_elem      = sample.n_elem;
00321     const eT* sample_mem  = sample.memptr();
00322           eT* r_mean_mem  = x.r_mean.memptr();
00323           eT* min_val_mem = x.min_val.memptr();
00324           eT* max_val_mem = x.max_val.memptr();
00325           
00326     
00327     for(u32 i=0; i<n_elem; ++i)
00328       {
00329       const eT val = sample_mem[i];
00330       
00331       r_mean_mem[i]  = val;
00332       min_val_mem[i] = val;
00333       max_val_mem[i] = val;
00334       }
00335     }
00336   
00337   x.counter++;
00338   }

template<typename T >
void running_stat_vec_aux::update_stats ( running_stat_vec< std::complex< T > > &  x,
const Mat< T > &  sample 
) [inline, static, inherited]

update statistics to reflect new sample (version for complex numbers)

Definition at line 346 of file running_stat_vec_meat.hpp.

References running_stat_vec_aux::update_stats().

00347   {
00348   arma_extra_debug_sigprint();
00349   
00350   const Mat< std::complex<T> > tmp = conv_to< Mat< std::complex<T> > >::from(sample);
00351   
00352   running_stat_vec_aux::update_stats(x, tmp);
00353   }

template<typename T >
void running_stat_vec_aux::update_stats ( running_stat_vec< std::complex< T > > &  x,
const Mat< std::complex< T > > &  sample 
) [inline, static, inherited]

alter statistics to reflect new sample (version for complex numbers)

Definition at line 361 of file running_stat_vec_meat.hpp.

References conj(), norm(), and trans().

00362   {
00363   arma_extra_debug_sigprint();
00364   
00365   typedef typename std::complex<T> eT;
00366   
00367   const T N = x.counter.value();
00368   
00369   if(N > T(0))
00370     {
00371     arma_debug_assert_same_size(x.r_mean, sample, "running_stat_vec(): dimensionality mismatch");
00372     
00373     const u32 n_elem           = sample.n_elem;
00374     const eT* sample_mem       = sample.memptr();
00375           eT* r_mean_mem       = x.r_mean.memptr();
00376            T* r_var_mem        = x.r_var.memptr();
00377           eT* min_val_mem      = x.min_val.memptr();
00378           eT* max_val_mem      = x.max_val.memptr();
00379            T* min_val_norm_mem = x.min_val_norm.memptr();
00380            T* max_val_norm_mem = x.max_val_norm.memptr();
00381     
00382     const T  N_plus_1   = x.counter.value_plus_1();
00383     const T  N_minus_1  = x.counter.value_minus_1();
00384     
00385     if(x.calc_cov == true)
00386       {
00387       const Mat<eT> tmp1 = sample - x.r_mean;
00388       
00389       Mat<eT> tmp2;
00390       
00391       if(sample.n_cols == 1)
00392         {
00393         tmp2 = conj(tmp1)*trans(tmp1);
00394         }
00395       else
00396         {
00397         tmp2 = trans(conj(tmp1))*tmp1;
00398         }
00399       
00400       x.r_cov *= (N_minus_1/N);
00401       x.r_cov += tmp2 / N_plus_1;
00402       }
00403     
00404     
00405     for(u32 i=0; i<n_elem; ++i)
00406       {
00407       const eT& val      = sample_mem[i];
00408       const  T  val_norm = std::norm(val);
00409       
00410       if(val_norm < min_val_norm_mem[i])
00411         {
00412         min_val_norm_mem[i] = val_norm;
00413         min_val_mem[i]      = val;
00414         }
00415       
00416       if(val_norm > max_val_norm_mem[i])
00417         {
00418         max_val_norm_mem[i] = val_norm;
00419         max_val_mem[i]      = val;
00420         }
00421       
00422       const eT& r_mean_val = r_mean_mem[i];
00423       
00424       r_var_mem[i] = N_minus_1/N * r_var_mem[i] + std::norm(val - r_mean_val)/N_plus_1;
00425       
00426       r_mean_mem[i] = r_mean_val + (val - r_mean_val)/N_plus_1;
00427       }
00428     
00429     }
00430   else
00431     {
00432     arma_debug_check( (sample.is_vec() == false), "running_stat_vec(): given sample is not a vector");
00433     
00434     x.r_mean.set_size(sample.n_rows, sample.n_cols);
00435     
00436     x.r_var.zeros(sample.n_rows, sample.n_cols);
00437     
00438     if(x.calc_cov == true)
00439       {
00440       x.r_cov.zeros(sample.n_elem, sample.n_elem);
00441       }
00442     
00443     x.min_val.set_size(sample.n_rows, sample.n_cols);
00444     x.max_val.set_size(sample.n_rows, sample.n_cols);
00445     
00446     x.min_val_norm.set_size(sample.n_rows, sample.n_cols);
00447     x.max_val_norm.set_size(sample.n_rows, sample.n_cols);
00448     
00449     
00450     const u32 n_elem           = sample.n_elem;
00451     const eT* sample_mem       = sample.memptr();
00452           eT* r_mean_mem       = x.r_mean.memptr();
00453           eT* min_val_mem      = x.min_val.memptr();
00454           eT* max_val_mem      = x.max_val.memptr();
00455            T* min_val_norm_mem = x.min_val_norm.memptr();
00456            T* max_val_norm_mem = x.max_val_norm.memptr();
00457     
00458     for(u32 i=0; i<n_elem; ++i)
00459       {
00460       const eT& val      = sample_mem[i];
00461       const  T  val_norm = std::norm(val);
00462       
00463       r_mean_mem[i]  = val;
00464       min_val_mem[i] = val;
00465       max_val_mem[i] = val;
00466       
00467       min_val_norm_mem[i] = val_norm;
00468       max_val_norm_mem[i] = val_norm;
00469       }
00470     }
00471   
00472   x.counter++;
00473   }