Compute safely the variance of the variable V when the mean is given. More...

#include <STK_Stat_Functors.h>

Public Types
typedef Derived::Type	Type

Public Member Functions
	VarianceWithFixedMeanSafeOp (ExprBase< Derived > const &V)
	constructor

Type const	operator() (Type mu, bool unbiased) const

template<class Weights >
Type const	operator() (ExprBase< Weights > const &w, Type const &mu, bool unbiased) const

Protected Attributes
Derived const &	V_

Detailed Description

template<class Derived>
struct STK::Stat::VarianceWithFixedMeanSafeOp< Derived >

Compute safely the variance of the variable V when the mean is given.

Definition at line 635 of file STK_Stat_Functors.h.

Member Typedef Documentation

◆ Type

template<class Derived >

typedef Derived::Type STK::Stat::VarianceWithFixedMeanSafeOp< Derived >::Type

Definition at line 637 of file STK_Stat_Functors.h.

Constructor & Destructor Documentation

◆ VarianceWithFixedMeanSafeOp()

template<class Derived >

STK::Stat::VarianceWithFixedMeanSafeOp< Derived >::VarianceWithFixedMeanSafeOp ( ExprBase< Derived > const & V )

inline

constructor

Definition at line 639 of file STK_Stat_Functors.h.

639 : V_(V.asDerived())

640 { STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);}

STK_STATIC_ASSERT_ONE_DIMENSION_ONLY

#define STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(EXPR)

Definition STK_StaticAssert.h:151

STK::Stat::VarianceWithFixedMeanSafeOp::V_

Derived const & V_

Definition STK_Stat_Functors.h:713

References STK_STATIC_ASSERT_ONE_DIMENSION_ONLY.

Member Function Documentation

◆ operator()() [1/2]

template<class Derived >

template<class Weights >

Type const STK::Stat::VarianceWithFixedMeanSafeOp< Derived >::operator()	(	ExprBase< Weights > const &	w,
		Type const &	mu,
		bool	unbiased
	)		const

inline

Returns: the safely computed weighted variance of the variable V with fixed mean.
$\hat{\sigma^2} = \frac{1}{\sum_{i=1}^n w(i)} \sum_{i=1}^n w(i) (V(i) - \mu)^2$

Parameters

w	weights
mu	the mean
unbiased	`true` if we want an unbiased estimate of the variance, `false` otherwise

Definition at line 687 of file STK_Stat_Functors.h.

    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Weights);
      // no samples
      if (V_.empty()) { return Type(0);}
      if (V_.range() != w.range())
        STKRUNTIME_ERROR_NO_ARG(wmeanSafe,V.range()!=w.range());
      // sum the weighted samples
      Type sum = 0.0, sum1weights = 0.0, sum2weights = 0.0;
      for (int i=V_.begin(); i<V_.end(); i++)
      {
        if ( !Arithmetic<Type>::isNA(V_[i]) && !Arithmetic<Type>::isNA(w[i]) )
        { Type weight = std::abs(w[i]);
          sum1weights += weight;
          sum2weights += weight * weight;
          sum         += weight*(V_[i]-mu)*(V_[i]-mu); // deviation from the mean
        }
      }
      // compute the variance
      return (unbiased) ?
        (sum1weights) ? (sum)/(sum1weights - sum2weights/sum1weights)
                      : Arithmetic<Type>::infinity()
        :
        (sum1weights) ? (sum/sum1weights) : Type(0);
    }

References STK::Arithmetic< Type >::isNA(), STK_STATIC_ASSERT_ONE_DIMENSION_ONLY, STKRUNTIME_ERROR_NO_ARG, STK::Stat::sum(), and STK::Stat::VarianceWithFixedMeanSafeOp< Derived >::V_.

◆ operator()() [2/2]

template<class Derived >

Type const STK::Stat::VarianceWithFixedMeanSafeOp< Derived >::operator()	(	Type	mu,
		bool	unbiased
	)		const

inline

Returns: the safely computed variance of the variable V with fixed mean.
$\hat{\sigma^2} = \frac{1}{n} \sum_{i=1}^n (V(i) - \mu)^2.$
using a compensated algorithm and discarding the missing values.

Note: Chan, Tony F.; Golub, Gene H.; LeVeque, Randall J. (1983). Algorithms for Computing the Sample Variance: Analysis and Recommendations. The American Statistician 37, 242-247.

Parameters

mu	the fixed mean
unbiased	`true` if we want an unbiased estimate of the variance, `false` otherwise

Definition at line 652 of file STK_Stat_Functors.h.

    {
      // no samples
      if (V_.empty()) { return Type(0);}
      int nobs = V_.size();
      // sum
      Type sum  = 0.0, var  = 0.0, dev;
      for (int i=V_.begin(); i<V_.end(); i++)
      {
        if (!Arithmetic<Type>::isNA(V_[i]))
        {
          sum += (dev = V_[i] - mu); // deviation from the mean
          var += (dev*dev);         // squared value
        }
        else nobs--;
      }
      // compute the variance
      return (unbiased) ?
      (nobs > 1) ? (var - (sum*sum)/Type(nobs))/Type(nobs -1)
                 : Arithmetic<Type>::infinity()
      :
      (nobs > 0) ? (var - (sum*sum)/(Type)nobs)/(Type)(nobs)
                 : Type(0.);
    }