STK_Stat_Functors.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004-2016  Serge Iovleff, Université Lille 1, Inria
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as
    published by the Free Software Foundation; either version 2 of the
    License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public
    License along with this program; if not, write to the
    Free Software Foundation, Inc.,
    59 Temple Place,
    Suite 330,
    Boston, MA 02111-1307
    USA
 
    Contact : S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
*/
 
/*
 * Project:  stkpp::STatistiK::StatDesc
 * Purpose:  Compute elementary 1D statistics for all variables.
 * Author:   Serge Iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 **/
 
#ifndef STK_STAT_FUNCTORS_H
#define STK_STAT_FUNCTORS_H
 
#include <Arrays/include/STK_ExprBaseFunctors.h>
 
#define FUNCTION_ON_ARRAY(funct, Op) \
template< class Derived> \
typename hidden::FunctorTraits<Derived, Op >::Row \
funct(Derived const& A) \
{ return typename hidden::FunctorTraits<Derived, Op>::ColOp(A)();} \
template< class Derived, class Weights> \
typename hidden::FunctorTraits<Derived, Op >::Row \
funct(Derived const& A, Weights const& w) \
{ return typename hidden::FunctorTraits<Derived, Op>::ColWeightedOp(A)(w);} \
template< class Derived> \
typename hidden::FunctorTraits<Derived, Op >::Row \
funct##ByCol(Derived const& A) \
{ return typename hidden::FunctorTraits<Derived, Op>::ColOp(A)();} \
template< class Derived, class Weights> \
typename hidden::FunctorTraits<Derived, Op >::Row \
funct##ByCol(Derived const& A, Weights const& w) \
{ return typename hidden::FunctorTraits<Derived, Op>::ColWeightedOp(A)(w);} \
template< class Derived> \
typename hidden::FunctorTraits<Derived, Op >::Col \
funct##ByRow(Derived const& A) \
{ return typename hidden::FunctorTraits<Derived, Op>::RowOp(A)();} \
template< class Derived, class Weights> \
typename hidden::FunctorTraits<Derived, Op >::Col \
funct##ByRow(Derived const& A, Weights const& w) \
{ return typename hidden::FunctorTraits<Derived, Op>::RowWeightedOp(A)(w);}
 
 
namespace STK
{
 
 
namespace Stat
{
template<class Derived>
struct MinOp
{
    typedef typename Derived::Type Type;
    inline MinOp( ExprBase<Derived> const&  V):  V_(V.asDerived())
    { STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);}
    Type const operator()() const
    {
      Type min  = Arithmetic<Type>::max();
      for (int i=V_.begin(); i<V_.end(); i++)
      { min = std::min(min, V_[i]);}
      return min;
    }
    template< class Weights>
    Type const operator()( ExprBase<Weights> const&  w) const
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Weights);
      Type min  = Arithmetic<Type>::max();
      for (int i=V_.begin(); i<V_.end(); i++)
      { min = std::min(min, w[i]*V_[i]);}
      return min;
    }
  protected:
    Derived const& V_;
};
 
template<class Derived>
struct MinSafeOp
{
    typedef typename Derived::Type Type;
    inline MinSafeOp( ExprBase<Derived> const&  V) :  V_(V.asDerived())
    { STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);}
    Type const operator()() const
    {
      Type min  = Arithmetic<Type>::max();
      for (int i=V_.begin(); i<V_.end(); i++)
      { if (Arithmetic<Type>::isFinite(V_[i])) min = std::min(min, V_[i]);}
      return min;
    }
    template< class Weights>
    Type const operator()( ExprBase<Weights> const&  w) const
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Weights);
      Type min  = Arithmetic<Type>::max();
      for (int i=V_.begin(); i<V_.end(); i++)
      { if (!Arithmetic<Type>::isNA(V_[i])) min = std::min(min, w[i]*V_[i]);}
      return min;
    }
  protected:
    Derived const& V_;
};
 
template<class Derived>
struct MaxOp
{
    typedef typename Derived::Type Type;
    inline MaxOp( ExprBase<Derived> const&  V) :  V_(V.asDerived())
    { STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);}
    Type const operator()() const
    {
      Type max  = -Arithmetic<Type>::max();
      for (int i=V_.begin(); i<V_.end(); i++)
      { max = std::max(max, V_[i]);}
      return max;
    }
    template< class Weights>
    Type const operator()( ExprBase<Weights> const&  w) const
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Weights);
      Type max  = -Arithmetic<Type>::max();
      for (int i=V_.begin(); i<V_.end(); i++)
      { max = std::max(max, w[i]*V_[i]);}
      return max;
    }
  protected:
    Derived const& V_;
};
 
template<class Derived>
struct MaxSafeOp
{
    typedef typename Derived::Type Type;
    inline MaxSafeOp( ExprBase<Derived> const&  V) :  V_(V.asDerived())
    { STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);}
    Type const operator()() const
    {
      Type max  = -Arithmetic<Type>::max();
      for (int i=V_.begin(); i<V_.end(); i++)
      { if (!Arithmetic<Type>::isNA(V_[i])) max = std::max(max, V_[i]);}
      return max;
    }
    template< class Weights>
    Type const operator()( ExprBase<Weights> const&  w) const
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Weights);
      Type max  = -Arithmetic<Type>::max();
      for (int i=V_.begin(); i<V_.end(); i++)
      { if (!Arithmetic<Type>::isNA(V_[i])) max = std::max(max, w[i]*V_[i]);}
      return max;
    }
  protected:
    Derived const& V_;
};
 
template<class Derived>
struct SumOp
{
    typedef typename Derived::Type Type;
    inline SumOp( ExprBase<Derived> const&  V) :  V_(V.asDerived())
    { STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);}
    Type const operator()() const
    {
      Type sum  = 0.;
      for (int i=V_.begin(); i<V_.end(); i++) { sum += V_[i];}
      return sum;
    }
    template< class Weights>
    Type const operator()( ExprBase<Weights> const&  w) const
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Weights);
      // sum the weighted samples
      Type sum  = 0.0;
      for (int i=V_.begin(); i<V_.end(); i++) { sum += w[i] * V_[i];}
      return sum;
    }
  protected:
    Derived const& V_;
};
 
template<class Derived>
struct SumSafeOp
{
    typedef typename Derived::Type Type;
    inline SumSafeOp( ExprBase<Derived> const&  V) :  V_(V.asDerived())
    { STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);}
    Type const operator()() const
    {
      // sum the samples
      Type sum  = 0.0;
      for (int i=V_.begin(); i<V_.end(); i++)
      { if (!Arithmetic<Type>::isNA(V_[i])) sum += V_[i];}
      return sum;
    }
    template< class Weights>
    inline Type const operator()( ExprBase<Weights> const&  w) const
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Weights);
#ifdef STK_BOUNDS_CHECK
      if (V_.range() != w.range())
        STKRUNTIME_ERROR_NO_ARG(wmeanSafe,V.range()!=w.range());
#endif
      // sum the weighted samples
      Type sum  = 0.0;
      for (int i=V_.begin(); i<V_.end(); i++)
      { if ( (!Arithmetic<Type>::isNA(V_[i])) && (!Arithmetic<Type>::isNA(w[i])))
        { sum += std::abs(w[i]) * V_[i];}
      }
      return sum;
    }
  protected:
    Derived const& V_;
};
 
template<class Derived>
struct MeanOp
{
    typedef typename Derived::Type Type;
    inline MeanOp( ExprBase<Derived> const&  V) :  V_(V.asDerived())
    { STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);}
    Type const operator()() const
    {
      // no samples
      if (V_.empty()) { return Type(0);}
      // sum the samples
      Type sum  = 0.;
      for (int i=V_.begin(); i<V_.end(); i++) { sum += V_[i];}
      return sum /= (Type)(V_.size());
    }
    template< class Weights>
    Type const operator()( ExprBase<Weights> const&  w) const
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Weights);
      // no samples
      if (V_.empty()) { return Type(0);}
      // sum the weighted samples
      Type sum  = 0.0, sumweights= 0.0;
      for (int i=V_.begin(); i<V_.end(); i++)
      {
        Type const weight = std::abs(w[i]);
        sumweights += weight;
        sum        += weight * V_[i];
      }
      // compute the weighted mean. If all weights are 0, we get 0
      return (sumweights) ? sum /= sumweights: Type(0);
    }
  protected:
    Derived const& V_;
};
 
template<class Derived>
struct MeanSafeOp
{
    typedef typename Derived::Type Type;
    inline MeanSafeOp( ExprBase<Derived> const&  V) :  V_(V.asDerived())
    { STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);}
    Type const operator()() const
    {
      // no samples
      if (V_.empty()) { return Type(0);}
      // get dimensions
      int nobs = V_.size();
      // sum the samples
      Type sum  = 0.0;
      for (int i=V_.begin(); i<V_.end(); i++)
      { (!Arithmetic<Type>::isNA(V_[i])) ? sum += V_[i] : nobs--;}
      // compute the mean
      return nobs ? (sum /= Type(nobs)) : Type(0);
    }
    template< class Weights>
    inline Type const operator()( ExprBase<Weights> const&  w) const
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Weights);
      // no samples
      if (V_.empty()) { return Type(0);}
#ifdef STK_BOUNDS_CHECK
      if (V_.range() != w.range())
        STKRUNTIME_ERROR_NO_ARG(wmeanSafe,V.range()!=w.range());
#endif
      // sum the weighted samples
      Type sum  = 0.0, sumweights= 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]);
          sumweights += weight;
          sum        += weight * V_[i];
        }
      }
      // compute the weighted mean. If all weights are 0, we get 0
      return (sumweights) ? (sum / sumweights) : Type(0);
    }
  protected:
    Derived const& V_;
};
 
template<class Derived>
struct VarianceOp
{
    typedef typename Derived::Type Type;
    inline VarianceOp( ExprBase<Derived> const&  V) :  V_(V.asDerived())
    { STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);}
    inline Type const operator()(bool unbiased) const
    {
      // no samples
      if (V_.empty()) { return Type(0);}
 
      int nobs = V_.size();
      // Compute the mean and sum
      Type mu = MeanOp<Derived>(V_)();
      Type sum  = 0.0, var  = 0.0, dev;
      for (int i=V_.begin(); i<V_.end(); i++)
      {
        sum += (dev = V_[i] - mu); // deviation from the mean
        var += (dev*dev);         // squared value
      }
      // 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);
    }
    template< class Weights>
    inline Type const operator()( ExprBase<Weights> const&  w, bool unbiased) const
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Weights);
      // no samples
      if (V_.empty()) { return Type(0);}
      // Compute the mean
      Type mu = MeanOp<Derived>(V_)(w);
      // sum the weighted samples
      Type sum = 0.0, sum1weights= 0.0, sum2weights = 0.0;
      for (int i=V_.begin(); i<V_.end(); i++)
      {
        Type const weight = 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) : Type(0)
      :
      (sum1weights) ? (sum/sum1weights) : Type(0);
    }
  protected:
    Derived const& V_;
};
 
template<class Derived>
struct VarianceSafeOp
{
    typedef typename Derived::Type Type;
    inline VarianceSafeOp( ExprBase<Derived> const&  V) :  V_(V.asDerived())
    { STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);}
    Type const operator()(bool unbiased) const
    {
      // no samples
      if (V_.empty()) { return Type(0);}
      int nobs = V_.size();
      // Compute the mean
      Type mu = MeanSafeOp<Derived>(V_)();
      // 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);
    }
    template< class Weights>
    Type const operator()( ExprBase<Weights> const&  w, bool unbiased) const
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Weights);
      // no samples
      if (V_.empty()) { return Type(0);}
      // Compute the mean
      Type mu = MeanSafeOp<Derived>(V_)(w);
#ifdef STK_BOUNDS_CHECK
      if (V_.range() != w.range())
        STKRUNTIME_ERROR_NO_ARG(VarianceSafeOp,V.range()!=w.range());
#endif
      // 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) : 0.
      :
      (sum1weights) ? (sum/sum1weights) : 0.;
    }
  protected:
    Derived const& V_;
};
 
template<class Derived>
struct VarianceWithFixedMeanOp
{
  typedef typename Derived::Type Type;
  inline VarianceWithFixedMeanOp( ExprBase<Derived> const&  V) :  V_(V.asDerived())
  { STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);}
    Type const operator()( Type const& mu, bool unbiased) const
    {
      // no samples
      if (V_.empty()) { return Type(0);}
      int nobs = V_.size();
      // sum
      Type sum = 0., var = 0., dev;
      for (int i=V_.begin(); i<V_.end(); i++)
      {
        sum += (dev = V_[i] - mu); // deviation from the mean
        var += (dev*dev);         // squared value
      }
      // unbiased 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);
    }
    template< class Weights>
    Type const operator()( ExprBase<Weights> const& w, Type const& mu, bool unbiased) const
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Weights);
      // no samples
      if (V_.empty()) { return Type(0);}
      // sum the weighted samples
      Type sum = 0.0, sum1weights = 0.0, sum2weights = 0.0;
      for (int i=V_.begin(); i<V_.end(); i++)
      {
        Real weight = std::abs(w[i]); // only positive weights
        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);
    }
  protected:
    Derived const& V_;
};
 
template<class Derived>
struct VarianceWithFixedMeanSafeOp
{
    typedef typename Derived::Type Type;
    inline VarianceWithFixedMeanSafeOp( ExprBase<Derived> const&  V) :  V_(V.asDerived())
    { STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);}
    Type const operator()( Type mu, bool unbiased) const
    {
      // 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.);
    }
 
    template< class Weights>
    Type const operator()( ExprBase<Weights> const& w, Type const& mu, bool unbiased) const
    {
      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);
    }
  protected:
    Derived const& V_;
};
 
FUNCTION_ON_ARRAY(min, MinOp)
 
 
FUNCTION_ON_ARRAY(minSafe, MinSafeOp)
 
FUNCTION_ON_ARRAY(max, MaxOp)
 
FUNCTION_ON_ARRAY(maxSafe, MaxSafeOp)
 
FUNCTION_ON_ARRAY(sum, SumOp)
 
FUNCTION_ON_ARRAY(sumSafe, SumSafeOp)
 
FUNCTION_ON_ARRAY(mean, MeanOp)
 
FUNCTION_ON_ARRAY(meanSafe, MeanSafeOp)
 
template< class Derived>
typename hidden::FunctorTraits<Derived, VarianceOp >::Row
variance(Derived const& A, bool unbiased = false)
{ return typename hidden::FunctorTraits<Derived, VarianceOp>::ColOp(A)(unbiased);}
 
template< class Derived, class Weights>
typename hidden::FunctorTraits<Derived, VarianceOp >::Row
variance(Derived const& A, ExprBase<Weights> const& w, bool unbiased = false)
{ return typename hidden::FunctorTraits<Derived, VarianceOp>::ColWeightedOp(A)(w, unbiased);}
 
template< class Derived>
typename hidden::FunctorTraits<Derived, VarianceOp >::Row
varianceByCol(Derived const& A, bool unbiased = false)
{ return typename hidden::FunctorTraits<Derived, VarianceOp>::ColOp(A)(unbiased);}
 
template< class Derived, class Weights>
typename hidden::FunctorTraits<Derived, VarianceOp >::Row
varianceByCol(Derived const& A, ExprBase<Weights> const& w, bool unbiased = false)
{ return typename hidden::FunctorTraits<Derived, VarianceOp>::ColWeightedOp(A)(w, unbiased);}
 
template< class Derived>
typename hidden::FunctorTraits<Derived, VarianceOp >::Col
varianceByRow(Derived const& A, bool unbiased = false)
{ return typename hidden::FunctorTraits<Derived, VarianceOp>::RowOp(A)(unbiased);}
 
 
template< class Derived, class Weights>
typename hidden::FunctorTraits<Derived, VarianceOp >::Col
varianceByRow(Derived const& A, ExprBase<Weights> const& w, bool unbiased = false)
{ return typename hidden::FunctorTraits<Derived, VarianceOp>::RowWeightedOp(A)(w, unbiased);}
 
template< class Derived>
typename hidden::FunctorTraits<Derived, VarianceSafeOp >::Row
varianceSafe(Derived const& A, bool unbiased = false)
{ return typename hidden::FunctorTraits<Derived, VarianceSafeOp>::ColOp(A)(unbiased);}
 
template< class Derived, class Weights>
typename hidden::FunctorTraits<Derived, VarianceSafeOp >::Row
varianceSafe(Derived const& A, ExprBase<Weights> const& w, bool unbiased = false)
{ return typename hidden::FunctorTraits<Derived, VarianceSafeOp>::ColWeightedOp(A)(w, unbiased);}
 
template< class Derived>
typename hidden::FunctorTraits<Derived, VarianceSafeOp >::Row
varianceSafeByCol(Derived const& A, bool unbiased = false)
{ return typename hidden::FunctorTraits<Derived, VarianceSafeOp>::ColOp(A)(unbiased);}
 
template< class Derived, class Weights>
typename hidden::FunctorTraits<Derived, VarianceSafeOp >::Row
varianceSafeByCol(Derived const& A, ExprBase<Weights> const& w, bool unbiased = false)
{ return typename hidden::FunctorTraits<Derived, VarianceSafeOp>::ColWeightedOp(A)(w, unbiased);}
 
template< class Derived>
typename hidden::FunctorTraits<Derived, VarianceSafeOp >::Col
varianceSafeByRow(Derived const& A, bool unbiased = false)
{ return typename hidden::FunctorTraits<Derived, VarianceSafeOp>::RowOp(A)(unbiased);}
 
template< class Derived, class Weights>
typename hidden::FunctorTraits<Derived, VarianceSafeOp >::Col
varianceSafeByRow(Derived const& A, ExprBase<Weights> const& w, bool unbiased = false)
{ return typename hidden::FunctorTraits<Derived, VarianceSafeOp>::RowWeightedOp(A)(w, unbiased);}
 
template< class Derived, class MeanType>
typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanOp >::Row
varianceWithFixedMean(Derived const& A, MeanType const& mean, bool unbiased)
{ return typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanOp>::ColOp(A)(mean, unbiased);}
 
template< class Derived, class MeanType, class Weights>
typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanOp >::Row
varianceWithFixedMean(Derived const& A, ExprBase<Weights> const& w, MeanType const& mean, bool unbiased)
{ return typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanOp>::ColWeightedOp(A)(w, mean, unbiased);}
 
template< class Derived, class MeanType>
typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanOp >::Row
varianceWithFixedMeanByCol(Derived const& A, MeanType const& mean, bool unbiased)
{ return typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanOp>::ColOp(A)(mean, unbiased);}
 
template< class Derived, class MeanType, class Weights>
typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanOp >::Row
varianceWithFixedMeanByCol(Derived const& A, ExprBase<Weights> const& w, MeanType const& mean, bool unbiased)
{ return typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanOp>::ColWeightedOp(A)(w, mean, unbiased);}
 
template< class Derived, class MeanType>
typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanOp >::Col
varianceWithFixedMeanByRow(Derived const& A, MeanType const& mean, bool unbiased = false)
{ return typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanOp>::RowOp(A)(mean, unbiased);}
 
template< class Derived, class MeanType, class Weights>
typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanOp >::Col
varianceWithFixedMeanByRow(Derived const& A, ExprBase<Weights> const& w, MeanType const& mean, bool unbiased)
{ return typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanOp>::RowWeightedOp(A)(w, mean, unbiased);}
 
template< class Derived, class MeanType>
typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanSafeOp >::Row
varianceWithFixedMeanSafe( Derived const& A, MeanType const& mean, bool unbiased)
{ return typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanSafeOp>::ColOp(A)(mean, unbiased);}
 
template< class Derived, class MeanType, class Weights>
typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanSafeOp >::Row
varianceWithFixedMeanSafe( Derived const& A, ExprBase<Weights> const& w, MeanType const& mean, bool unbiased)
{ return typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanSafeOp>::ColWeightedOp(A)(w, mean, unbiased);}
 
template< class Derived, class MeanType>
typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanSafeOp >::Row
varianceWithFixedMeanSafeByCol( Derived const& A, MeanType const& mean, bool unbiased)
{ return typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanSafeOp>::ColOp(A)(mean, unbiased);}
 
template< class Derived, class MeanType, class Weights>
typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanSafeOp >::Row
varianceWithFixedMeanSafeByCol( Derived const& A, ExprBase<Weights> const& w, MeanType const& mean, bool unbiased)
{ return typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanSafeOp>::ColWeightedOp(A)(w, mean, unbiased);}
 
template< class Derived, class MeanType>
typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanSafeOp >::Col
varianceWithFixedMeanSafeByRow(Derived const& A, MeanType const& mean, bool unbiased)
{ return typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanSafeOp>::RowOp(A)(mean, unbiased);}
 
template< class Derived, class MeanType, class Weights>
typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanSafeOp >::Col
varianceWithFixedMeanSafeByRow(Derived const& A, ExprBase<Weights> const& w, MeanType const& mean, bool unbiased)
{ return typename hidden::FunctorTraits<Derived, VarianceWithFixedMeanOp>::RowWeightedOp(A)(w, mean, unbiased);}
 
 
}  // namespace Stat
 
}  // namespace STK
 
#undef FUNCTION_ON_ARRAY
 
#endif /*STK_STAT_FUNCTORS_H*/