facade design pattern. More...

#include <STK_MixtureFacade.h>

Inheritance diagram for STK::StrategyFacade:

Public Member Functions
	StrategyFacade (IMixtureComposer *&p_model)
	constructor.

virtual	~StrategyFacade ()
	destructor.

void	setModel (IMixtureComposer *&p_model)
	set model in case we want to use the strategy again

void	createSimpleStrategy (Clust::initType init, int nbTrialInInit, Clust::algoType initAlgo, int nbInitIter, Real initEpsilon, int nbTry, Clust::algoType algo, int nbIter, Real epsilon)
	create a SimpleStrategy

void	createFullStrategy (Clust::initType init, int nbTryInInit, Clust::algoType initAlgo, int nbInitIter, Real initEpsilon, int nbTry, int nbInitRun, int nbShortRun, Clust::algoType shortAlgo, int nbShortIter, Real shortEpsilon, Clust::algoType longAlgo, int nblongIter, Real longEpsilon)
	create a FullStrategy

virtual bool	run ()
	run the strategy

Public Member Functions inherited from STK::IRunnerBase
String const &	error () const
	get the last error message.

Protected Attributes
IMixtureComposer *&	p_model_
	the mixture model to estimate

IMixtureStrategy *	p_strategy_
	the strategy to use in order to estimate the mixture model

Protected Attributes inherited from STK::IRunnerBase
String	msg_error_
	String with the last error message.

bool	hasRun_
	`true` if run has been used, `false` otherwise

Additional Inherited Members
Protected Member Functions inherited from STK::IRunnerBase
	IRunnerBase ()
	default constructor

	IRunnerBase (IRunnerBase const &runner)
	copy constructor

virtual	~IRunnerBase ()
	destructor

virtual void	update ()
	update the runner.

Detailed Description

facade design pattern.

StrategyFacade allows to create the strategy for estimating a mixture model with less effort

Definition at line 56 of file STK_MixtureFacade.h.

Constructor & Destructor Documentation

◆ StrategyFacade()

STK::StrategyFacade::StrategyFacade ( IMixtureComposer *& p_model )

inline

constructor.

Parameters

p_model a reference on the current model

Definition at line 62 of file STK_MixtureFacade.h.

63 : IRunnerBase(), p_model_(p_model), p_strategy_(0)

64 {}

STK::IRunnerBase::IRunnerBase

IRunnerBase()

default constructor

Definition STK_IRunner.h:68

STK::StrategyFacade::p_model_

IMixtureComposer *& p_model_

the mixture model to estimate

Definition STK_MixtureFacade.h:85

STK::StrategyFacade::p_strategy_

IMixtureStrategy * p_strategy_

the strategy to use in order to estimate the mixture model

Definition STK_MixtureFacade.h:87

◆ ~StrategyFacade()

STK::StrategyFacade::~StrategyFacade ( )

virtual

destructor.

Definition at line 46 of file STK_MixtureFacade.cpp.

46{ if (p_strategy_) delete p_strategy_;}

References p_strategy_.

Member Function Documentation

◆ createFullStrategy()

void STK::StrategyFacade::createFullStrategy	(	Clust::initType	init,
		int	nbTryInInit,
		Clust::algoType	initAlgo,
		int	nbInitIter,
		Real	initEpsilon,
		int	nbTry,
		int	nbInitRun,
		int	nbShortRun,
		Clust::algoType	shortAlgo,
		int	nbShortIter,
		Real	shortEpsilon,
		Clust::algoType	longAlgo,
		int	nblongIter,
		Real	longEpsilon
	)

create a FullStrategy

Definition at line 58 of file STK_MixtureFacade.cpp.

{
  IMixtureInit* p_init = Clust::createInit(init, nbTryInInit, initAlgo, nbInitIter, initEpsilon);
  IMixtureAlgo* p_shortAlgo = Clust::createAlgo(shortAlgo, nbShortIter, shortEpsilon);
  IMixtureAlgo* p_longAlgo = Clust::createAlgo(longAlgo, nblongIter, longEpsilon);
 
  p_strategy_ = Clust::createFullStrategy(p_model_, nbTry, nbInitRun, p_init, nbShortRun, p_shortAlgo, p_longAlgo);
}

References STK::Clust::createAlgo(), STK::Clust::createFullStrategy(), STK::Clust::createInit(), p_model_, and p_strategy_.

◆ createSimpleStrategy()

void STK::StrategyFacade::createSimpleStrategy	(	Clust::initType	init,
		int	nbTrialInInit,
		Clust::algoType	initAlgo,
		int	nbInitIter,
		Real	initEpsilon,
		int	nbTry,
		Clust::algoType	algo,
		int	nbIter,
		Real	epsilon
	)

create a SimpleStrategy

Definition at line 48 of file STK_MixtureFacade.cpp.

{
  IMixtureInit* p_init = Clust::createInit(init, nbTryInInit, initAlgo, nbInitIter, initEpsilon);
  IMixtureAlgo* p_algo = Clust::createAlgo(algo, nbIter, epsilon);
 
  p_strategy_ = Clust::createSimpleStrategy(p_model_, nbTry, p_init, p_algo);
}

References STK::Clust::createAlgo(), STK::Clust::createInit(), STK::Clust::createSimpleStrategy(), p_model_, and p_strategy_.

◆ run()

bool STK::StrategyFacade::run ( )

virtual

run the strategy

Implements STK::IRunnerBase.

Definition at line 70 of file STK_MixtureFacade.cpp.

{
#ifdef STK_MIXTURE_VERBOSE
  stk_cout << _T("------------------------------\n")
           << _T("Entering StrategyFacade::run()\n");
#endif
  bool flag = false;
  if (p_strategy_)
  {
    if (p_strategy_->run()) { flag = true;}
    else
    {
      msg_error_ += STKERROR_NO_ARG(StrategyFacade::run,strategy failed\n);
      msg_error_ += p_strategy_->error();
#ifdef STK_MIXTURE_VERBOSE
      stk_cout << _T("StrategyFacade:run() terminated without success.\n")
               << msg_error_ << _T("\n")
               << _T("------------------------------------------------\n");
#endif
    }
    // p_model_->imputationStep();
    p_model_->finalizeStep();
  }
  else
  { msg_error_ = STKERROR_NO_ARG(MixtureFacade::run(),strategy is not created);}
#ifdef STK_MIXTURE_VERBOSE
  stk_cout << _T("StrategyFacade:run() terminated.\np_model->lnLikelihood() =")
           << p_model_->lnLikelihood() << _T("\n")
           << _T("--------------------------------\n");
#endif
  return flag;
}

References _T, STK::IRunnerBase::error(), STK::IMixtureComposer::finalizeStep(), STK::IStatModelBase::lnLikelihood(), STK::IRunnerBase::msg_error_, p_model_, p_strategy_, run(), STK::IRunnerBase::run(), stk_cout, and STKERROR_NO_ARG.

Referenced by run(), and STK::LearnFacade::run().

◆ setModel()

void STK::StrategyFacade::setModel ( IMixtureComposer *& p_model )

inline

set model in case we want to use the strategy again

Parameters

p_model the model to set

Definition at line 70 of file STK_MixtureFacade.h.

70{p_model_ = p_model;};

References p_model_.

Member Data Documentation

◆ p_model_

IMixtureComposer*& STK::StrategyFacade::p_model_

protected

the mixture model to estimate

Definition at line 85 of file STK_MixtureFacade.h.

Referenced by createFullStrategy(), createSimpleStrategy(), run(), and setModel().

◆ p_strategy_

IMixtureStrategy* STK::StrategyFacade::p_strategy_