STK_Clust_Util.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.org (see copyright for ...)
*/
 
/*
 * Project:  stkpp::Clustering
 * created on: 2 sept. 2013
 * Author:   iovleff, serge.iovleff@stkpp.org
 * Originally created by Parmeet Bhatia <b..._DOT_p..._AT_gmail_Dot_com>
 **/
 
#ifndef STK_CLUST_UTIL_H
#define STK_CLUST_UTIL_H
 
#include <STKernel.h>
 
namespace STK
{
 
// forward declaration
class IMixtureAlgo;
class IMixtureAlgoPredict;
class IMixtureAlgoLearn;
class IMixtureInit;
class IMixtureStrategy;
class IMixtureComposer;
class IMixtureCriterion;
 
template <int Id> struct ModelParameters;
 
template <class Array_> struct HDMatrixModelParameters;
 
namespace hidden
{
template<class Derived> struct MixtureBridgeTraits;
template <class Mixture> struct MixtureTraits;
 
template <class Manager> struct MixtureManagerTraits;
 
} // namespace hidden
 
 
namespace Clust
{
 
enum initType
{
  noInit_ = -1,         
  randomInit_ = -2,     
  randomParamInit_ = 0, 
  randomClassInit_ = 1, 
  randomFuzzyInit_ = 2, 
  valueParamInit_ = 3   
};
 
initType stringToInit( String const& type);
 
enum algoType
{
  emAlgo_ = 0,
  cemAlgo_ = 1,
  semAlgo_ = 2,
  semiSemAlgo_ = 3
};
 
 
algoType stringToAlgo( String const& type);
 
enum algoPredictType
{
  emPredictAlgo_,
  semiSEMPredictAlgo_
};
 
algoPredictType stringToPredictAlgo( String const& type);
 
enum algoLearnType
{
  imputeAlgo_,
  simulAlgo_
};
 
algoLearnType stringToLearnAlgo( String const& type);
 
enum strategyType
{
  simpleStrategy_ = 0,
  XemStrategy_    = 1, // not implemented
  SemStrategy_    = 2,
  FullStrategy_   = 3
};
 
enum criterionType
{
  aic_  = 0,
  bic_  = 1,
  icl_  = 2,
  ml_   = 3
};
 
criterionType stringToCriterion( String const& type);
 
enum exceptions
{
  randomInitFail_,
  randomParamInitFail_,
  randomClassInitFail_,
  randomFuzzyInitFail_,
  estimFail_,
  initializeStepFail_,
  mStepFail_,
  eStepFail_,
  mapStepFail_,
  cStepFail_,
  sStepFail_
};
 
String exceptionToString( exceptions const& type);
 
enum modelState
{
  modelCreated_ =0,         
  modelInitialized_ =1,     
  modelParamInitialized_=2, 
  shortRun_,                
  longRun_,                 
  modelFinalized_           
};
 
enum ParsimoniousCovarianceModel
{
  Covariance_EII_ =100,
  Covariance_VII_,
  Covariance_EEI_,
  Covariance_VEI_,
  Covariance_EVI_,
  Covariance_VVI_,
  Covariance_EEE_,
  Covariance_VEE_,
  Covariance_EVE_,
  Covariance_VVE_,
  Covariance_EEV_,
  Covariance_VEV_,
  Covariance_EVV_,
  Covariance_VVV_  // =114
};
enum HDCovarianceModel
{
  HDCovariance_AjkBkQkDk_ =120,
  HDCovariance_AjkBkQkD_,
  HDCovariance_AjkBkQDk_,
  HDCovariance_AjkBkQD_,
  HDCovariance_AjkBQkDk_,
  HDCovariance_AjkBQkD_,
  HDCovariance_AjkBQDk_,
  HDCovariance_AjkBQD_,
  HDCovariance_AkBkQkDk_,
  HDCovariance_AkBkQkD_,
  HDCovariance_AkBkQDk_,
  HDCovariance_AkBkQD_,
  HDCovariance_AkBQkDk_,
  HDCovariance_AkBQkD_,
  HDCovariance_AkBQDk_,
  HDCovariance_AkBQD_,
  HDCovariance_AjBkQkDk_,
  HDCovariance_AjBkQkD_,
  HDCovariance_AjBkQDk_,
  HDCovariance_AjBkQD_,
  HDCovariance_AjBQkDk_,
  HDCovariance_AjBQkD_,
  HDCovariance_AjBQDk_,
  HDCovariance_AjBQD_,
  HDCovariance_ABkQkDk_,
  HDCovariance_ABkQkD_,
  HDCovariance_ABkQDk_,
  HDCovariance_ABkQD_,
  HDCovariance_ABQkDk_,
  HDCovariance_ABQkD_,
  HDCovariance_ABQDk_,
  HDCovariance_ABQD_ // =151
};
 
} // namespace Clust
 
namespace hidden
{
template<int Id> struct HDCovarianceChooser;
 
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AjkBkQkDk_>
{
  const bool isAj_ = true;
  const bool isAk_ = true;
  const bool isBk_ = true;
  const bool isQk_ = true;
  const bool isDk_ = true;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AjkBkQkD_>
{
  const bool isAj_ = true;
  const bool isAk_ = true;
  const bool isBk_ = true;
  const bool isQk_ = true;
  const bool isDk_ = false;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AjkBkQDk_>
{
  const bool isAj_ = true;
  const bool isAk_ = true;
  const bool isBk_ = true;
  const bool isQk_ = false;
  const bool isDk_ = true;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AjkBkQD_>
{
  const bool isAj_ = true;
  const bool isAk_ = true;
  const bool isBk_ = true;
  const bool isQk_ = false;
  const bool isDk_ = false;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AjkBQkDk_>
{
  const bool isAj_ = true;
  const bool isAk_ = true;
  const bool isBk_ = false;
  const bool isQk_ = true;
  const bool isDk_ = true;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AjkBQkD_>
{
  const bool isAj_ = true;
  const bool isAk_ = true;
  const bool isBk_ = false;
  const bool isQk_ = true;
  const bool isDk_ = false;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AjkBQDk_>
{
  const bool isAj_ = true;
  const bool isAk_ = true;
  const bool isBk_ = false;
  const bool isQk_ = false;
  const bool isDk_ = true;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AjkBQD_>
{
  const bool isAj_ = true;
  const bool isAk_ = true;
  const bool isBk_ = false;
  const bool isQk_ = false;
  const bool isDk_ = false;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AkBkQkDk_>
{
  const bool isAj_ = false;
  const bool isAk_ = true;
  const bool isBk_ = true;
  const bool isQk_ = true;
  const bool isDk_ = true;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AkBkQkD_>
{
  const bool isAj_ = false;
  const bool isAk_ = true;
  const bool isBk_ = true;
  const bool isQk_ = true;
  const bool isDk_ = false;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AkBkQDk_>
{
  const bool isAj_ = false;
  const bool isAk_ = true;
  const bool isBk_ = true;
  const bool isQk_ = false;
  const bool isDk_ = true;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AkBkQD_>
{
  const bool isAj_ = false;
  const bool isAk_ = true;
  const bool isBk_ = true;
  const bool isQk_ = false;
  const bool isDk_ = false;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AkBQkDk_>
{
  const bool isAj_ = false;
  const bool isAk_ = true;
  const bool isBk_ = false;
  const bool isQk_ = true;
  const bool isDk_ = true;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AkBQkD_>
{
  const bool isAj_ = false;
  const bool isAk_ = true;
  const bool isBk_ = false;
  const bool isQk_ = true;
  const bool isDk_ = false;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AkBQDk_>
{
  const bool isAj_ = false;
  const bool isAk_ = true;
  const bool isBk_ = false;
  const bool isQk_ = false;
  const bool isDk_ = true;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AkBQD_>
{
  const bool isAj_ = false;
  const bool isAk_ = true;
  const bool isBk_ = false;
  const bool isQk_ = false;
  const bool isDk_ = false;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AjBkQkDk_>
{
  const bool isAj_ = true;
  const bool isAk_ = false;
  const bool isBk_ = true;
  const bool isQk_ = true;
  const bool isDk_ = true;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AjBkQkD_>
{
  const bool isAj_ = true;
  const bool isAk_ = false;
  const bool isBk_ = true;
  const bool isQk_ = true;
  const bool isDk_ = false;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AjBkQDk_>
{
  const bool isAj_ = true;
  const bool isAk_ = false;
  const bool isBk_ = true;
  const bool isQk_ = false;
  const bool isDk_ = true;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AjBkQD_>
{
  const bool isAj_ = true;
  const bool isAk_ = false;
  const bool isBk_ = true;
  const bool isQk_ = false;
  const bool isDk_ = false;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AjBQkDk_>
{
  const bool isAj_ = true;
  const bool isAk_ = false;
  const bool isBk_ = false;
  const bool isQk_ = true;
  const bool isDk_ = true;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_AjBQkD_>
{
  const bool isAj_ = true;
  const bool isAk_ = false;
  const bool isBk_ = false;
  const bool isQk_ = true;
  const bool isDk_ = false;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_ABkQkDk_>
{
  const bool isAj_ = false;
  const bool isAk_ = false;
  const bool isBk_ = true;
  const bool isQk_ = true;
  const bool isDk_ = true;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_ABkQkD_>
{
  const bool isAj_ = false;
  const bool isAk_ = false;
  const bool isBk_ = true;
  const bool isQk_ = true;
  const bool isDk_ = false;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_ABkQDk_>
{
  const bool isAj_ = false;
  const bool isAk_ = false;
  const bool isBk_ = true;
  const bool isQk_ = false;
  const bool isDk_ = true;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_ABkQD_>
{
  const bool isAj_ = false;
  const bool isAk_ = false;
  const bool isBk_ = true;
  const bool isQk_ = false;
  const bool isDk_ = false;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_ABQkDk_>
{
  const bool isAj_ = false;
  const bool isAk_ = false;
  const bool isBk_ = false;
  const bool isQk_ = true;
  const bool isDk_ = true;
};
template<>
struct HDCovarianceChooser<Clust::HDCovariance_ABQkD_>
{
  const bool isAj_ = false;
  const bool isAk_ = false;
  const bool isBk_ = false;
  const bool isQk_ = true;
  const bool isDk_ = false;
};
 
}  // namespace hidden
 
namespace Clust
{
enum Mixture
{
  Gamma_ajk_bjk_ =0,
  Gamma_ajk_bk_,
  Gamma_ajk_bj_,
  Gamma_ajk_b_,
  Gamma_ak_bjk_,
  Gamma_ak_bk_,
  Gamma_ak_bj_,
  Gamma_ak_b_,
  Gamma_aj_bjk_,
  Gamma_aj_bk_,
  Gamma_a_bjk_,
  Gamma_a_bk_, // = 11
  Gaussian_sjk_ =20,
  Gaussian_sk_,
  Gaussian_sj_,
  Gaussian_s_,
  Gaussian_sjsk_, // = 24
  Categorical_pjk_ =40,
  Categorical_pk_,
  Poisson_ljk_ = 60,
  Poisson_lk_,
  Poisson_ljlk_,
  Kmm_sk_ = 80,
  Kmm_s_,
  HDGaussian_AjkBkQkDk_ =120,
  HDGaussian_AjkBkQkD_,
  HDGaussian_AjkBkQDk_,
  HDGaussian_AjkBkQD_,
  HDGaussian_AjkBQkDk_,
  HDGaussian_AjkBQkD_,
  HDGaussian_AjkBQDk_,
  HDGaussian_AjkBQD_,
  HDGaussian_AkBkQkDk_,
  HDGaussian_AkBkQkD_,
  HDGaussian_AkBkQDk_,
  HDGaussian_AkBkQD_,
  HDGaussian_AkBQkDk_,
  HDGaussian_AkBQkD_,
  HDGaussian_AkBQDk_,
  HDGaussian_AkBQD_,
  HDGaussian_AjBkQkDk_,
  HDGaussian_AjBkQkD_,
  HDGaussian_AjBkQDk_,
  HDGaussian_AjBkQD_,
  HDGaussian_AjBQkDk_,
  HDGaussian_AjBQkD_,
  HDGaussian_ABkQkDk_,
  HDGaussian_ABkQkD_,
  HDGaussian_ABkQDk_,
  HDGaussian_ABkQD_,
  HDGaussian_ABQkDk_,
  HDGaussian_ABQkD_,
  HDGaussian_ABQD_,   // =148
  unknown_mixture_ = -1
};
 
enum MixtureClass
{
  Gamma_,
  DiagGaussian_,
  Categorical_,
  Poisson_,
  Kmm_,
  Matrix_,
  HDGaussian_,
  HDMatrixGaussian_,
  unknown_mixture_class_ = -1
};
 
Mixture stringToMixture( String const& type);
 
Mixture stringToMixture( String const& type, bool& freeProp);
 
String mixtureToString( Mixture const& type);
 
String mixtureToString(Mixture type, bool freeProp);
 
MixtureClass mixtureToMixtureClass( Mixture const& type);
 
const int defaultNbTry = 5;
 
const Clust::initType defaultInitType = randomFuzzyInit_;
const int defaultNbInit = 5;
const Clust::algoType defaultAlgoInInit = emAlgo_;
const int defaultNbIterMaxInInit = 20;
const Real defaultEpsilonInInit = 1e-02;
 
const Clust::algoType defaultAlgoShortRun = emAlgo_;
const int defaultMaxIterShortRun = 200;
const Real defaultEpsilonShortRun = 1e-04;
 
const Clust::algoType defaultAlgoLongRun = emAlgo_;
const int defaultMaxIterLongRun = 1000;
const Real defaultEpsilonLongRun = 1e-08;
 
IMixtureCriterion* createCriterion( Clust::criterionType criterion);
 
STK::IMixtureCriterion* createCriterion( String const& criterion);
 
IMixtureAlgo* createAlgo( Clust::algoType algo, int nbIterMax, Real epsilon);
 
IMixtureAlgoLearn* createLearnAlgo(Clust::algoLearnType algo, int nbIterMax, Real epsilon);
 
IMixtureAlgoPredict* createPredictAlgo(Clust::algoPredictType algo, int nbIterBurn, int nbIterLong, Real epsilon);
 
IMixtureInit* createInit( Clust::initType init = defaultInitType
                        , int nbInits          = defaultNbInit
                        , Clust::algoType algo = defaultAlgoInInit
                        , int nbIterMax        = defaultNbIterMaxInInit
                        , Real epsilon         = defaultEpsilonInInit);
inline IMixtureAlgo* createShortRunAlgo( Clust::algoType algo = defaultAlgoShortRun
                                       , int nbIterMax        = defaultMaxIterShortRun
                                       , Real epsilon         = defaultEpsilonShortRun)
{ return createAlgo(algo, nbIterMax, epsilon);}
inline IMixtureAlgo* createLongRunAlgo( Clust::algoType algo = defaultAlgoLongRun
                                      , int nbIterMax        = defaultMaxIterLongRun
                                      , Real epsilon         = defaultEpsilonLongRun)
{ return createAlgo(algo, nbIterMax, epsilon);}
 
IMixtureStrategy* createSimpleStrategy( IMixtureComposer*& p_composer
                                      , int nbTry
                                      , IMixtureInit* const& p_init
                                      , IMixtureAlgo* const& algo);
 
IMixtureStrategy* createFullStrategy( IMixtureComposer*& p_composer
                                    , int nbTry, int nbInitRun
                                    , IMixtureInit* const& p_init
                                    , int nbShortRun, IMixtureAlgo* const& shortRunAlgo
                                    , IMixtureAlgo* const& longRunAlgo);
}  // namespace Clust
 
}  // namespace STK
 
#endif /* STK_CLUST_UTIL_H */