Classes | Functions

Running_stat_vec

//! More...

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< typename get_pod_type< eT >::result, T1 > &X)
 update statistics to reflect new sample
template<typename T1 >
arma_hot void running_stat_vec::operator() (const Base< std::complex< typename get_pod_type< eT >::result >, 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)

Detailed Description

//!


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.

  {
  arma_extra_debug_sigprint_this(this);
  }

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.

  : calc_cov(in_calc_cov)
  {
  arma_extra_debug_sigprint_this(this);
  }

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.

  : calc_cov    (in_rsv.calc_cov)
  , counter     (in_rsv.counter)
  , r_mean      (in_rsv.r_mean)
  , r_var       (in_rsv.r_var)
  , r_cov       (in_rsv.r_cov)
  , min_val     (in_rsv.min_val)
  , max_val     (in_rsv.max_val)
  , min_val_norm(in_rsv.min_val_norm)
  , max_val_norm(in_rsv.max_val_norm)
  {
  arma_extra_debug_sigprint_this(this);
  }

template<typename eT >
const running_stat_vec< eT > & running_stat_vec< eT >::operator= ( const running_stat_vec< eT > &  in_rsv  )  [inline, inherited]
template<typename eT>
template<typename T1 >
arma_hot void running_stat_vec< eT >::operator() ( const Base< typename get_pod_type< eT >::result, 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().

  {
  arma_extra_debug_sigprint();
  
  //typedef typename get_pod_type<eT>::result T;
  
  const unwrap<T1>        tmp(X.get_ref());
  const Mat<eT>& sample = tmp.M;
  
  arma_check( (sample.is_finite() == false), "running_stat_vec: given sample has non-finite elements" );
  
  running_stat_vec_aux::update_stats(*this, sample);
  }

template<typename eT>
template<typename T1 >
arma_hot void running_stat_vec< eT >::operator() ( const Base< std::complex< typename get_pod_type< eT >::result >, 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().

  {
  arma_extra_debug_sigprint();
  
  //typedef typename std::complex<typename get_pod_type<eT>::result> eT;
  
  const unwrap<T1>        tmp(X.get_ref());
  const Mat<eT>& sample = tmp.M;
  
  arma_check( (sample.is_finite() == false), "running_stat_vec: given sample has non-finite elements" );
  
  running_stat_vec_aux::update_stats(*this, sample);
  }

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.

  {
  arma_extra_debug_sigprint();
  
  return r_mean;
  }

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().

  {
  arma_extra_debug_sigprint();
  
  const T N = counter.value();
  
  if(N > T(1))
    {
    if(norm_type == 0)
      {
      return r_var;
      }
    else
      {
      const T N_minus_1 = counter.value_minus_1();
      
      r_var_dummy = (N_minus_1/N) * r_var;
      
      return r_var_dummy;
      }
    }
  else
    {
    r_var_dummy.zeros(r_mean.n_rows, r_mean.n_cols);
    
    return r_var_dummy;
    }
  
  }

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().

  {
  arma_extra_debug_sigprint();
  
  const T N = counter.value();
  
  if(N > T(1))
    {
    if(norm_type == 0)
      {
      return sqrt(r_var);
      }
    else
      {
      const T N_minus_1 = counter.value_minus_1();
      
      return sqrt( (N_minus_1/N) * r_var );
      }
    }
  else
    {
    return Mat<T>();
    }
  }

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().

  {
  arma_extra_debug_sigprint();
  
  if(calc_cov == true)
    {
    const T N = counter.value();
    
    if(N > T(1))
      {
      if(norm_type == 0)
        {
        return r_cov;
        }
      else
        {
        const T N_minus_1 = counter.value_minus_1();
        
        r_cov_dummy = (N_minus_1/N) * r_cov;
        
        return r_cov_dummy;
        }
      }
    else
      {
      r_cov_dummy.zeros(r_mean.n_rows, r_mean.n_cols);
      
      return r_cov_dummy;
      }
    }
  else
    {
    r_cov_dummy.reset();
    
    return r_cov_dummy;
    }
  
  }

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.

  {
  arma_extra_debug_sigprint();

  return min_val;
  }

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.

  {
  arma_extra_debug_sigprint();

  return max_val;
  }

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().

  {
  arma_extra_debug_sigprint();
  
  typedef typename running_stat_vec<eT>::T T;
  
  const T N = x.counter.value();
  
  if(N > T(0))
    {
    arma_debug_assert_same_size(x.r_mean, sample, "running_stat_vec(): dimensionality mismatch");
    
    const u32 n_elem      = sample.n_elem;
    const eT* sample_mem  = sample.memptr();
          eT* r_mean_mem  = x.r_mean.memptr();
           T* r_var_mem   = x.r_var.memptr();
          eT* min_val_mem = x.min_val.memptr();
          eT* max_val_mem = x.max_val.memptr();
    
    const T  N_plus_1   = x.counter.value_plus_1();
    const T  N_minus_1  = x.counter.value_minus_1();
    
    if(x.calc_cov == true)
      {
      Mat<eT>& tmp1 = x.tmp1;
      Mat<eT>& tmp2 = x.tmp2;
      
      tmp1 = sample - x.r_mean;
      
      if(sample.n_cols == 1)
        {
        tmp2 = tmp1*trans(tmp1);
        }
      else
        {
        tmp2 = trans(tmp1)*tmp1;
        }
      
      x.r_cov *= (N_minus_1/N);
      x.r_cov += tmp2 / N_plus_1;
      }
    
    
    for(u32 i=0; i<n_elem; ++i)
      {
      const eT val = sample_mem[i];
      
      if(val < min_val_mem[i])
        {
        min_val_mem[i] = val;
        }
      
      if(val > max_val_mem[i])
        {
        max_val_mem[i] = val;
        }
        
      const eT r_mean_val = r_mean_mem[i];
      const eT tmp        = val - r_mean_val;
    
      r_var_mem[i] = N_minus_1/N * r_var_mem[i] + (tmp*tmp)/N_plus_1;
      
      r_mean_mem[i] = r_mean_val + (val - r_mean_val)/N_plus_1;
      }
    }
  else
    {
    arma_debug_check( (sample.is_vec() == false), "running_stat_vec(): given sample is not a vector");
    
    x.r_mean.set_size(sample.n_rows, sample.n_cols);
    
    x.r_var.zeros(sample.n_rows, sample.n_cols);
    
    if(x.calc_cov == true)
      {
      x.r_cov.zeros(sample.n_elem, sample.n_elem);
      }
    
    x.min_val.set_size(sample.n_rows, sample.n_cols);
    x.max_val.set_size(sample.n_rows, sample.n_cols);
    
    
    const u32 n_elem      = sample.n_elem;
    const eT* sample_mem  = sample.memptr();
          eT* r_mean_mem  = x.r_mean.memptr();
          eT* min_val_mem = x.min_val.memptr();
          eT* max_val_mem = x.max_val.memptr();
          
    
    for(u32 i=0; i<n_elem; ++i)
      {
      const eT val = sample_mem[i];
      
      r_mean_mem[i]  = val;
      min_val_mem[i] = val;
      max_val_mem[i] = val;
      }
    }
  
  x.counter++;
  }

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().

  {
  arma_extra_debug_sigprint();
  
  const Mat< std::complex<T> > tmp = conv_to< Mat< std::complex<T> > >::from(sample);
  
  running_stat_vec_aux::update_stats(x, tmp);
  }

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().

  {
  arma_extra_debug_sigprint();
  
  typedef typename std::complex<T> eT;
  
  const T N = x.counter.value();
  
  if(N > T(0))
    {
    arma_debug_assert_same_size(x.r_mean, sample, "running_stat_vec(): dimensionality mismatch");
    
    const u32 n_elem           = sample.n_elem;
    const eT* sample_mem       = sample.memptr();
          eT* r_mean_mem       = x.r_mean.memptr();
           T* r_var_mem        = x.r_var.memptr();
          eT* min_val_mem      = x.min_val.memptr();
          eT* max_val_mem      = x.max_val.memptr();
           T* min_val_norm_mem = x.min_val_norm.memptr();
           T* max_val_norm_mem = x.max_val_norm.memptr();
    
    const T  N_plus_1   = x.counter.value_plus_1();
    const T  N_minus_1  = x.counter.value_minus_1();
    
    if(x.calc_cov == true)
      {
      Mat<eT>& tmp1 = x.tmp1;
      Mat<eT>& tmp2 = x.tmp2;
      
      tmp1 = sample - x.r_mean;
      
      if(sample.n_cols == 1)
        {
        tmp2 = conj(tmp1)*trans(tmp1);
        }
      else
        {
        tmp2 = trans(conj(tmp1))*tmp1;
        }
      
      x.r_cov *= (N_minus_1/N);
      x.r_cov += tmp2 / N_plus_1;
      }
    
    
    for(u32 i=0; i<n_elem; ++i)
      {
      const eT& val      = sample_mem[i];
      const  T  val_norm = std::norm(val);
      
      if(val_norm < min_val_norm_mem[i])
        {
        min_val_norm_mem[i] = val_norm;
        min_val_mem[i]      = val;
        }
      
      if(val_norm > max_val_norm_mem[i])
        {
        max_val_norm_mem[i] = val_norm;
        max_val_mem[i]      = val;
        }
      
      const eT& r_mean_val = r_mean_mem[i];
      
      r_var_mem[i] = N_minus_1/N * r_var_mem[i] + std::norm(val - r_mean_val)/N_plus_1;
      
      r_mean_mem[i] = r_mean_val + (val - r_mean_val)/N_plus_1;
      }
    
    }
  else
    {
    arma_debug_check( (sample.is_vec() == false), "running_stat_vec(): given sample is not a vector");
    
    x.r_mean.set_size(sample.n_rows, sample.n_cols);
    
    x.r_var.zeros(sample.n_rows, sample.n_cols);
    
    if(x.calc_cov == true)
      {
      x.r_cov.zeros(sample.n_elem, sample.n_elem);
      }
    
    x.min_val.set_size(sample.n_rows, sample.n_cols);
    x.max_val.set_size(sample.n_rows, sample.n_cols);
    
    x.min_val_norm.set_size(sample.n_rows, sample.n_cols);
    x.max_val_norm.set_size(sample.n_rows, sample.n_cols);
    
    
    const u32 n_elem           = sample.n_elem;
    const eT* sample_mem       = sample.memptr();
          eT* r_mean_mem       = x.r_mean.memptr();
          eT* min_val_mem      = x.min_val.memptr();
          eT* max_val_mem      = x.max_val.memptr();
           T* min_val_norm_mem = x.min_val_norm.memptr();
           T* max_val_norm_mem = x.max_val_norm.memptr();
    
    for(u32 i=0; i<n_elem; ++i)
      {
      const eT& val      = sample_mem[i];
      const  T  val_norm = std::norm(val);
      
      r_mean_mem[i]  = val;
      min_val_mem[i] = val;
      max_val_mem[i] = val;
      
      min_val_norm_mem[i] = val_norm;
      max_val_norm_mem[i] = val_norm;
      }
    }
  
  x.counter++;
  }