STK_IAAModel.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004-2010  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:  stkpp::AAModels
 * created on: 23 déc. 2010
 * Purpose: Interface bas class for all AA Models.
 * Author:   iovleff, serge.iovleff@stkpp.org
 *
 **/

#ifndef STK_IAAMODEL_H
#define STK_IAAMODEL_H

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

namespace STK
{

// forward declarations
class IReduct;
template<class X, class Y, class W> class IRegression;

class IAAModel
{
    typedef IRegression<Matrix, Matrix, Vector > Regressor;
  protected:
    IAAModel( Matrix& workData);
    ~IAAModel();

  public:
    inline Matrix const& workData() const { return *p_workData_;}
    inline IReduct* const& p_reductor() const { return p_reductor_;}
    inline Regressor* const& p_regressor() const { return p_regressor_;}
    inline Matrix*  const& p_reduced() const { return p_reduced_;}
    inline Matrix*  const& p_predicted() const { return p_predicted_;}
    inline Matrix* const& p_residuals() const { return p_residuals_;}
    inline Integer const& dim() const { return dim_;}

    inline bool isCentered() const { return isCentered_;}
    inline bool isStandardized() const { return isStandardized_;}

    inline Point const& mean() const { return mean_;}
    inline Point const& std() const { return std_;}
    inline MatrixSquare const& covProjected() const { return covProjected_;}
    inline MatrixSquare const& covResiduals() const { return covResiduals_;}
    inline Real const& varResiduals() const { return varResiduals_;}

    void setDimension( Integer const& dim);
    virtual void setWorkData( Matrix& workData);
    void setReductor( IReduct* p_reductor);
    void setRegressor( Regressor* p_regressor);

    void freeReductor();
    void freeRegressor();

    void center();
    void center( Vector const& weights);
    void standardize();
    void standardize( Vector const& weights);

    void reduction();
    void reduction( Vector const& weights);
    void regression();
    void regression( Vector const& weights);

    void decenterResults();
    void destandardizeResults();
    void computeProjectedCovariance();
    void computeResidualsCovariance();

  protected:
    Regressor* p_regressor_;
    IReduct* p_reductor_;

    Matrix* p_workData_;
    Matrix* p_reduced_;
    Matrix* p_predicted_;
    Matrix* p_residuals_;

  private:
    Integer dim_;
    Point mean_;
    Point std_;
    bool isCentered_;
    bool isStandardized_;
    MatrixSquare covProjected_;
    MatrixSquare covResiduals_;
    Real varResiduals_;
};

}

#endif /* STK_IAAMODEL_H */