STK_Stat_MultivariateReal.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004-2007  Serge Iovleff

    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 : Serge.Iovleff@stkpp.org
*/

/*
 * Project:  StatDesc
 * Purpose:  Compute multivariate elementary statistics for
 * a 2D container.
 * Author:   Serge Iovleff, serge.iovleff@stkpp.org
 **/

#ifndef STK_STAT_MULTIVARIATEREAL_H
#define STK_STAT_MULTIVARIATEREAL_H

#include "../../STKernel/include/STK_Arithmetic.h"
#include "../../STKernel/include/STK_Misc.h"

#include "../../Arrays/include/STK_MatrixSquare.h"

#include "STK_Stat_UnivariateReal.h"
#include "STK_Stat_BivariateRealReal.h"
#include "STK_Stat_Multivariate.h"

namespace STK
{
namespace Stat
{

typedef Multivariate<Real, Matrix> MultivariateMatrix;

template < class TContainer2D >
class Multivariate<Real, TContainer2D > : public IRunnerPtr2D< Real, TContainer2D>
{
  typedef typename TContainer2D::TContainerHo TContainerHo;
  typedef typename TContainer2D::TContainerVe TContainerVe;
  typedef IRunnerPtr2D< Real, TContainer2D> Runner2D;

  public:
    Multivariate( TContainer2D const* p_data)
                : Runner2D(p_data)
                , nbSamples_(0)
                , nbVar_(0)
                , mean_(0)
                , var_(0)
                , cov_(0)
    { update(); }

    virtual ~Multivariate() { }

    inline Integer const& nbVar() const {return nbVar_;}
    inline Integer const& nbSamples() const {return nbSamples_;}
    inline TContainerHo const& mean() const { return mean_;}
    inline TContainerHo const& variance() const { return var_;}
    inline MatrixSquare const& covariance() const { return cov_;}
    virtual bool run()
    {
      try
      {
        if (!this->p_data_)
          throw runtime_error("data have not be set.");
        // get dimensions
        const Integer first = this->p_data_->firstCol(), last  = this->p_data_->lastCol();
        // for each variables
        for (Integer j= first; j<= last; j++)
        {
          mean_[j] = Stat::mean(this->p_data_->col(j));
          // compute the variance
          var_[j]  = varianceWithFixedMean(this->p_data_->col(j), mean_[j]);
          cov_(j, j) = var_[j];
          // compute the covariances
          for (Integer i= first; i<j; i++)
          {
            cov_(i, j) = covarianceWithFixedMean(this->p_data_->col(i), this->p_data_->col(j), mean_[i], mean_[j]);
            cov_(j, i) = cov_(i, j);
          }
        }
      }
      catch (Exception error)
      {
        this->msg_error_  = _T("Error in MultivariateReal::run():\nWhat: ");
        this->msg_error_ += error.error();
        return false;
      }
      // no error
      return true;
    }

    virtual bool run( TContainerVe const& weights)
    {
      try
      {
        if (!this->p_data_)
          throw runtime_error("data have not be set.");
        // get dimensions
        const Integer first = this->p_data_->firstCol(), last  = this->p_data_->lastCol();
        // for each variables
        for (Integer j= first; j<= last; j++)
        {
          mean_[j] = Stat::mean(this->p_data_->col(j), weights);
          // compute the variance
          var_[j]  = varianceWithFixedMean(this->p_data_->col(j), weights, mean_[j]);
          cov_(j, j) = var_[j];
          // compute the covariances
          for (Integer i= first; i<j; i++)
          {
            cov_(i, j) = covarianceWithFixedMean(this->p_data_->col(i), this->p_data_->col(j), weights, mean_[i], mean_[j]);
            cov_(j, i) = cov_(i, j);
          }
        }
      }
      catch (Exception error)
      {
        this->msg_error_  = _T("Error in MultivariateReal::run(weights): ");
        this->msg_error_ += error.error();
        return false;
      }
      // no error
      return true;
    }

  protected:
    Integer nbSamples_;
    Integer nbVar_;

    TContainerHo mean_;
    TContainerHo var_;
    MatrixSquare cov_;

    virtual void update()
    {
      // if there is no data there is nothing to update
      if (this->p_data_)
      {
        nbSamples_ = this->p_data_->sizeVe();
        nbVar_ = this->p_data_->sizeHo();
        mean_.resize(this->p_data_->rangeHo());
        var_.resize(this->p_data_->rangeHo());
        cov_.resize(this->p_data_->rangeHo());
      }
    }
};


template < class TContainerHo, class TContainer2D >
void mean( ITContainer2D< Real, TContainer2D> const&  V
         , ITContainer1D< Real, TContainerHo> & mean
         )
{
  // get dimensions
  const Integer  firstVar = V.firstCol(), lastVar = V.lastCol();
  mean.resize(V.rangeHo());
  for (Integer j= firstVar; j<= lastVar; j++)
    mean[j] = Stat::mean(V.col(j));
}

template < class TContainerHo, class TContainerVe, class TContainer2D >
void mean( ITContainer2D< Real, TContainer2D> const& V
         , ITContainer1D< Real, TContainerVe> const& W
         , ITContainer1D< Real, TContainerHo> & mean
         )
{
  // get dimensions
  const Integer  firstVar = V.firstCol(), lastVar = V.lastCol();
  mean.resize(V.rangeHo());
  for (Integer j= firstVar; j<= lastVar; j++)
    mean[j] = Stat::mean(V.col(j), W);
}

template < class TContainerHo, class TContainer2D >
TContainerHo mean( ITContainer2D< Real, TContainer2D> const&  V)
{
  TContainerHo mean(V.rangeHo());
  // get dimensions
  const Integer  firstVar = V.firstCol(), lastVar = V.lastCol();
  for (Integer j= firstVar; j<= lastVar; j++)
    mean[j] = Stat::mean(V.col(j));
  return mean;
}

template < class TContainerHo, class TContainerVe, class TContainer2D >
TContainerHo mean( ITContainer2D< Real, TContainer2D> const& V
                 , ITContainer1D< Real, TContainerVe> const& W
                 )
{
  // create result
  TContainerHo mean(V.rangeHo());
  // get dimensions
  const Integer  firstVar = V.firstCol(), lastVar = V.lastCol();
  for (Integer j= firstVar; j<= lastVar; j++)
    mean[j] = Stat::mean(V.col(j), W);
  return mean;
}

template < class TContainer2D >
typename TContainer2D::TContainerHo variance( ITContainer2D< Real, TContainer2D> const& V
                     , bool unbiased = false
                     )
{
  // create result
  typename TContainer2D::TContainerHo var(V.rangeHo());
  // get dimensions
  const Integer firstVar = V.firstCol(), lastVar = V.lastCol();
  for (Integer j= firstVar; j<= lastVar; j++)
  {
    var[j] = Stat::variance(V.col(j), unbiased);
  }
  // return variance
  return var;
}

template < class TContainerHo, class TContainerVe, class TContainer2D >
typename TContainer2D::TContainerHo variance( ITContainer2D< Real, TContainer2D> const& V
                     , TContainerVe const& W
                     , bool unbiased = false
                     )
{
  // create result
    typename TContainer2D::TContainerHo var(V.rangeHo());
  // get dimensions
  const Integer  firstVar = V.firstCol(), lastVar = V.lastCol();
  // check if there exist a mean vector
  for (Integer j= firstVar; j<= lastVar; j++)
    var[j] = Stat::variance(V.col(j), W, unbiased);
  // return variance
  return var;
}

template < class TContainerHo, class TContainerVe, class TContainer2D >
TContainerHo varianceWithFixedMean( ITContainer2D< Real, TContainer2D> const& V
                                  , TContainerHo const& mu
                                  , bool unbiased = false
                                  )
{
  if (mu.range() != V.rangeHo())
    throw runtime_error("In varianceWithFixedMean(V, mu, unbiased) "
                             "mu.range() != V.rangeHo()");
  // create result
  TContainerHo var(V.rangeHo());
  // get dimensions
  const Integer  firstVar = V.firstCol(), lastVar = V.lastCol();
  for (Integer j= firstVar; j<= lastVar; j++)
    var[j] = Stat::varianceWithFixedMean(V.col(j), mu[j], unbiased);
  // return variance
  return var;
}

template < class TContainerHo, class TContainerVe, class TContainer2D >
TContainerHo varianceWithFixedMean( ITContainer2D< Real, TContainer2D> const& V
                                  , TContainerVe const& W
                                  , TContainerHo const& mu
                                  , bool unbiased = false
                                  )
{
#ifdef STK_DEBUG
  if (mu.range() != V.rangeHo())
    throw runtime_error(_T("In varianceWithFixedMean(V, W, mu) "
                           "mu.range() != V.rangeHo()"));
#endif
  // create result
  TContainerHo var(V.rangeHo());
  // get dimensions
  const Integer  firstVar = V.firstCol(), lastVar = V.lastCol();
  for (Integer j= firstVar; j<= lastVar; j++)
    var[j] = Stat::varianceWithFixedMean<TContainerVe>(V[j], W, mu[j], unbiased);
  // return variance
  return var;
}

template < class TContainer2D >
void covariance( TContainer2D const& V
               , MatrixSquare & cov
               , bool unbiased = false
               )
{
  typename ContainerTraits<Real, TContainer2D>::TContainerHo mean;
  // compute the
  Stat::mean(V, mean);
  // get dimensions
  const Integer firstVar = V.firstCol(), lastVar = V.lastCol();
  cov.resize(V.rangeHo());
  for (Integer j= firstVar; j<= lastVar; j++)
  {
    cov(j, j) = Stat::varianceWithFixedMean(V.col(j), mean[j], unbiased);
    for (Integer i= firstVar; i<j; i++)
    {
      cov(j,i) = ( cov(i, j) = Stat::covarianceWithFixedMean(V.col(i), V.col(j), mean[i], mean[j], unbiased));
    }
  }
}

template < class TContainerVe, class TContainer2D >
void covariance( ITContainer2D< Real, TContainer2D> const& V
               , ITContainer1D< Real, TContainerVe> const& W
               , MatrixSquare & cov
               , bool unbiased = false
               )
{
  typename ContainerTraits<Real, TContainer2D>::TContainerHo mean;
  // compute the
  Stat::mean(V, W, mean);
  // get dimensions
  const Integer firstVar = V.firstCol(), lastVar = V.lastCol();
  cov.resize(V.rangeHo(), V.rangeHo());
  for (Integer j= firstVar; j<= lastVar; j++)
  {
    cov(j, j) = Stat::varianceWithFixedMean(V.col(j), W, unbiased);
    for (Integer i= firstVar; i<j; i++)
    {
      cov(j,i) = ( cov(i, j) = Stat::covarianceWithFixedMean(V.col(i), V.col(j), W, mean[i], mean[j], unbiased));
    }
  }
}


}  // namespace Stat

}  // namespace STK

#endif /*STK_STAT_MULTIVARIATEREAL_H*/