MMSD_Cluster.h

Go to the documentation of this file.

#ifndef MMSD_Cluster_H
#define MMSD_Cluster_H


#include "MMSD_Object.h"

#include "MMSD_Law.h"
#include "MMSD_DoubleVector.h"
#include "MMSD_DoubleFullMatrix.h"
#include "STAT_GammaDistribution.h"

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

private:
    // type of initilizatio of the weight
    static const tFlag CONSTANT_WEIGHT_INITIALIZATION;
    static const tFlag GAMMA_WEIGHT_INITIALIZATION;
    static const double EMPTY_LIMIT;
    
    tFlag mWeightInitializationType;
    double mWeightShapeInitialization;
    double mWeightRateInitialization;
    
    // weights of property p in [0,P[ in sample i in [0,N[, size N x P
    MMSD_DoubleFullMatrix mWeights;

    // freedom degree of the properties p in [0,P[ of size P 
    // to store for backup
    MMSD_DoubleVector mFreedomDegrees;
    double mMaxFreedomDegreeValue;


    // true if the cluster is empty
    // depending on mRate
    tBoolean mIsEmpty;
    
    // rate of the cluster
    // store for backup
    double mRate;
    
    //laws of the cluster
    SP::MMSD_Law mLaw;

  
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    MMSD_Cluster(void);
  
  
  
    // DESTRUCTORS 
  
  
    virtual ~MMSD_Cluster(void);   
  
  
  
public:
    //----------------
    // NEW constructors
    // ---------------
    

    // -----------------
    // SET & GET Methods
    // -----------------
public:

    inline void setWeightInitializationType(const tString& type,
                                            const double& shape,
                                            const double& rate) {

        tString t=CORE_String::toLower(type);
        if (t.compare("gamma")==0) {
            setWeightInitializationType(GAMMA_WEIGHT_INITIALIZATION,
                                        shape,rate);
        } else {
            setWeightInitializationType(CONSTANT_WEIGHT_INITIALIZATION,
                                        shape,rate);
        }
    }
    
    inline void setWeightInitializationType(const tFlag& t,
                                            const double& shape,
                                            const double& rate) {
        mWeightInitializationType=t;
        mWeightShapeInitialization=shape;
        mWeightRateInitialization=rate;
       
    }
    inline void setWeightInitializationType(const tFlag& t) {
        setWeightInitializationType(t,1.,1.);
    }
    
    inline void setMaxFreedomDegreeValue(const double& v)  {
        mMaxFreedomDegreeValue=v;
    }
    inline double getMaxFreedomDegreeValue() const {
        return mMaxFreedomDegreeValue;
    }
    
    inline double getRate() const {
        return mRate;
    }
   
    inline const MMSD_DoubleFullMatrix& getWeights() const {
        return mWeights;
    };
    
    inline const MMSD_DoubleVector& getFreedomDegrees() const {
        return mFreedomDegrees;
    };
  
    
    inline void setLaw(SP::MMSD_Law law) {
        mLaw=law;
    }
    inline const MMSD_Law* getLaw() const {
        return mLaw.get();
    };


    inline tBoolean isEmpty() const {
        return mIsEmpty;
    }
    
    virtual void restore(const MMSD_DoubleFullMatrix& properties);
    
    virtual void initialize(const int& clusterIndex,
                            const MMSD_IntegerVector& clusterIndexSamples,
                            const MMSD_DoubleFullMatrix& properties);
    

    void updateRate(const MMSD_DoubleVector& clusterProbabilitiesSamples);
    

    void updateWeights(const MMSD_DoubleVector& probs) {
        updateWeights(mLaw->getPropertiesMatrixMultByCovarianceDecompositionMatrix(),
                      mLaw->getCovarianceDecompositionMatrix(),
                      mLaw->getCovarianceDecompositionDiagonal(),
                      mLaw->getMean(),
                      mFreedomDegrees,
                      probs,
                      mWeights);
    }

    void updateLaw(const MMSD_DoubleFullMatrix& properties,const MMSD_DoubleVector& probs) {
        mLaw->optimizeParameters(mWeights,probs,properties);
    }
    
    void updateFreedomDegrees(const MMSD_DoubleVector& probs) {
        updateFreedomDegrees(mWeights,probs,mMaxFreedomDegreeValue,
                             mFreedomDegrees);
    }
    

    inline void sort() {
        mLaw->sort(mFreedomDegrees);
    };
    
    void computeMultivariateDensity(double* Pk) const {
        computeMultivariateDensity(mLaw->getPropertiesMatrixMultByCovarianceDecompositionMatrix(),
                                   mLaw->getCovarianceDecompositionMatrix(),
                                   mLaw->getCovarianceDecompositionDiagonal(),
                                   mLaw->getMean(),
                                   mFreedomDegrees,
                                   Pk);
                                   
    };
    void computeMultivariateDensity(MMSD_DoubleVector& Pk) const {
        Pk.setSize(mLaw->getPropertiesMatrixMultByCovarianceDecompositionMatrix().getRowsNumber());
        
        computeMultivariateDensity(mLaw->getPropertiesMatrixMultByCovarianceDecompositionMatrix(),
                                   mLaw->getCovarianceDecompositionMatrix(),
                                   mLaw->getCovarianceDecompositionDiagonal(),
                                   mLaw->getMean(),
                                   mFreedomDegrees,
                                   Pk.getValues());
                                   
    };
   
    
protected:
    virtual void computeMultivariateDensity(const MMSD_DoubleFullMatrix& YP, //size N x P
                                            const MMSD_DoubleFullMatrix& P, // size P x P
                                            const MMSD_DoubleVector& D, // size P
                                            const MMSD_DoubleVector& mean, // size P
                                            const MMSD_DoubleVector& nu, // size P
                                            double* Pk) const=0;
    
    virtual void updateWeights(const MMSD_DoubleFullMatrix& YP, // N x P
                               const MMSD_DoubleFullMatrix& P, // P x P
                               const MMSD_DoubleVector& D, // P
                               const MMSD_DoubleVector& mean, // P 
                               const MMSD_DoubleVector& nu, // P
                               const MMSD_DoubleVector& probs, // N
                               MMSD_DoubleFullMatrix& W) const=0;

    virtual void updateFreedomDegrees(const MMSD_DoubleFullMatrix& W,
                                      const MMSD_DoubleVector& probs,
                                      const double& maxFD,
                                      MMSD_DoubleVector& nus)=0;
      
    // ------------------------------
    // SAVER & LOADER for UI class
    // ------------------------------
    virtual void saveToUIClass(UI_Class& mclass) const;

    virtual void loadFromUIClass(const UI_Class& mclass);
    
    // ----------------------
    // String representation
    // ----------------------
public:
    virtual tString toString() const {
        tString ret=MMSD_Object::toString();
        return ret;
    };
    
    
};

#endif