source: trunk/src/PCA.h @ 13

#ifndef GENETICS_PCA_ANALYZER_H
#define GENETICS_PCA_ANALYZER_H

// C++ tools include
/////////////////////
#include "vector.h"
#include "matrix.h"
#include "SVD.h"

// Standard C++ includes
////////////////////////
#include <vector>
#include <iostream>
#include <memory>
#include <cstdlib>


namespace thep_cpp_tools 
{
  /**
     Class performing PCA using SVD.
  */
  
  class PCA
  {
  public:
    /**
       This constructor is only to be used in test-class
    */
    PCA(); 

    /**
       Constructor taking the data-matrix as input. No row-centering
       should have been performed and no products. 
     */
    explicit PCA( const thep_gsl_api::matrix& );

    
    /**
       Will perform PCA according to the following scheme: \n
       1: Rowcenter A  \n
       2: SVD(A)  --> USV' \n
       3: Calculate eigenvalues according to \n 
          \f$ \lambda_{ii} = s_{ii}/N_{rows} \f$ \n
       4: Sort eigenvectors (from matrix V) according to descending eigenvalues \n
    */
    void process();

    
    /** 
       Performes a simple test on performance. Not optimal!
       Returns true if ok otherwise false. 
    */
    bool test();


    /**
       Returns eigenvector \a i
    */
    thep_gsl_api::matrix get_eigenvector( const size_t& i ) const
    {
      return eigenvectors_.row( i );
    }

    /**
       Returns eigenvalues to covariance matrix 
       \f$ C = \frac{1}{N^2}A^TA \f$
    */
    double get_eigenvalue( const size_t& i ) const
    {
      return eigenvalues_[ i ];
    }

    /**
       Returns the explained intensity of component \a K \n
       \f$I = \frac{ \sum^{K}_{i=1} \lambda_i }{ \sum^{N}_{j=1} \lambda_j }\f$ \n
       where \f$N\f$ is the dimension 
    */
    double PCA::get_explained_intensity( const size_t& k );



    /** 
        This function will project data onto the new coordinate-system
  where the axes are the calculated eigenvectors. This means that 
  PCA must have been run before this function can be used! 
  Output is presented as coordinates in the N-dimensional room
  spanned by the eigenvectors.
    */
    thep_gsl_api::matrix projection( const thep_gsl_api::matrix& ) const;

    
  private:
    thep_gsl_api::matrix A_; 
    thep_gsl_api::matrix  eigenvectors_;
    thep_gsl_api::vector  eigenvalues_;
    thep_gsl_api::vector  explained_intensity_;
    thep_gsl_api::vector  meanvalues_;
    bool process_, explained_calc_;
    
    /**
       Private function that will row-center the matrix A,
       that is, A = A - M, where M is a matrix
       with the meanvalues of each row
    */
    void row_center( thep_gsl_api::matrix& A_center );

    /**
       Private function that will calculate the explained 
       intensity
    */
    void calculate_explained_intensity();

    
  }; // class PCA  
  
}

#endif