STK::Stat::Univariate< TContainer1D, Real > Class Template Reference

Computation of the univariate Statistics of a Real Variable. More...

#include <STK_Stat_UnivariateReal.h>

Public Member Functions
	Univariate (TContainer1D const &V, bool sorted=false)
	Default constructor Copy locally the variable V and set dimensions.
	Univariate (TContainer1D const &V, TContainer1D const &W, bool sorted=false)
	Default constructor for weighted variables.
	Univariate (const Univariate &stat)
	Copy constructor.
	~Univariate ()
	destructor.
Univariate &	operator= (const Univariate &stat)
	Operator = : overwrite the Univariate with stat.
template<class Vector >
void	setData (Vector const &V, bool sorted=false)
	Compute the statistics of a new Variable.
template<class Vector , class Weights >
void	setData (Vector const &V, Weights const &W, bool sorted=false)
	Compute the statistics of a new weighted Variable.
const int	nbSamples () const
	get the number of samples
const int	nbAvailableSamples () const
	get the number of available samples (not missing)
const int	nbMissingSamples () const
	get the number of missing samples
const Real	min () const
	get the min of the variable
const Real	max () const
	get the max of the variable
const Real	aMax () const
	get the absolute maximal value
const Real	mean () const
	get the mean of the variable
const Real	median () const
	get the median of the variable
const Real	variance () const
	get the variance of the variable (division by n)
const Real	unbiasedVariance () const
	get the unbiased Variance of the variable (division by n-1)
const Real	std () const
	get the standard deviation of the variable
const Real	unbiasedStd () const
	get the sample standard deviation of the variable
const Real	mad () const
	get the median absolute deviation of the variable
const Real	kurtosis () const
	get the kurtosis of the variable
const Real	skewness () const
	get the skewness of the variable
Variable< Real > const &	quartiles () const
	get the quartiles of the variable (25%)
Variable< Real > const &	deciles () const
	get the deciles of the varibales (10%)
Variable< Real > const &	viceciles () const
	get the viceciles of the variable (5%)
Variable< Real > const &	percentiles () const
	get the percentiles of the variable (1%)
template<class OtherArray >
void	compQuantiles (OtherArray &T)
	Compute the quantiles of the sorted variable V_ and store the result in the array T.

Protected Attributes
int	nbSamples_
	Number of samples.
int	nbAvailable_
	Number of Available samples.
int	nbMiss_
	Number of missing samples.
TContainer1D	V_
	local copy of the variable
TContainer1D	W_
	local copy of the weights
bool	weighted_
	Samples are weighted ?
bool	sorted_
	Samples are sorted ?
bool	comporder_
	Orders Statistics are computed ?
bool	compstat_
	Usuals Statistics are computed ?
Real	sumweights_
	Sum of the weights.
Real	sum2weights_
	Sum of the square of the weights.
Real	min_
	Min of the variable.
Real	max_
	Max of the variable.
Real	amax_
	Absolute maximal value.
Real	mean_
	mean of the variable
Real	median_
	median of the variable
Real	var_
	Variance of the variable (division by n)
Real	uvar_
	Unbiased Variance of the variable (division by n-1)
Real	std_
	Standard deviation of the variable (n)
Real	ustd_
	Sample standard deviation of the variable (n-1)
Real	mad_
	absolute deviation of the variable
Real	kurtosis_
	kurtosis of the variable
Real	skewness_
	Skewness of the variable.
Variable< Real >	quartiles_
	Quartiles (25%)
Variable< Real >	deciles_
	Deciles (10%)
Variable< Real >	viceciles_
	viceciles (5%)
Variable< Real >	percentiles_
	percentiles (1%)

Private Member Functions
void	initializeVariable ()
	Initialize the container in order to discard the missing elements in the non weighted case.
void	initializeVariableAndWeights ()
	Initialize the containers in order to discard the missing elements in the weighted case.
void	compStatistics ()
	Compute the usual statistics of the variable:
void	compWeightedStatistics ()
	Compute the usual weighted statistics of the variable.
void	compOrderStatistics ()
	Compute the Order Statistics of the variable.

Detailed Description

template<class TContainer1D>
class STK::Stat::Univariate< TContainer1D, Real >

Computation of the univariate Statistics of a Real Variable.

This is a specialization of the class Univariate for the type Real.

The template parameter TContainer1D is the type of container used for storing the data : It should derive from ITContainer and contain elements of type Real.

This specialization propose also statics methods for computing the (weighted) mean and the (weighted) variance.

Definition at line 63 of file STK_Stat_UnivariateReal.h.

Constructor & Destructor Documentation

Univariate() [1/3]

template<class TContainer1D >

STK::Stat::Univariate< TContainer1D, Real >::Univariate ( TContainer1D const &  V, bool  sorted = false  )

inline

Default constructor Copy locally the variable V and set dimensions.

The statistics are then computed.

Parameters

V	variable
sorted	true if the variable is sorted, false otherwise

Definition at line 72 of file STK_Stat_UnivariateReal.h.

              : nbSamples_(V.size())
              , nbAvailable_(V.size())
              , nbMiss_(0)
              , V_(V)
              , W_()
              , weighted_(false)
              , sorted_(sorted)
              , comporder_(false)
              , compstat_(false)
              , sumweights_(0.)
              , sum2weights_(0.)
              , mean_(Arithmetic<Real>::NA())
              , median_(Arithmetic<Real>::NA())
              , var_(Arithmetic<Real>::NA())
              , uvar_(Arithmetic<Real>::NA())
              , std_(Arithmetic<Real>::NA())
              , ustd_(Arithmetic<Real>::NA())
              , mad_(Arithmetic<Real>::NA())
              , kurtosis_(Arithmetic<Real>::NA())
              , skewness_(Arithmetic<Real>::NA())
              , quartiles_(3, Arithmetic<Real>::NA(), String(_T("Quartiles")))
              , deciles_(9, Arithmetic<Real>::NA(), String(_T("Deciles")))
              , viceciles_(19, Arithmetic<Real>::NA(), String(_T("Viceciles")))
              , percentiles_(99, Arithmetic<Real>::NA(), String(_T("Percentiles")))
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(TContainer1D);
      initializeVariable();
      compOrderStatistics();
      compStatistics();
    }

References STK_STATIC_ASSERT_ONE_DIMENSION_ONLY.

Univariate() [2/3]

template<class TContainer1D >

STK::Stat::Univariate< TContainer1D, Real >::Univariate ( TContainer1D const &  V, TContainer1D const &  W, bool  sorted = false  )

inline

Default constructor for weighted variables.

Copy locally the variable V, the weights W and set dimensions. No statistics except min_, max_ and amax_ are calculated at this stage.

Parameters

V,W	the variable and the weights
sorted	true if the variable is sorted, false otherwise

Definition at line 111 of file STK_Stat_UnivariateReal.h.

              : nbSamples_(V.size())
              , nbAvailable_(V.size())
              , nbMiss_(0)
              , V_(V)
              , W_(W)
              , weighted_(true)
              , sorted_(sorted)
              , comporder_(false)
              , compstat_(false)
              , sumweights_(0.0)
              , sum2weights_(0.0)
              , mean_(Arithmetic<Real>::NA())
              , median_(Arithmetic<Real>::NA())
              , var_(Arithmetic<Real>::NA())
              , uvar_(Arithmetic<Real>::NA())
              , std_(Arithmetic<Real>::NA())
              , ustd_(Arithmetic<Real>::NA())
              , mad_(Arithmetic<Real>::NA())
              , kurtosis_(Arithmetic<Real>::NA())
              , skewness_(Arithmetic<Real>::NA())
              , quartiles_(3)
              , deciles_(9)
              , viceciles_(19)
              , percentiles_(99)
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(TContainer1D);
      // check weights size
      if ((V_.range() != W_.range()))
      {  STKRUNTIME_ERROR_NO_ARG(Univariate::Univariate(V, W, sorted),V and W have different range);}
      initializeVariableAndWeights();
      compOrderStatistics();
      compWeightedStatistics();
    }

References STK_STATIC_ASSERT_ONE_DIMENSION_ONLY, and STKRUNTIME_ERROR_NO_ARG.

Univariate() [3/3]

template<class TContainer1D >

STK::Stat::Univariate< TContainer1D, Real >::Univariate ( const Univariate< TContainer1D, Real > &  stat )

inline

Copy constructor.

Parameters

stat	the univariate statistics to copy

Definition at line 148 of file STK_Stat_UnivariateReal.h.

              : nbSamples_(stat.nbSamples_)
              , nbAvailable_(stat.nbAvailable_)
              , nbMiss_(stat.nbMiss_)
              , V_(stat.V_)
              , W_(stat.W_)
              , weighted_(stat.weighted_)
              , sorted_(stat.sorted_)
              , comporder_(stat.comporder_)
              , compstat_(stat.compstat_)
              , sumweights_(stat.sumweights_)
              , sum2weights_(stat.sum2weights_)
              , min_(stat.min_)
              , max_(stat.max_)
              , amax_(stat.amax_)
              , mean_(stat.mean_)
              , median_(stat.median_)
              , var_(stat.var_)
              , uvar_(stat.uvar_)
              , std_(stat.std_)
              , ustd_(stat.ustd_)
              , mad_(stat.mad_)
              , kurtosis_(stat.kurtosis_)
              , skewness_(stat.skewness_)
              , quartiles_(stat.quartiles_)
              , deciles_(stat.deciles_)
              , viceciles_(stat.viceciles_)
              , percentiles_(stat.percentiles_)
    {}

~Univariate()

template<class TContainer1D >

STK::Stat::Univariate< TContainer1D, Real >::~Univariate ( )

inline

destructor.

Definition at line 179 of file STK_Stat_UnivariateReal.h.

{}

Member Function Documentation

aMax()

template<class TContainer1D >

const Real STK::Stat::Univariate< TContainer1D, Real >::aMax ( ) const

inline

get the absolute maximal value

Definition at line 313 of file STK_Stat_UnivariateReal.h.

{return amax_;}

compOrderStatistics()

template<class TContainer1D >

void STK::Stat::Univariate< TContainer1D, Real >::compOrderStatistics ( )

inlineprivate

Compute the Order Statistics of the variable.

Definition at line 624 of file STK_Stat_UnivariateReal.h.

    {
      // no samples
      if (nbAvailable_ == 0)
      {
        median_      = Arithmetic<Real>::NA();
        quartiles_   = Arithmetic<Real>::NA();
        deciles_     = Arithmetic<Real>::NA();
        viceciles_   = Arithmetic<Real>::NA();
        percentiles_ = Arithmetic<Real>::NA();
        return;
      }
 
      // One observation
      if (nbAvailable_ == 1)
      {
        median_      = max_;
        quartiles_   = max_;
        deciles_     = max_;
        viceciles_   = max_;
        percentiles_ = max_;
        return;
      }
      // sort values
      if (!sorted_)
      {
        // if the Variable is not weighted, we can sort it directly
        if (!weighted_) heapSort(V_);
        else // otherwise we have to sort V_and W_ using indirection
        {
          TContainer1D const& Vconst = V_;
          Array2DVector<int> I; // auxiliary Array for indirection
          heapSort(I, Vconst);
          applySort1D(V_, I);
          applySort1D(W_, I);
        }
        sorted_ = true;
      }
      // Find the Quantiles of the distribution
      compQuantiles(quartiles_);
      compQuantiles(deciles_);
      compQuantiles(viceciles_);
      compQuantiles(percentiles_);
      // get the median
      median_ = quartiles_[2];
    }

References STK::applySort1D(), STK::heapSort(), and STK::Arithmetic< Type >::NA().

compQuantiles()

template<class TContainer1D >

template<class OtherArray >

void STK::Stat::Univariate< TContainer1D, Real >::compQuantiles ( OtherArray &  T )

inline

Compute the quantiles of the sorted variable V_ and store the result in the array T.

The number of quantiles is given by the size of T. For exemple, if T.size() == 9, compQuantiles will return the deciles.

Parameters

T	TContainer1Ds of the *tiles

Definition at line 352 of file STK_Stat_UnivariateReal.h.

    {
      if (!sorted_)
      {  STKRUNTIME_ERROR_NO_ARG(Univariate<TContainer1D>::compQuantiles(T),V_ is not sorted);}
      // number of quantiles
      int  nt = T.size(), shift = V_.begin()-1;
      Real n1 = Real(nbAvailable_+1), nt1 = Real(nt+1);
 
      for (int j=T.begin(), k=1; j<T.end(); j++, k++)
      {
        // find index of the k-th quantile
        Real find  = Real(k*n1)/nt1;  // compute the index in Real
        int  tind  = std::max(1, int(find));   // in int
        int  tind1 = std::min(nbAvailable_, tind+1); // next
        Real aux   = find - Real(tind); // lower ponderation
 
        // nbAvailable_+1 not perfectly divisible ? weighting...
        aux ? T[j] = aux * V_[shift+tind] + (1.0-aux)*V_[shift+tind1]
            : T[j] = V_[shift+tind];
      }
    }

References STKRUNTIME_ERROR_NO_ARG.

compStatistics()

template<class TContainer1D >

void STK::Stat::Univariate< TContainer1D, Real >::compStatistics ( )

inlineprivate

Compute the usual statistics of the variable:

• mean the empirical mean of the variable
• var_ the variance of of the variable (division by n)
• uvar_ the sample variance of the variable (division by n-1)
• std_ the standard deviation of the variable (n)
• ustd_ the sample standard deviation of the variable (n-1)
• mad_ the absolute deviation from the mean of the variable

Definition at line 460 of file STK_Stat_UnivariateReal.h.

    {
      // If there is no samples
      if (nbAvailable_ == 0)
      {
        mean_     = Arithmetic<Real>::NA();
        var_      = Arithmetic<Real>::NA();
        uvar_     = Arithmetic<Real>::NA();
        std_      = Arithmetic<Real>::NA();
        ustd_     = Arithmetic<Real>::NA();
        mad_      = Arithmetic<Real>::NA();
        kurtosis_ = Arithmetic<Real>::NA();
        skewness_ = Arithmetic<Real>::NA();
        return;
      }
 
      // One observation
      if (nbAvailable_ == 1)
      {
        mean_     = V_.front();
        var_      = Arithmetic<Real>::NA();
        std_      = 0.0;
        ustd_     = Arithmetic<Real>::NA();
        mad_      = 0.0;
        kurtosis_ = 0.0;
        skewness_ = 0.0;
        return;
      }
      // get indexes
      // get nbAvailable observation in Real
      const Real n = (Real)nbAvailable_;
      // first pass : compute the mean
      // scale the samples for preventing overflows
      mean_ = 0.;
      {
        if (amax_) // if the absolute maximal value is greater than 0
        {
          // sum samples with scaling
          for (int i=V_.begin(); i<=V_.lastIdx(); i++)
            mean_ += V_[i]/amax_;
          // divide by the number of available observation
          mean_ /= n;
          // unscale
          mean_ *= amax_;
        }
      }
      // second pass : compute the variance, skewness and kurtosis
      // initialize values
      Real sum = 0.0, dev1, dev2;
      var_  = 0.0;
      mad_  = 0.0;
      kurtosis_ = 0.0;
      skewness_ = 0.0;
      for (int i=V_.begin(); i<V_.end(); i++)
      {
        sum       += (dev1 = V_[i]-mean_); // deviation from the mean
        var_      += (dev2 = dev1*dev1);   // squared deviation
        mad_      += std::abs( dev1 );          // absolute deviation
        skewness_ += dev2 * dev1;          // cubic deviation
        kurtosis_ += dev2 * dev2;          // squared squared deviation
      }
      mad_ *= sum2weights_;
      uvar_ = (var_ - sum*sum/n)/(n - 1.);
      var_  = (var_ - sum*sum/n)/n;
      std_  = sqrt((double)var_);
      ustd_ = sqrt((double)uvar_);
     // if there is variance
      if (var_)
      {
        skewness_ /= n;
        kurtosis_ /= n;
 
        skewness_ /= (var_ * std_);
        kurtosis_ /= (var_ * var_);
        kurtosis_ -= 3.0;
      }
      else
      {
        skewness_ = 0.0;
        kurtosis_ = 0.0;
      }
      // Statistics are computed
      compstat_ = true;
    }

References STK::Arithmetic< Type >::NA(), and STK::Stat::sum().

compWeightedStatistics()

template<class TContainer1D >

void STK::Stat::Univariate< TContainer1D, Real >::compWeightedStatistics ( )

inlineprivate

Compute the usual weighted statistics of the variable.

Definition at line 546 of file STK_Stat_UnivariateReal.h.

    {
      // If there is no samples
      if (nbAvailable_ == 0)
      {
        mean_     = Arithmetic<Real>::NA();
        var_      = Arithmetic<Real>::NA();
        uvar_     = Arithmetic<Real>::NA();
        std_      = Arithmetic<Real>::NA();
        ustd_     = Arithmetic<Real>::NA();
        mad_      = Arithmetic<Real>::NA();
        kurtosis_ = Arithmetic<Real>::NA();
        skewness_ = Arithmetic<Real>::NA();
        return;
      }
 
      // One observation or pathological weights
      if ((nbAvailable_ == 1)||(sumweights_*sumweights_ <= sum2weights_))
      {
        mean_     = V_.front();
        var_      = 0.;
        uvar_     = Arithmetic<Real>::NA();
        std_      = 0.;
        ustd_     = Arithmetic<Real>::NA();
        mad_      = 0.;
        kurtosis_ = 0.;
        skewness_ = 0.;
        return;
      }
      // first pass : get the mean
      // scale the samples for preventing overflows
      mean_ = 0.;
      if (amax_) // if the maximal value is greater than 0
       {
        // sum samples
        for (int i=V_.begin(); i<V_.end(); i++)
          mean_ += (W_[i]*V_[i])/amax_; // compute the mean with scaling
        mean_ /= sumweights_;           // weight the sum
        mean_ *= amax_;                 // and unscale
      }
      // second pass : compute the variance, skewness and kurtosis
      // initialize some values
      Real sum = 0.0, dev1, dev2;
      var_  = 0.0;
      mad_  = 0.0;
      kurtosis_ = 0.0;
      skewness_ = 0.0;
      for (int i=V_.begin(); i<V_.end(); i++)
      {
        Real weight = W_[i];
        sum       += weight * (dev1 = V_[i]-mean_); // deviation from the mean
        var_      += weight * (dev2 = dev1*dev1);   // squared value
        mad_      += weight * std::abs(dev1);       // absolute deviation from mean
        skewness_ += weight * dev2 * dev1;
        kurtosis_ += weight * dev2 * dev2;
      }
      mad_ /= sumweights_;
      uvar_ = (var_ - sum*sum/sumweights_)/(sumweights_ - sum2weights_/sumweights_);
      var_  = (var_ - sum*sum/sumweights_)/sumweights_;
      std_  = sqrt((double)var_);
      ustd_ = sqrt((double)uvar_);
      // if there is variance
      if (var_)
      {
        skewness_ /= (sumweights_ * var_ * std_);
        kurtosis_ /= (sumweights_ * var_ * var_);
        kurtosis_ -= 3.0;
      }
      else
      {
        skewness_ = 0.0;
        kurtosis_ = 0.0;
      }
      // Stat are computed
      compstat_ = true;
    }

References STK::Arithmetic< Type >::NA(), and STK::Stat::sum().

deciles()

template<class TContainer1D >

Variable< Real > const & STK::Stat::Univariate< TContainer1D, Real >::deciles ( ) const

inline

get the deciles of the varibales (10%)

Definition at line 339 of file STK_Stat_UnivariateReal.h.

{return deciles_;}

initializeVariable()

template<class TContainer1D >

void STK::Stat::Univariate< TContainer1D, Real >::initializeVariable ( )

inlineprivate

Initialize the container in order to discard the missing elements in the non weighted case.

Definition at line 378 of file STK_Stat_UnivariateReal.h.

    {
      // initialize the extreme values
      min_ =  Arithmetic<Real>::max();
      max_ = -Arithmetic<Real>::max();
      // discard missing values
      for (int i=V_.lastIdx(); i>=V_.begin(); i--)
      {
        if ( isNA(V_[i]) )
        {
          // if NA
          nbAvailable_--;         // decrease nbAvailable_
          nbMiss_++;        // increase nbMiss_
          V_.erase(i);    // Delete the current row
        }
        else
        {
          min_ = std::min((Real)V_[i], min_);    // update min_
          max_ = std::max((Real)V_[i], max_);    // update max_
        }
      }
      // all weights are 1/n.
      sumweights_ = 1.0;
      sum2weights_= 1./(Real)nbAvailable_;
 
      // no samples
      if (nbAvailable_ == 0)
      {
        min_  = Arithmetic<Real>::NA();
        max_  = Arithmetic<Real>::NA();
        amax_ = Arithmetic<Real>::NA();
      }
      else // one or more samples : compute amax
        amax_ = std::max(std::abs(min_), std::abs(max_));
    }

References STK::isNA(), and STK::Arithmetic< Type >::NA().

initializeVariableAndWeights()

template<class TContainer1D >

void STK::Stat::Univariate< TContainer1D, Real >::initializeVariableAndWeights ( )

inlineprivate

Initialize the containers in order to discard the missing elements in the weighted case.

Definition at line 417 of file STK_Stat_UnivariateReal.h.

    {
      // initialize the extreme values
      min_ =  Arithmetic<Real>::max();
      max_ = -Arithmetic<Real>::max();
 
      // discard missing values or values without weights
      for (int i=V_.lastIdx(); i>=V_.begin(); i--)
      {
        if ( isNA(V_[i])||isNA(W_[i]))
        {
          V_.erase(i); // Delete the current row
          W_.erase(i); // for the weights too
          nbAvailable_--;         // decrease number of samples
          nbMiss_++;        // increase number of missing values
        }
        else
        {
          min_       = std::min(V_[i], min_);    // update min_
          max_       = std::max(V_[i], max_);    // update max_
          sumweights_  += (W_[i] = std::abs((Real)W_[i]));// sum absolute weights
          sum2weights_ += W_[i] * W_[i];     // sum squared weights
        }
      }
      // no samples
      if (nbAvailable_ == 0)
      {
        min_  = Arithmetic<Real>::NA();
        max_  = Arithmetic<Real>::NA();
        amax_ = Arithmetic<Real>::NA();
      }
      else // one or more samples : compute amax
        amax_ = std::max(std::abs(min_), std::abs(max_));
    }

References STK::isNA(), and STK::Arithmetic< Type >::NA().

kurtosis()

template<class TContainer1D >

const Real STK::Stat::Univariate< TContainer1D, Real >::kurtosis ( ) const

inline

get the kurtosis of the variable

Definition at line 332 of file STK_Stat_UnivariateReal.h.

{return kurtosis_;}

mad()

template<class TContainer1D >

const Real STK::Stat::Univariate< TContainer1D, Real >::mad ( ) const

inline

get the median absolute deviation of the variable

Definition at line 329 of file STK_Stat_UnivariateReal.h.

{ return( mad_);}

max()

template<class TContainer1D >

const Real STK::Stat::Univariate< TContainer1D, Real >::max ( ) const

inline

get the max of the variable

Definition at line 311 of file STK_Stat_UnivariateReal.h.

{return max_;}

mean()

template<class TContainer1D >

const Real STK::Stat::Univariate< TContainer1D, Real >::mean ( ) const

inline

get the mean of the variable

Definition at line 316 of file STK_Stat_UnivariateReal.h.

{return mean_;}

median()

template<class TContainer1D >

const Real STK::Stat::Univariate< TContainer1D, Real >::median ( ) const

inline

get the median of the variable

Definition at line 318 of file STK_Stat_UnivariateReal.h.

{return median_;}

min()

template<class TContainer1D >

const Real STK::Stat::Univariate< TContainer1D, Real >::min ( ) const

inline

get the min of the variable

Definition at line 309 of file STK_Stat_UnivariateReal.h.

{return min_;}

nbAvailableSamples()

template<class TContainer1D >

const int STK::Stat::Univariate< TContainer1D, Real >::nbAvailableSamples ( ) const

inline

get the number of available samples (not missing)

Definition at line 304 of file STK_Stat_UnivariateReal.h.

{return nbAvailable_;}

nbMissingSamples()

template<class TContainer1D >

const int STK::Stat::Univariate< TContainer1D, Real >::nbMissingSamples ( ) const

inline

get the number of missing samples

Definition at line 306 of file STK_Stat_UnivariateReal.h.

{return nbMiss_;}

nbSamples()

template<class TContainer1D >

const int STK::Stat::Univariate< TContainer1D, Real >::nbSamples ( ) const

inline

get the number of samples

Definition at line 302 of file STK_Stat_UnivariateReal.h.

{return nbSamples_;}

operator=()

template<class TContainer1D >

Univariate & STK::Stat::Univariate< TContainer1D, Real >::operator= ( const Univariate< TContainer1D, Real > &  stat )

inline

Operator = : overwrite the Univariate with stat.

Definition at line 182 of file STK_Stat_UnivariateReal.h.

    {
      nbSamples_ = stat.nbSamples_;
      nbAvailable_ = stat.nbAvailable_;
      nbMiss_ = stat.nbMiss_;
      V_           = stat.V_;
      W_           = stat.W_;
      weighted_    = stat.weighted_;
      sorted_      = stat.sorted_;
      comporder_   = stat.comporder_;
      compstat_    = stat.compstat_;
      sumweights_  = stat.sumweights_;
      sum2weights_ = stat.sum2weights_;
      min_         = stat.min_;
      max_         = stat.max_;
      amax_        = stat.amax_;
      mean_        = stat.mean_;
      median_      = stat.median_;
      var_         = stat.var_;
      uvar_        = stat.uvar_;
      std_         = stat.std_;
      ustd_        = stat.ustd_;
      mad_         = stat.mad_;
      kurtosis_    = stat.kurtosis_;
      skewness_    = stat.skewness_;
      quartiles_   = stat.quartiles_;
      deciles_     = stat.deciles_;
      viceciles_   = stat.viceciles_;
      percentiles_ = stat.percentiles_;
 
      return *this;
    }

percentiles()

template<class TContainer1D >

Variable< Real > const & STK::Stat::Univariate< TContainer1D, Real >::percentiles ( ) const

inline

get the percentiles of the variable (1%)

Definition at line 343 of file STK_Stat_UnivariateReal.h.

{ return percentiles_;}

quartiles()

template<class TContainer1D >

Variable< Real > const & STK::Stat::Univariate< TContainer1D, Real >::quartiles ( ) const

inline

get the quartiles of the variable (25%)

Definition at line 337 of file STK_Stat_UnivariateReal.h.

{return quartiles_;}

setData() [1/2]

template<class TContainer1D >

template<class Vector >

void STK::Stat::Univariate< TContainer1D, Real >::setData ( Vector const &  V, bool  sorted = false  )

inline

Compute the statistics of a new Variable.

Parameters

V	the variable to set
sorted	true if the variable is sorted

Definition at line 220 of file STK_Stat_UnivariateReal.h.

    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Vector);
      // set variable and weights
      V_ = V;
      W_.clear();  // no weights
      // initialize dimensions
      nbSamples_    = V_.size();
      nbAvailable_  = V_.size();
      nbMiss_ = 0;
      // initialize data
      weighted_    = false;
      sorted_      = sorted;
      comporder_   = false;
      compstat_    = false;
      sumweights_  = 0.0;
      sum2weights_ = 0.0;
      mean_        = Arithmetic<Real>::NA();
      median_      = Arithmetic<Real>::NA();
      var_         = Arithmetic<Real>::NA();
      uvar_        = Arithmetic<Real>::NA();
      std_         = Arithmetic<Real>::NA();
      ustd_        = Arithmetic<Real>::NA();
      mad_         = Arithmetic<Real>::NA();
      kurtosis_    = Arithmetic<Real>::NA();
      skewness_    = Arithmetic<Real>::NA();
      quartiles_   = Arithmetic<Real>::NA();
      deciles_     = Arithmetic<Real>::NA();
      viceciles_   = Arithmetic<Real>::NA();
      percentiles_ = Arithmetic<Real>::NA();
 
      initializeVariable();
      compOrderStatistics();
      compStatistics();
    }

References STK::IArray2D< Derived >::clear(), STK::Arithmetic< Type >::NA(), and STK_STATIC_ASSERT_ONE_DIMENSION_ONLY.

setData() [2/2]

template<class TContainer1D >

template<class Vector , class Weights >

void STK::Stat::Univariate< TContainer1D, Real >::setData ( Vector const &  V, Weights const &  W, bool  sorted = false  )

inline

Compute the statistics of a new weighted Variable.

Parameters

V,W	the variable and the weights to set
sorted	true if the variable is sorted

Definition at line 261 of file STK_Stat_UnivariateReal.h.

    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Vector);
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Weights);
      // check range size
      if ((V.range() != W.range()))
      {  STKRUNTIME_ERROR_NO_ARG(Univariate::setData(V, W, sorted),V and W have different range);}
      // set variable and weights
      V_ = V;
      W_ = W;
      // initialize dimensions
      nbSamples_    = V_.size();
      nbAvailable_  = V_.size();
      nbMiss_ = 0;
      // initialize data
      weighted_    = true;
      sorted_      = sorted;
      comporder_   = false;
      compstat_    = false;
      sumweights_  = 0.0;
      sum2weights_ = 0.0;
      mean_        = Arithmetic<Real>::NA();
      median_      = Arithmetic<Real>::NA();
      var_         = Arithmetic<Real>::NA();
      uvar_        = Arithmetic<Real>::NA();
      std_         = Arithmetic<Real>::NA();
      ustd_        = Arithmetic<Real>::NA();
      mad_         = Arithmetic<Real>::NA();
      kurtosis_    = Arithmetic<Real>::NA();
      skewness_    = Arithmetic<Real>::NA();
      quartiles_   = Arithmetic<Real>::NA();
      deciles_     = Arithmetic<Real>::NA();
      viceciles_   = Arithmetic<Real>::NA();
      percentiles_ = Arithmetic<Real>::NA();
 
      initializeVariableAndWeights();
      compOrderStatistics();
      compWeightedStatistics();
    }

References STK::Arithmetic< Type >::NA(), STK_STATIC_ASSERT_ONE_DIMENSION_ONLY, and STKRUNTIME_ERROR_NO_ARG.

skewness()

template<class TContainer1D >

const Real STK::Stat::Univariate< TContainer1D, Real >::skewness ( ) const

inline

get the skewness of the variable

Definition at line 334 of file STK_Stat_UnivariateReal.h.

{return skewness_;}

std()

template<class TContainer1D >

const Real STK::Stat::Univariate< TContainer1D, Real >::std ( ) const

inline

get the standard deviation of the variable

Definition at line 325 of file STK_Stat_UnivariateReal.h.

{return std_;}

unbiasedStd()

template<class TContainer1D >

const Real STK::Stat::Univariate< TContainer1D, Real >::unbiasedStd ( ) const

inline

get the sample standard deviation of the variable

Definition at line 327 of file STK_Stat_UnivariateReal.h.

{return ustd_;}

unbiasedVariance()

template<class TContainer1D >

const Real STK::Stat::Univariate< TContainer1D, Real >::unbiasedVariance ( ) const

inline

get the unbiased Variance of the variable (division by n-1)

Definition at line 323 of file STK_Stat_UnivariateReal.h.

{return uvar_;}

variance()

template<class TContainer1D >

const Real STK::Stat::Univariate< TContainer1D, Real >::variance ( ) const

inline

get the variance of the variable (division by n)

Definition at line 321 of file STK_Stat_UnivariateReal.h.

{return var_;}

viceciles()

template<class TContainer1D >

Variable< Real > const & STK::Stat::Univariate< TContainer1D, Real >::viceciles ( ) const

inline

get the viceciles of the variable (5%)

Definition at line 341 of file STK_Stat_UnivariateReal.h.

{ return viceciles_;}

Member Data Documentation

amax_

template<class TContainer1D >

Real STK::Stat::Univariate< TContainer1D, Real >::amax_

protected

Absolute maximal value.

Definition at line 692 of file STK_Stat_UnivariateReal.h.

comporder_

template<class TContainer1D >

bool STK::Stat::Univariate< TContainer1D, Real >::comporder_

protected

Orders Statistics are computed ?

Definition at line 684 of file STK_Stat_UnivariateReal.h.

compstat_

template<class TContainer1D >

bool STK::Stat::Univariate< TContainer1D, Real >::compstat_

protected

Usuals Statistics are computed ?

Definition at line 685 of file STK_Stat_UnivariateReal.h.

deciles_

template<class TContainer1D >

Variable<Real> STK::Stat::Univariate< TContainer1D, Real >::deciles_

protected

Deciles (10%)

Definition at line 705 of file STK_Stat_UnivariateReal.h.

kurtosis_

template<class TContainer1D >

Real STK::Stat::Univariate< TContainer1D, Real >::kurtosis_

protected

kurtosis of the variable

Definition at line 701 of file STK_Stat_UnivariateReal.h.

mad_

template<class TContainer1D >

Real STK::Stat::Univariate< TContainer1D, Real >::mad_

protected

absolute deviation of the variable

Definition at line 700 of file STK_Stat_UnivariateReal.h.

max_

template<class TContainer1D >

Real STK::Stat::Univariate< TContainer1D, Real >::max_

protected

Max of the variable.

Definition at line 691 of file STK_Stat_UnivariateReal.h.

mean_

template<class TContainer1D >

Real STK::Stat::Univariate< TContainer1D, Real >::mean_

protected

mean of the variable

Definition at line 694 of file STK_Stat_UnivariateReal.h.

median_

template<class TContainer1D >

Real STK::Stat::Univariate< TContainer1D, Real >::median_

protected

median of the variable

Definition at line 695 of file STK_Stat_UnivariateReal.h.

min_

template<class TContainer1D >

Real STK::Stat::Univariate< TContainer1D, Real >::min_

protected

Min of the variable.

Definition at line 690 of file STK_Stat_UnivariateReal.h.

nbAvailable_

template<class TContainer1D >

int STK::Stat::Univariate< TContainer1D, Real >::nbAvailable_

protected

Number of Available samples.

Definition at line 674 of file STK_Stat_UnivariateReal.h.

nbMiss_

template<class TContainer1D >

int STK::Stat::Univariate< TContainer1D, Real >::nbMiss_

protected

Number of missing samples.

Definition at line 675 of file STK_Stat_UnivariateReal.h.

nbSamples_

template<class TContainer1D >

int STK::Stat::Univariate< TContainer1D, Real >::nbSamples_

protected

Number of samples.

Definition at line 673 of file STK_Stat_UnivariateReal.h.

percentiles_

template<class TContainer1D >

Variable<Real> STK::Stat::Univariate< TContainer1D, Real >::percentiles_

protected

percentiles (1%)

Definition at line 707 of file STK_Stat_UnivariateReal.h.

quartiles_

template<class TContainer1D >

Variable<Real> STK::Stat::Univariate< TContainer1D, Real >::quartiles_

protected

Quartiles (25%)

Definition at line 704 of file STK_Stat_UnivariateReal.h.

skewness_

template<class TContainer1D >

Real STK::Stat::Univariate< TContainer1D, Real >::skewness_

protected

Skewness of the variable.

Definition at line 702 of file STK_Stat_UnivariateReal.h.

sorted_

template<class TContainer1D >

bool STK::Stat::Univariate< TContainer1D, Real >::sorted_

protected

Samples are sorted ?

Definition at line 683 of file STK_Stat_UnivariateReal.h.

std_

template<class TContainer1D >

Real STK::Stat::Univariate< TContainer1D, Real >::std_

protected

Standard deviation of the variable (n)

Definition at line 698 of file STK_Stat_UnivariateReal.h.

sum2weights_

template<class TContainer1D >

Real STK::Stat::Univariate< TContainer1D, Real >::sum2weights_

protected

Sum of the square of the weights.

Definition at line 689 of file STK_Stat_UnivariateReal.h.

sumweights_

template<class TContainer1D >

Real STK::Stat::Univariate< TContainer1D, Real >::sumweights_

protected

Sum of the weights.

Definition at line 688 of file STK_Stat_UnivariateReal.h.

ustd_

template<class TContainer1D >

Real STK::Stat::Univariate< TContainer1D, Real >::ustd_

protected

Sample standard deviation of the variable (n-1)

Definition at line 699 of file STK_Stat_UnivariateReal.h.

uvar_

template<class TContainer1D >

Real STK::Stat::Univariate< TContainer1D, Real >::uvar_

protected

Unbiased Variance of the variable (division by n-1)

Definition at line 697 of file STK_Stat_UnivariateReal.h.

V_

template<class TContainer1D >

TContainer1D STK::Stat::Univariate< TContainer1D, Real >::V_

protected

local copy of the variable

Definition at line 678 of file STK_Stat_UnivariateReal.h.

var_

template<class TContainer1D >

Real STK::Stat::Univariate< TContainer1D, Real >::var_

protected

Variance of the variable (division by n)

Definition at line 696 of file STK_Stat_UnivariateReal.h.

viceciles_

template<class TContainer1D >

Variable<Real> STK::Stat::Univariate< TContainer1D, Real >::viceciles_

protected

viceciles (5%)

Definition at line 706 of file STK_Stat_UnivariateReal.h.

W_

template<class TContainer1D >

TContainer1D STK::Stat::Univariate< TContainer1D, Real >::W_

protected

local copy of the weights

Definition at line 679 of file STK_Stat_UnivariateReal.h.

weighted_

template<class TContainer1D >

bool STK::Stat::Univariate< TContainer1D, Real >::weighted_

protected

Samples are weighted ?

Definition at line 682 of file STK_Stat_UnivariateReal.h.

---

The documentation for this class was generated from the following file:

• STK_Stat_UnivariateReal.h