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)
 running_stat_vec::running_stat_vec (const running_stat_vec &in_rsv)
const running_stat_vecrunning_stat_vec::operator= (const running_stat_vec &in_rsv)
template<typename T1 >
arma_hot void running_stat_vec::operator() (const Base< T, T1 > &X)
 update statistics to reflect new sample
template<typename T1 >
arma_hot 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
const Mat< eT > & running_stat_vec::mean () const
 mean or average value
const Mat< T > & running_stat_vec::var (const u32 norm_type=0)
 variance
Mat< T > running_stat_vec::stddev (const u32 norm_type=0) const
 standard deviation
const Mat< eT > & running_stat_vec::cov (const u32 norm_type=0)
 covariance
const Mat< eT > & running_stat_vec::min () const
 vector with minimum values
const 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 >
running_stat_vec< eT >::running_stat_vec ( const running_stat_vec< eT > &  in_rsv  )  [inline, inherited]

Definition at line 40 of file running_stat_vec_meat.hpp.

00041   : calc_cov    (in_rsv.calc_cov)
00042   , counter     (in_rsv.counter)
00043   , r_mean      (in_rsv.r_mean)
00044   , r_var       (in_rsv.r_var)
00045   , r_cov       (in_rsv.r_cov)
00046   , min_val     (in_rsv.min_val)
00047   , max_val     (in_rsv.max_val)
00048   , min_val_norm(in_rsv.min_val_norm)
00049   , max_val_norm(in_rsv.max_val_norm)
00050   {
00051   arma_extra_debug_sigprint_this(this);
00052   }

template<typename eT >
const running_stat_vec< eT > & running_stat_vec< eT >::operator= ( const running_stat_vec< eT > &  in_rsv  )  [inline, inherited]

Definition at line 58 of file running_stat_vec_meat.hpp.

References running_stat_vec< eT >::calc_cov, 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, and access::rw().

00059   {
00060   arma_extra_debug_sigprint();
00061   
00062   access::rw(calc_cov) = in_rsv.calc_cov;
00063   
00064   counter      = in_rsv.counter;
00065   r_mean       = in_rsv.r_mean;
00066   r_var        = in_rsv.r_var;
00067   r_cov        = in_rsv.r_cov;
00068   min_val      = in_rsv.min_val;
00069   max_val      = in_rsv.max_val;
00070   min_val_norm = in_rsv.min_val_norm;
00071   max_val_norm = in_rsv.max_val_norm;
00072   
00073   return *this;
00074   }

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

update statistics to reflect new sample

Definition at line 84 of file running_stat_vec_meat.hpp.

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

00085   {
00086   arma_extra_debug_sigprint();
00087   
00088   //typedef typename get_pod_type<eT>::result T;
00089   
00090   const unwrap<T1>        tmp(X.get_ref());
00091   const Mat<eT>& sample = tmp.M;
00092   
00093   arma_check( (sample.is_finite() == false), "running_stat_vec: given sample has non-finite elements" );
00094   
00095   running_stat_vec_aux::update_stats(*this, sample);
00096   }

template<typename eT >
template<typename T1 >
arma_hot 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 106 of file running_stat_vec_meat.hpp.

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

00107   {
00108   arma_extra_debug_sigprint();
00109   
00110   //typedef typename std::complex<typename get_pod_type<eT>::result> eT;
00111   
00112   const unwrap<T1>        tmp(X.get_ref());
00113   const Mat<eT>& sample = tmp.M;
00114   
00115   arma_check( (sample.is_finite() == false), "running_stat_vec: given sample has non-finite elements" );
00116   
00117   running_stat_vec_aux::update_stats(*this, sample);
00118   }

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

mean or average value

Definition at line 155 of file running_stat_vec_meat.hpp.

References running_stat_vec< eT >::r_mean.

00156   {
00157   arma_extra_debug_sigprint();
00158   
00159   return r_mean;
00160   }

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

variance

Definition at line 168 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, running_stat_vec< eT >::r_var_dummy, arma_counter< eT >::value(), arma_counter< eT >::value_minus_1(), and Mat< eT >::zeros().

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

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 204 of file running_stat_vec_meat.hpp.

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

00205   {
00206   arma_extra_debug_sigprint();
00207   
00208   const T N = counter.value();
00209   
00210   if(N > T(1))
00211     {
00212     if(norm_type == 0)
00213       {
00214       return sqrt(r_var);
00215       }
00216     else
00217       {
00218       const T N_minus_1 = counter.value_minus_1();
00219       
00220       return sqrt( (N_minus_1/N) * r_var );
00221       }
00222     }
00223   else
00224     {
00225     return Mat<T>();
00226     }
00227   }

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

covariance

Definition at line 235 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_cov_dummy, running_stat_vec< eT >::r_mean, arma_counter< eT >::value(), and arma_counter< eT >::value_minus_1().

00236   {
00237   arma_extra_debug_sigprint();
00238   
00239   if(calc_cov == true)
00240     {
00241     const T N = counter.value();
00242     
00243     if(N > T(1))
00244       {
00245       if(norm_type == 0)
00246         {
00247         return r_cov;
00248         }
00249       else
00250         {
00251         const T N_minus_1 = counter.value_minus_1();
00252         
00253         r_cov_dummy = (N_minus_1/N) * r_cov;
00254         
00255         return r_cov_dummy;
00256         }
00257       }
00258     else
00259       {
00260       r_cov_dummy.zeros(r_mean.n_rows, r_mean.n_cols);
00261       
00262       return r_cov_dummy;
00263       }
00264     }
00265   else
00266     {
00267     r_cov_dummy.reset();
00268     
00269     return r_cov_dummy;
00270     }
00271   
00272   }

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

vector with minimum values

Definition at line 280 of file running_stat_vec_meat.hpp.

References running_stat_vec< eT >::min_val.

00281   {
00282   arma_extra_debug_sigprint();
00283 
00284   return min_val;
00285   }

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

vector with maximum values

Definition at line 293 of file running_stat_vec_meat.hpp.

References running_stat_vec< eT >::max_val.

00294   {
00295   arma_extra_debug_sigprint();
00296 
00297   return max_val;
00298   }

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 310 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, running_stat_vec< eT >::tmp1, running_stat_vec< eT >::tmp2, 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().

00311   {
00312   arma_extra_debug_sigprint();
00313   
00314   typedef typename running_stat_vec<eT>::T T;
00315   
00316   const T N = x.counter.value();
00317   
00318   if(N > T(0))
00319     {
00320     arma_debug_assert_same_size(x.r_mean, sample, "running_stat_vec(): dimensionality mismatch");
00321     
00322     const u32 n_elem      = sample.n_elem;
00323     const eT* sample_mem  = sample.memptr();
00324           eT* r_mean_mem  = x.r_mean.memptr();
00325            T* r_var_mem   = x.r_var.memptr();
00326           eT* min_val_mem = x.min_val.memptr();
00327           eT* max_val_mem = x.max_val.memptr();
00328     
00329     const T  N_plus_1   = x.counter.value_plus_1();
00330     const T  N_minus_1  = x.counter.value_minus_1();
00331     
00332     if(x.calc_cov == true)
00333       {
00334       Mat<eT>& tmp1 = x.tmp1;
00335       Mat<eT>& tmp2 = x.tmp2;
00336       
00337       tmp1 = sample - x.r_mean;
00338       
00339       if(sample.n_cols == 1)
00340         {
00341         tmp2 = tmp1*trans(tmp1);
00342         }
00343       else
00344         {
00345         tmp2 = trans(tmp1)*tmp1;
00346         }
00347       
00348       x.r_cov *= (N_minus_1/N);
00349       x.r_cov += tmp2 / N_plus_1;
00350       }
00351     
00352     
00353     for(u32 i=0; i<n_elem; ++i)
00354       {
00355       const eT val = sample_mem[i];
00356       
00357       if(val < min_val_mem[i])
00358         {
00359         min_val_mem[i] = val;
00360         }
00361       
00362       if(val > max_val_mem[i])
00363         {
00364         max_val_mem[i] = val;
00365         }
00366         
00367       const eT r_mean_val = r_mean_mem[i];
00368       const eT tmp        = val - r_mean_val;
00369     
00370       r_var_mem[i] = N_minus_1/N * r_var_mem[i] + (tmp*tmp)/N_plus_1;
00371       
00372       r_mean_mem[i] = r_mean_val + (val - r_mean_val)/N_plus_1;
00373       }
00374     }
00375   else
00376     {
00377     arma_debug_check( (sample.is_vec() == false), "running_stat_vec(): given sample is not a vector");
00378     
00379     x.r_mean.set_size(sample.n_rows, sample.n_cols);
00380     
00381     x.r_var.zeros(sample.n_rows, sample.n_cols);
00382     
00383     if(x.calc_cov == true)
00384       {
00385       x.r_cov.zeros(sample.n_elem, sample.n_elem);
00386       }
00387     
00388     x.min_val.set_size(sample.n_rows, sample.n_cols);
00389     x.max_val.set_size(sample.n_rows, sample.n_cols);
00390     
00391     
00392     const u32 n_elem      = sample.n_elem;
00393     const eT* sample_mem  = sample.memptr();
00394           eT* r_mean_mem  = x.r_mean.memptr();
00395           eT* min_val_mem = x.min_val.memptr();
00396           eT* max_val_mem = x.max_val.memptr();
00397           
00398     
00399     for(u32 i=0; i<n_elem; ++i)
00400       {
00401       const eT val = sample_mem[i];
00402       
00403       r_mean_mem[i]  = val;
00404       min_val_mem[i] = val;
00405       max_val_mem[i] = val;
00406       }
00407     }
00408   
00409   x.counter++;
00410   }

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 418 of file running_stat_vec_meat.hpp.

References running_stat_vec_aux::update_stats().

00419   {
00420   arma_extra_debug_sigprint();
00421   
00422   const Mat< std::complex<T> > tmp = conv_to< Mat< std::complex<T> > >::from(sample);
00423   
00424   running_stat_vec_aux::update_stats(x, tmp);
00425   }

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 433 of file running_stat_vec_meat.hpp.

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

00434   {
00435   arma_extra_debug_sigprint();
00436   
00437   typedef typename std::complex<T> eT;
00438   
00439   const T N = x.counter.value();
00440   
00441   if(N > T(0))
00442     {
00443     arma_debug_assert_same_size(x.r_mean, sample, "running_stat_vec(): dimensionality mismatch");
00444     
00445     const u32 n_elem           = sample.n_elem;
00446     const eT* sample_mem       = sample.memptr();
00447           eT* r_mean_mem       = x.r_mean.memptr();
00448            T* r_var_mem        = x.r_var.memptr();
00449           eT* min_val_mem      = x.min_val.memptr();
00450           eT* max_val_mem      = x.max_val.memptr();
00451            T* min_val_norm_mem = x.min_val_norm.memptr();
00452            T* max_val_norm_mem = x.max_val_norm.memptr();
00453     
00454     const T  N_plus_1   = x.counter.value_plus_1();
00455     const T  N_minus_1  = x.counter.value_minus_1();
00456     
00457     if(x.calc_cov == true)
00458       {
00459       Mat<eT>& tmp1 = x.tmp1;
00460       Mat<eT>& tmp2 = x.tmp2;
00461       
00462       tmp1 = sample - x.r_mean;
00463       
00464       if(sample.n_cols == 1)
00465         {
00466         tmp2 = conj(tmp1)*trans(tmp1);
00467         }
00468       else
00469         {
00470         tmp2 = trans(conj(tmp1))*tmp1;
00471         }
00472       
00473       x.r_cov *= (N_minus_1/N);
00474       x.r_cov += tmp2 / N_plus_1;
00475       }
00476     
00477     
00478     for(u32 i=0; i<n_elem; ++i)
00479       {
00480       const eT& val      = sample_mem[i];
00481       const  T  val_norm = std::norm(val);
00482       
00483       if(val_norm < min_val_norm_mem[i])
00484         {
00485         min_val_norm_mem[i] = val_norm;
00486         min_val_mem[i]      = val;
00487         }
00488       
00489       if(val_norm > max_val_norm_mem[i])
00490         {
00491         max_val_norm_mem[i] = val_norm;
00492         max_val_mem[i]      = val;
00493         }
00494       
00495       const eT& r_mean_val = r_mean_mem[i];
00496       
00497       r_var_mem[i] = N_minus_1/N * r_var_mem[i] + std::norm(val - r_mean_val)/N_plus_1;
00498       
00499       r_mean_mem[i] = r_mean_val + (val - r_mean_val)/N_plus_1;
00500       }
00501     
00502     }
00503   else
00504     {
00505     arma_debug_check( (sample.is_vec() == false), "running_stat_vec(): given sample is not a vector");
00506     
00507     x.r_mean.set_size(sample.n_rows, sample.n_cols);
00508     
00509     x.r_var.zeros(sample.n_rows, sample.n_cols);
00510     
00511     if(x.calc_cov == true)
00512       {
00513       x.r_cov.zeros(sample.n_elem, sample.n_elem);
00514       }
00515     
00516     x.min_val.set_size(sample.n_rows, sample.n_cols);
00517     x.max_val.set_size(sample.n_rows, sample.n_cols);
00518     
00519     x.min_val_norm.set_size(sample.n_rows, sample.n_cols);
00520     x.max_val_norm.set_size(sample.n_rows, sample.n_cols);
00521     
00522     
00523     const u32 n_elem           = sample.n_elem;
00524     const eT* sample_mem       = sample.memptr();
00525           eT* r_mean_mem       = x.r_mean.memptr();
00526           eT* min_val_mem      = x.min_val.memptr();
00527           eT* max_val_mem      = x.max_val.memptr();
00528            T* min_val_norm_mem = x.min_val_norm.memptr();
00529            T* max_val_norm_mem = x.max_val_norm.memptr();
00530     
00531     for(u32 i=0; i<n_elem; ++i)
00532       {
00533       const eT& val      = sample_mem[i];
00534       const  T  val_norm = std::norm(val);
00535       
00536       r_mean_mem[i]  = val;
00537       min_val_mem[i] = val;
00538       max_val_mem[i] = val;
00539       
00540       min_val_norm_mem[i] = val_norm;
00541       max_val_norm_mem[i] = val_norm;
00542       }
00543     }
00544   
00545   x.counter++;
00546   }