STK_ModelGamma_aj_bj.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::Model
 * created on: 22 juil. 2011
 * Purpose: define the class IUnivStatModel.
 * Author:   iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 *
 **/
 
#ifndef STK_JOINTGAMMAMODEL_H
#define STK_JOINTGAMMAMODEL_H
 
#include <cmath>
 
#include "STK_Model_Util.h"
#include "STK_IMultiStatModel.h"
#include <Arrays/include/STK_Array2DPoint.h>
 
#include <STatistiK/include/STK_Law_Gamma.h>
#include <Analysis/include/STK_Algo_FindZero.h>
#include <Analysis/include/STK_Funct_raw.h>
 
namespace STK
{
// forward declaration
template <class Array, class WColVector = CVectorX> class ModelGamma_aj_bj;
struct ModelGamma_aj_bjParameters;
 
namespace hidden
{
template<class Data_, class WColVector_>
struct StatModelTraits< ModelGamma_aj_bj<Data_, WColVector_> >
{
  typedef DataBridge<Data_> Data;
  typedef WColVector_ WColVector;
  typedef typename Traits<Data_>::Type Type;
  typedef ModelGamma_aj_bjParameters Parameters;
};
 
} // hidden
 
struct ModelGamma_aj_bjParameters
{
  ModelGamma_aj_bjParameters() : shape_(), scale_(), mean_(), meanLog_(), variance_() {}
  ModelGamma_aj_bjParameters( Range const& range)
                            : shape_(range, 1.), scale_(range, 1.)
                            , mean_(range, 1.), meanLog_(range, 0.), variance_(range, 1.)
  {}
  ModelGamma_aj_bjParameters( ModelGamma_aj_bjParameters const& param)
                            : shape_(param.shape_), scale_(param.scale_)
                            , mean_(param.mean_), meanLog_(param.meanLog_), variance_(param.variance_)
  {}
  ~ModelGamma_aj_bjParameters() {}
  inline CPointX const& shape() const {return shape_;}
  inline CPointX const& scale() const {return scale_;}
 
  inline void resize(Range const& range)
  {
    if (range != range_)
    {
      shape_.resize(range); shape_ = 1.;
      scale_.resize(range); scale_ = 1.;
      mean_.resize(range); mean_ = 1.;
      meanLog_.resize(range); meanLog_ = 0.;
      variance_.resize(range); variance_ = 1.;
      range_ = range;
    }
  }
  CPointX shape_;
  CPointX scale_;
  CPointX mean_;
  CPointX meanLog_;
  CPointX variance_;
  Range range_;
};
 
 
template <class Data_, class WColVector_>
class ModelGamma_aj_bj: public IMultiStatModel< ModelGamma_aj_bj<Data_, WColVector_> >
{
  protected:
    class dloglikelihood: public IFunction<dloglikelihood >
    {
      public:
        dloglikelihood( Real const& mean, Real const& meanLog)
                      : delta_(meanLog - Real(std::log(mean))) {}
        inline Real fImpl(Real a) const
        { return (delta_ + std::log(a) - Funct::psi_raw(a));}
        inline Real xminImpl() const { return 0;}
      private:
        Real delta_;
    };
 
  public:
    typedef DataBridge<Data_> Data;
    typedef typename hidden::Traits<Data_>::Row RowVector;
    typedef WColVector_ WColVector;
    typedef IMultiStatModel< ModelGamma_aj_bj<Data_, WColVector_> > Base;
    using Base::p_data;
    using Base::param;
 
    ModelGamma_aj_bj(): Base() {}
    ModelGamma_aj_bj(Data const& data): Base(data){}
    ModelGamma_aj_bj(Data const* p_data): Base(p_data){}
    ModelGamma_aj_bj(ModelGamma_aj_bj const& model): Base(model) {}
    ~ModelGamma_aj_bj(){}
 
    inline CPointX const& shape() const {return param().shape_;}
    inline CPointX const& scale() const {return param().scale_;}
    inline CPointX const& mean() const {return param().mean_;}
    inline CPointX const& meanLog() const {return param().meanLog_;}
    inline CPointX const& variance() const {return param().variance_;}
 
    int computeNbFreeParameters() const { return 2*p_data()->dataij().sizeCols();}
    Real computeLnLikelihood( RowVector const& rowData) const;
    void computeParameters();
    void computeParameters( WColVector const& weights);
    void writeParametersImpl(ostream& os) const;
 
  private:
    inline CPointX& shape() { return param().shape_;}
    inline CPointX& scale() { return param().scale_;}
    inline CPointX& mean() { return param().mean_;}
    inline CPointX& meanLog() { return param().meanLog_;}
    inline CPointX& variance() { return param().variance_;}
};
 
/* compute the log Likelihood of an observation. */
template<class Data_, class WColVector_>
Real ModelGamma_aj_bj<Data_, WColVector_>::computeLnLikelihood( RowVector const& rowData) const
{
  Real sum =0.;
  for (Integer j= rowData.begin(); j < rowData.end(); ++j)
  { sum += Law::Gamma::lpdf(rowData[j], shape()[j], scale()[j]);}
  return sum;
}
 
/* compute the parameters */
template<class Data_, class WColVector_>
void ModelGamma_aj_bj<Data_, WColVector_>::computeParameters()
{
  for (int j=p_data()->dataij().beginCols(); j < p_data()->dataij().endCols(); ++j)
  {
    mean()[j] =  p_data()->dataij().col(j).meanSafe();
    meanLog()[j] = p_data()->dataij().col(j).safe(1.).log().mean();
    variance()[j] = p_data()->dataij().col(j).safe().variance();
    Real x0 = (mean()[j]*mean()[j]) / variance()[j];
    Real x1 = 0.9*x0 +  0.05/(mean()[j] - meanLog()[j]);
    dloglikelihood funct(mean()[j], meanLog()[j]);
    Real a =  Algo::findZero(funct, x0, x1, 1e-08);
    // replace with moment estimate if needed
    if (!Arithmetic<Real>::isFinite(a)) { a =  mean()[j]*mean()[j]/variance()[j];}
    shape()[j] = a;
    scale()[j] = mean()[j]/a;
  }
}
/* compute the weighted parameters */
template<class Data_, class WColVector_>
void ModelGamma_aj_bj<Data_, WColVector_>::computeParameters( WColVector const& weights)
{
  for (int j=p_data()->dataij().beginCols(); j < p_data()->dataij().endCols(); ++j)
  {
    mean()[j] =  p_data()->dataij().col(j).safe().wmean(weights);
    meanLog()[j] = p_data()->dataij().col(j).safe(1).log().wmean(weights);
    variance()[j] = p_data()->dataij().col(j).safe().wvariance(weights);
    Real x0 = (mean()[j]*mean()[j]) / variance()[j];
    Real x1 = 0.9*x0 +  0.05/(mean()[j] - meanLog()[j]);
    dloglikelihood funct(mean()[j], meanLog()[j]);
    Real a =  Algo::findZero(funct, x0, x1, 1e-08);
    // replace with moment estimate if needed
    if (!Arithmetic<Real>::isFinite(a)) { a =  mean()[j]*mean()[j]/variance()[j];}
    shape()[j] = a;
    scale()[j] = mean()[j]/a;
  }
}
 
/* Write the parameters on the output stream os */
template<class Data_, class WColVector_>
void ModelGamma_aj_bj<Data_, WColVector_>::writeParametersImpl(ostream& os) const
{
  os << _T("shape = ") << shape();
  os << _T("scale = ") << scale();
}
 
 
} // namespace STK
 
#endif /* STK_JOINTGAMMAMODEL_H */