STK_IAAModel.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::AAModels
 * Purpose: Interface bas class for all AA Models.
 * Author:  iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 *
 **/
 
#ifndef STK_IAAMODEL_H
#define STK_IAAMODEL_H
 
#include <Arrays/include/STK_Array2DPoint.h>
#include <Arrays/include/STK_Array2DVector.h>
 
#include <STatistiK/include/STK_Stat_MultivariateReal.h>
#include <STatistiK/include/STK_Stat_Transform.h>
 
#include "Reduct/include/STK_IReducer.h"
#include "Regress/include/STK_IRegression.h"
 
#ifdef STK_AAMODELS_VERBOSE
#include "Arrays/include/STK_Display.h"
#endif
 
 
namespace STK
{
template<class Array>
class IAAModel
{
  private:
    typedef IRegression<Array, Array, VectorX > Regressor;
    typedef IReducer<Array, VectorX > Reducer;
 
  protected:
    IAAModel( Array* p_workData);
    IAAModel( Array& workData);
  public:
    ~IAAModel();
    inline Array const& workData() const { return *p_workData_;}
    inline Reducer* const& p_reducer() const { return p_reducer_;}
    inline Regressor* const& p_regressor() const { return p_regressor_;}
    inline Array* const& p_reduced() const { return p_reduced_;}
    inline Array* const& p_predicted() const { return p_predicted_;}
    inline Array* const& p_residuals() const { return p_residuals_;}
    inline int dim() const { return dim_;}
    inline bool isCentered() const { return isCentered_;}
    inline bool isStandardized() const { return isStandardized_;}
    inline PointX const& mean() const { return mean_;}
    inline PointX const& std() const { return std_;}
    void setDimension( int const& dim);
    void setWorkData( Array& workData);
    void setReducer( Reducer* p_reducer);
    void setRegressor( Regressor* p_regressor);
    void freeReducer();
    void freeRegressor();
    void center();
    void center( VectorX const& weights);
    void standardize();
    void standardize( VectorX const& weights);
    void reductionStep();
    void reductionStep( VectorX const& weights);
    void regressionStep();
    void regressionStep( VectorX const& weights);
 
    void uncenterResults();
    void unstandardizeResults();
 
  protected:
    Regressor* p_regressor_;
    Reducer* p_reducer_;
    Array* p_workData_;
    Array* p_reduced_;
    Array* p_predicted_;
    Array* p_residuals_;
 
  private:
    int dim_;
    PointX mean_;
    PointX std_;
    bool isCentered_;
    bool isStandardized_;
};
 
/* Constructor.
 *  @param p_workData A pointer on the the working data set
 **/
template<class Array>
IAAModel<Array>::IAAModel( Array* p_workData)
                        : p_regressor_(0)
                        , p_reducer_(0)
                        , p_workData_(p_workData)
                        , p_reduced_(0)
                        , p_predicted_(0)
                        , p_residuals_(0)
                        , dim_(0)
                        , mean_()
                        , std_()
                        , isCentered_(false)
                        , isStandardized_(false)
{}
 
template<class Array>
IAAModel<Array>::IAAModel( Array& workData)
                        : p_regressor_(0)
                        , p_reducer_(0)
                        , p_workData_(&workData)
                        , p_reduced_(0)
                        , p_predicted_(0)
                        , p_residuals_(0)
                        , dim_(0)
                        , mean_()
                        , std_()
                        , isCentered_(false)
                        , isStandardized_(false)
{ }
 
/* destructor */
template<class Array>
IAAModel<Array>::~IAAModel()
{}
 
/* set the dimension of the model */
template<class Array>
void IAAModel<Array>::setDimension( const int& dim)
{ dim_ = dim;}
 
/* set the working set with the Data to treat.
 * @param p_reducer a pointer on the reduction dimension method to use
 */
template<class Array>
void IAAModel<Array>::setWorkData( Array& workData)
{
  p_workData_ = &workData;
  isCentered_     = false;
  isStandardized_ = false;
}
/* set the reduction dimension method.
 * @param p_reducer a pointer on the reduction dimension method to use
 */
template<class Array>
void IAAModel<Array>::setReducer( Reducer* p_reducer)
{ p_reducer_ = p_reducer;}
/* set the regression method.
 * @param p_regressor a pointer on the regresssion method to use
 */
template<class Array>
void IAAModel<Array>::setRegressor( Regressor* p_regressor)
{ p_regressor_ = p_regressor;}
 
template<class Array>
void IAAModel<Array>::freeReducer()
{
  if (p_reducer_) delete p_reducer_;
  p_reducer_ = 0;
}
template<class Array>
void IAAModel<Array>::freeRegressor()
{
  if (p_regressor_) delete p_regressor_;
  p_regressor_ = 0;
}
 
/* standardize the local data set */
template<class Array>
void IAAModel<Array>::center()
{
#ifdef STK_AAMODELS_DEBUG
  if (!p_workData_)
    STKRUNTIME_ERROR_NO_ARG(IAAModel<Array>::center,workData is not initialized);
#endif
  // we have to uncenter in case they have been centered with weights
  if (isCentered_)
  {
    Stat::uncenter(*p_workData_, mean_);
    isCentered_ = false;
  }
  Stat::center(*p_workData_, mean_);
  isCentered_ = true;
}
 
/* center the local data set */
template<class Array>
void IAAModel<Array>::center(VectorX const& weights)
{
#ifdef STK_AAMODELS_DEBUG
  if (!p_workData_)
    STKRUNTIME_ERROR_NO_ARG(IAAModel<Array>::center,workData is not initialized);
#endif
  // we have to uncenter in case of this is not the same weights
  if (isCentered_)
  {
    Stat::uncenter(*p_workData_, mean_);
    isCentered_ = false;
  }
  // center
  Stat::center(*p_workData_, weights, mean_);
  isCentered_ = true;
}
 
/* standardize the local data set */
template<class Array>
void IAAModel<Array>::standardize()
{
#ifdef STK_AAMODELS_DEBUG
  if (!p_workData_)
    STKRUNTIME_ERROR_NO_ARG(IAAModel<Array>::standardize,workData is not initialized);
#endif
  // we have to unstandardize in case they have been standardized with weights
  if (isStandardized_)
  {
    Stat::unstandardize(*p_workData_, mean_, std_);
    isStandardized_ = false;
  }
  Stat::standardize(*p_workData_, mean_, std_);
  isStandardized_ = true;
}
 
/* standardize the local data set */
template<class Array>
void IAAModel<Array>::standardize(VectorX const& weights)
{
#ifdef STK_AAMODELS_DEBUG
  if (!p_workData_)
    STKRUNTIME_ERROR_NO_ARG(IAAModel<Array>::standardize,workData is not initialized);
#endif
  // we have to unstandardize in case of this is not the same weights
  if (isStandardized_)
  {
    Stat::unstandardize(*p_workData_, mean_, std_);
    isStandardized_ = false;
  }
  // standardize
  Stat::standardize(*p_workData_, weights, mean_, std_);
  isStandardized_ = true;
}
 
 
/* compute the dimension reduction **/
template<class Array>
void IAAModel<Array>::reductionStep()
{
#ifdef STK_AAMODELS_DEBUG
  if (!p_reducer_)
    STKRUNTIME_ERROR_NO_ARG(IAAModel<Array>::reduction,reducer is not set);
#endif
  // compute axis
  p_reducer_->setDimension(dim_);
  p_reducer_->run();
  // compute matrix multiplication
  p_reduced_= p_reducer_->p_reduced();
}
 
/* compute the weighted dimension reduction **/
template<class Array>
void IAAModel<Array>::reductionStep( VectorX const& weights)
{
#ifdef STK_AAMODELS_DEBUG
  if (!p_reducer_)
    STKRUNTIME_ERROR_NO_ARG(IAAModel<Array>::reduction,reducer is not set);
#endif
  // compute axis
  p_reducer_->setDimension(dim_);
  p_reducer_->run(weights);
  // get the reduced data set
  p_reduced_= p_reducer_->p_reduced();
}
 
/* compute the regression **/
template<class Array>
void IAAModel<Array>::regressionStep()
{
#ifdef STK_AAMODELS_DEBUG
  if (!p_regressor_)
    STKRUNTIME_ERROR_NO_ARG(IAAModel<Array>::regressionStep,regressor is not set);
#endif
  // compute regression
  p_regressor_->run();
  // get results
  p_predicted_ = p_regressor_->p_predicted();
  p_residuals_ = p_regressor_->p_residuals();
}
/* compute the weighted regression **/
template<class Array>
void IAAModel<Array>::regressionStep( VectorX const& weights)
{
#ifdef STK_AAMODELS_DEBUG
  if (!p_regressor_)
    STKRUNTIME_ERROR_NO_ARG(IAAModel<Array>::regressionStep,regressor is not set);
#endif
  p_regressor_->run(weights);
  // get results
  p_predicted_ = p_regressor_->p_predicted();
  p_residuals_ = p_regressor_->p_residuals();
}
 
/* unstandardize the predicted result and residuals */
template<class Array>
void IAAModel<Array>::uncenterResults()
{
#ifdef STK_AAMODELS_DEBUG
  if (!p_predicted_)
    STKRUNTIME_ERROR_NO_ARG(IAAModel<Array>::uncenterResults,predictions are not computed);
#endif
  Stat::uncenter(*p_predicted_, mean_);
}
/* unstandardize the predicted result and residuals */
template<class Array>
void IAAModel<Array>::unstandardizeResults()
{
#ifdef STK_AAMODELS_DEBUG
  if (!p_predicted_)
    STKRUNTIME_ERROR_NO_ARG(IAAModel<Array>::unstandardizeResults,predictions are not computed);
  if (!p_residuals_)
    STKRUNTIME_ERROR_NO_ARG(IAAModel<Array>::unstandardizeResults,residuals are not computed);
#endif
  Stat::unstandardize(*p_predicted_, mean_, std_);
  Stat::unstandardize(*p_residuals_, std_);
}
 
 
} // namespace STK
 
#endif /* STK_IAAMODEL_H */