STK_ModelBernoulli_pj.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_MODELBERNOULLI_PJ_H
#define STK_MODELBERNOULLI_PJ_H
 
#include <cmath>
 
#include "STK_Model_Util.h"
#include "STK_IMultiStatModel.h"
#include <STatistiK/include/STK_Law_Bernoulli.h>
 
namespace STK
{
// forward declaration
template <class Data, class WColVector = CVectorX> class ModelBernoulli_pj;
class Bernoulli_pjParameters;
 
namespace hidden
{
template<class Data_, class WColVector_>
struct StatModelTraits< ModelBernoulli_pj<Data_, WColVector_> >
{
  typedef DataBridge<Data_> Data;
  typedef WColVector_ WColVector;
  typedef typename Traits<Data_>::Type Type;
  typedef Bernoulli_pjParameters Parameters;
};
 
} // hidden
 
class Bernoulli_pjParameters
{
  public:
    Bernoulli_pjParameters() {}
    Bernoulli_pjParameters( Range const& size)
                          : prob_(size, 0.5)
                          , lnProb_(size, -Const::_LN2_)
                          , ln1mProb_(size, -Const::_LN2_)
    {}
    Bernoulli_pjParameters( Bernoulli_pjParameters const& param)
                          : prob_(param.prob_)
                          , lnProb_(param.lnProb_)
                          , ln1mProb_(param.ln1mProb_)
    {}
    ~Bernoulli_pjParameters() {}
    inline Range const& range() const { return range_;}
    inline CPointX const& prob() const { return prob_;}
    inline CPointX const& lnProb() const { return lnProb_;}
    inline CPointX const& ln1mProb() const { return ln1mProb_;}
 
    inline void setProb(int j, Real const& prob)
    { prob_[j] = prob;
      if (prob>0) { lnProb_[j] = std::log(prob);}
      else        { lnProb_[j] = -Arithmetic<Real>::infinity();}
      if (prob<1) { ln1mProb_[j] = std::log(1.-prob);}
      else        { ln1mProb_[j] = -Arithmetic<Real>::infinity();}
    }
    inline void resize(Range const& range)
    {
      if (range != range_)
      {
        prob_.resize(range); lnProb_.resize(range); ln1mProb_.resize(range);
        range_ = range;
      }
    }
 
    CPointX prob_;
    CPointX lnProb_;
    CPointX ln1mProb_;
    Range range_;
};
 
template <class Data_, class WColVector_>
class ModelBernoulli_pj: public IMultiStatModel< ModelBernoulli_pj<Data_, WColVector_> >
{
  public:
    typedef DataBridge<Data_> Data;
    typedef typename hidden::Traits<Data_>::Row RowVector;
    typedef WColVector_ WColVector;
    typedef typename hidden::Traits<Data_>::Type Type;
    typedef IMultiStatModel< ModelBernoulli_pj<Data_, WColVector_> > Base;
    using Base::p_data;
    using Base::param;
 
    ModelBernoulli_pj(): Base() {}
    ModelBernoulli_pj( Data const& data): Base(data) {}
    ModelBernoulli_pj( Data const* p_data): Base(p_data) {}
    ModelBernoulli_pj( ModelBernoulli_pj const& model): Base(model) {}
    ~ModelBernoulli_pj() {}
 
    inline CPointX const& prob() const { return param().prob();}
    inline CPointX const& lnProb() const { return param().lnProb();}
    inline CPointX const& ln1mProb() const { return param().ln1mProb();}
 
    inline int computeNbFreeParameters() const { return p_data()->dataij().sizeCols();}
    Real computeLnLikelihood( RowVector const& rowData) const;
    void computeParameters();
    void computeParameters(WColVector const& weights);
    void writeParametersImpl(ostream& os) const;
};
 
/* compute the log Likelihood of an observation. */
template<class Data_, class WColVector_>
Real ModelBernoulli_pj<Data_, WColVector_>::computeLnLikelihood( RowVector const& rowData) const
{
  Real sum =0.;
  for (Integer j= rowData.begin(); j < rowData.end(); ++j)
  {
    sum += rowData[j] * lnProb()[j] + (1-rowData[j] * ln1mProb()[j] );
  }
  return sum;
}
 
/* compute the parameters */
template<class Data_, class WColVector_>
void ModelBernoulli_pj<Data_, WColVector_>::computeParameters()
{
  for (int j=p_data()->dataij().beginCols(); j < p_data()->dataij().endCols(); ++j)
  {
    Real sum=0.;
    int nbObs=p_data()->dataij().sizeRows();
 
    for (int i=p_data()->dataij().beginRows(); i<p_data()->dataij().endRows(); ++i)
    { (p_data()->dataij().elt(i,j) == binaryNA_) ? --nbObs : sum += p_data()->dataij().elt(i,j);}
    if (nbObs != 0) { param().prob_[j] = sum/nbObs;}
               else { param().prob_[j] = Arithmetic<Real>::NA();}
  }
}
/* compute the weighted parameters */
template<class Data_, class WColVector_>
void ModelBernoulli_pj<Data_, WColVector_>::computeParameters( WColVector const& weights)
{
  // compute
  for (int j=p_data()->dataij().beginCols(); j < p_data()->dataij().endCols(); ++j)
  {
    Real sum=0., wsum = 0.;
    for (int i=p_data()->dataij().beginRows(); i<p_data()->dataij().endRows(); ++i)
    { if (p_data()->dataij().elt(i,j) != binaryNA_)
      { sum  += weights[i]*p_data()->dataij().elt(i,j);
        wsum += weights[i];
      }
    }
    if (wsum != 0) { param().prob_[j] = sum/wsum;}
              else { param().prob_[j] = Arithmetic<Real>::NA();}
  }
}
 
/* Write the parameters on the output stream os */
template<class Data_, class WColVector_>
void ModelBernoulli_pj<Data_, WColVector_>::writeParametersImpl(ostream& os) const
{
  os << _T("prob = ") << prob();
  os << _T("lnProb = ") << lnProb();
  os << _T("ln1mProb = ") << ln1mProb();
}
 
} // namespace STK
 
#endif /* STK_MODELBERNOULLI_PJ_H */