MMSD_Law.h

Go to the documentation of this file.

#ifndef MMSD_Law_H
#define MMSD_Law_H


#include "MMSD_Object.h"

#include "MMSD_DataSet.h"
#include "MMSD_DoubleVector.h"
#include "MMSD_DoubleFullMatrix.h"

DEFINE_SPTR(MMSD_Law);
DEFINE_SVPTR(MMSD_Law);
class MMSD_Law : public virtual MMSD_Object {
    SP_OBJECT(MMSD_Law);
    // ATTRIBUTES
  
private:

    double mMinEigenValue;
    
    // mean vector of size P
    // store for backup
    MMSD_DoubleVector mMean;
    
    // covariance symmetric matrix of size P x P = tP . D . P
    // store for backup
    MMSD_DoubleFullMatrix mP;
    // store for backup
    MMSD_DoubleVector mD; 

    MMSD_DoubleFullMatrix mYP; // Y.mP size N x P
  
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    MMSD_Law(void);
  
  
  
    // DESTRUCTORS 
  
  
    virtual ~MMSD_Law(void);   
  
  
  
public:
    //----------------
    // NEW constructors
    // ---------------
    

    // -----------------
    // SET & GET Methods
    // -----------------
    inline const MMSD_DoubleFullMatrix& getPropertiesMatrixMultByCovarianceDecompositionMatrix() const {
        return mYP;
    };
    inline const MMSD_DoubleFullMatrix& getCovarianceDecompositionMatrix() const {
        return mP;
    };
    inline const MMSD_DoubleVector& getCovarianceDecompositionDiagonal() const {
        return mD;
    };
    inline const MMSD_DoubleVector& getMean() const {
        return mMean;
    };


    inline void setMinEigenValue(const double& v) {
        mMinEigenValue=v;
    }
    inline double getMinEigenValue() const {
        return mMinEigenValue;
    }

    virtual tBoolean isOutOfBounds() const;
    
    // computations methods
    // --------------------
    
    virtual void restore(const MMSD_DoubleFullMatrix& properties);
    
    virtual void initialize(const int& clusterIndex,
                            const int& samplesNumber,
                            const MMSD_IntegerVector& clustersIndex,
                            const MMSD_DoubleFullMatrix& properties);

    
    virtual void optimizeParameters(const MMSD_DoubleFullMatrix& weights,
                                    const MMSD_DoubleVector& probs,
                                    const MMSD_DoubleFullMatrix& Y) {
          // update mMean
        updateMean(mP,mYP,weights,probs,
                   mMean);
        // update mD
        updateCovarianceDecompositionDiagonal(mP,mYP,mMean,weights,probs,
                                              mD);
        // update mP
        updateCovarianceDecompositionMatrix(Y,mD,mMean,weights,probs,
                                            mP,mYP);
        
    
    }

    void sort(MMSD_DoubleVector& nus);
    
protected:
    virtual void updateMean(const MMSD_DoubleFullMatrix& P,
                            const MMSD_DoubleFullMatrix& YP,
                            const MMSD_DoubleFullMatrix& W,
                            const MMSD_DoubleVector& probs,
                            MMSD_DoubleVector& mean)=0;
    virtual void updateCovarianceDecompositionMatrix(const MMSD_DoubleFullMatrix& Y,
                                                     const MMSD_DoubleVector& Diag,
                                                     const MMSD_DoubleVector& mean,
                                                     const MMSD_DoubleFullMatrix& W,
                                                     const MMSD_DoubleVector& probs,
                                                     MMSD_DoubleFullMatrix& P,
                                                     MMSD_DoubleFullMatrix& YP)=0;
    virtual void updateCovarianceDecompositionDiagonal(const MMSD_DoubleFullMatrix& P, // PxP
                                                       const MMSD_DoubleFullMatrix& YP, // PxP
                                                       const MMSD_DoubleVector& mean, // P
                                                       const MMSD_DoubleFullMatrix& W, // NxP
                                                       const MMSD_DoubleVector& probs, // N
                                                       MMSD_DoubleVector& D)=0;
    
   
      
    // ------------------------------
    // SAVER & LOADER for UI class
    // ------------------------------
    virtual void saveToUIClass(UI_Class& mclass) const;

    virtual void loadFromUIClass(const UI_Class& mclass);
    
    // ----------------------
    // String representation
    // ----------------------

    virtual tString toString() const {
        tString ret=MMSD_Object::toString();
        return ret;
    }

private:
    // sort methods
    void swapValues(MMSD_DoubleVector& nus,
                    const int& i,const int&j);
   
    /* sort nus & law parameters in indices [from,to]
     */
    void quickSort(MMSD_DoubleVector& nus,
                   const int& from,const int& to);
};

#endif