gum::LeastSquareTestPolicy< GUM_SCALAR > Class Template Reference

<agrum/tools/multidim/core/testPolicy/leastSquareTestPolicy.h> More...

#include <leastSquareTestPolicy.h>

Inheritance diagram for gum::LeastSquareTestPolicy< GUM_SCALAR >:

Collaboration diagram for gum::LeastSquareTestPolicy< GUM_SCALAR >:

Public Member Functions
Constructor/Destrcutor
	LeastSquareTestPolicy ()
	Constructor. More...
void *	operator new (size_t s)
	Allocators and Deallocators redefinition. More...
void	operator delete (void *p)
	Constructor. More...
virtual	~LeastSquareTestPolicy ()
	Destructor. More...
Observation insertion
void	addObservation (Idx attr, GUM_SCALAR value)
	Comptabilizes the new observation. More...
Test relevance
bool	isTestRelevant () const
	Returns true if enough observation were made so that the test can be relevant. More...
Test result
void	computeScore ()
	Returns the performance of current variable according to the test. More...
double	score ()
	Returns the performance of current variable according to the test. More...
double	secondaryscore () const
	Returns a second criterion to severe ties. More...
Observation methods
Idx	nbObservation () const
	Comptabilizes the new observation. More...
Test methods
virtual void	computeScore () const
	Recomputes the statistic from the beginning. More...
virtual double	score () const =0
	Returns the performance of current variable according to the test. More...
Fusion Methods
void	add (const ITestPolicy< GUM_SCALAR > &src)
Miscelleanous Methods
std::string	toString () const

Protected Member Functions
bool	isModified_ () const

Fusion Methods
double	_sumO_
	Global sum. More...
HashTable< Idx, Idx >	_nbObsTable_
	Nb Observation for each modality assumed by variable. More...
HashTable< Idx, double >	_sumAttrTable_
	Sum for each modality assumed by variable. More...
HashTable< Idx, LinkedList< double > *>	_obsTable_
	Not sure if needed. More...
double	_score_
	Keeping computed score. More...
void	add (const LeastSquareTestPolicy< GUM_SCALAR > &src)
	Performs the merging of current LeastSquareTestPolicy instance with given instance. More...
double	sumValue () const
	Returns global sum (needed for the merging) More...
const HashTable< Idx, Idx > &	nbObsTable () const
	Returns nbobs per modality table (needed for the merging) More...
const HashTable< Idx, double > &	sumAttrTable () const
	Returns sum per modality table (needed for the merging) More...
const HashTable< Idx, LinkedList< double > *> &	obsTable () const
	Returns global sum (needed for the merging) More...

Detailed Description

template<typename GUM_SCALAR>
class gum::LeastSquareTestPolicy< GUM_SCALAR >

<agrum/tools/multidim/core/testPolicy/leastSquareTestPolicy.h>

LeastSquareTestPolicy implements a test policy that follows the Least Square statistic

Definition at line 52 of file leastSquareTestPolicy.h.

Constructor & Destructor Documentation

LeastSquareTestPolicy()

template<typename GUM_SCALAR >

gum::LeastSquareTestPolicy< GUM_SCALAR >::LeastSquareTestPolicy ( )

inline

Constructor.

Definition at line 62 of file leastSquareTestPolicy.h.

                            : ITestPolicy< GUM_SCALAR >(), _sumO_(0.0), _score_(0) {
      GUM_CONSTRUCTOR(LeastSquareTestPolicy);
    }

~LeastSquareTestPolicy()

template<typename GUM_SCALAR >

gum::LeastSquareTestPolicy< GUM_SCALAR >::~LeastSquareTestPolicy ( )

virtual

Destructor.

Definition at line 36 of file leastSquareTestPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                              {
    for (auto obsIter = this->_obsTable_.cbeginSafe(); _obsTable_.cendSafe() != obsIter; ++obsIter)
      delete obsIter.val();

    GUM_DESTRUCTOR(LeastSquareTestPolicy);
  }

Here is the call graph for this function:

Member Function Documentation

add() [1/2]

template<typename GUM_SCALAR >

void gum::LeastSquareTestPolicy< GUM_SCALAR >::add

(

const LeastSquareTestPolicy< GUM_SCALAR > &

src

)

Performs the merging of current LeastSquareTestPolicy instance with given instance.

Definition at line 121 of file leastSquareTestPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                {
    ITestPolicy< GUM_SCALAR >::add(src);

    for (auto obsIter = src.nbObsTable().cbeginSafe(); obsIter != src.nbObsTable().cendSafe();
         ++obsIter)
      if (_nbObsTable_.exists(obsIter.key()))
        _nbObsTable_[obsIter.key()] += obsIter.val();
      else
        _nbObsTable_.insert(obsIter.key(), obsIter.val());

    for (auto attrIter = src.sumAttrTable().cbeginSafe(); attrIter != src.sumAttrTable().cendSafe();
         ++attrIter)
      if (_sumAttrTable_.exists(attrIter.key()))
        _sumAttrTable_[attrIter.key()] += attrIter.val();
      else
        _sumAttrTable_.insert(attrIter.key(), attrIter.val());

    for (auto obsIter = src.obsTable().cbeginSafe(); obsIter != src.obsTable().cendSafe();
         ++obsIter) {
      if (!_obsTable_.exists(obsIter.key()))
        _obsTable_.insert(obsIter.key(), new LinkedList< double >());
      const Link< double >* srcLink = obsIter.val()->list();
      while (srcLink) {
        _obsTable_[obsIter.key()]->addLink(srcLink->element());
        srcLink = srcLink->nextLink();
      }
    }
  }

Here is the call graph for this function:

add() [2/2]

template<typename GUM_SCALAR >

void gum::ITestPolicy< GUM_SCALAR >::add ( const ITestPolicy< GUM_SCALAR > &  src )

inlineinherited

Definition at line 139 of file ITestPolicy.h.

References gum::ITestPolicy< GUM_SCALAR >::_isModified_.

                                                   {
      _isModified_ = true;
      _nbObs_ += src.nbObservation();
    }

addObservation()

template<typename GUM_SCALAR >

void gum::LeastSquareTestPolicy< GUM_SCALAR >::addObservation ( Idx  attr, GUM_SCALAR  value  )

virtual

Comptabilizes the new observation.

Reimplemented from gum::ITestPolicy< GUM_SCALAR >.

Definition at line 52 of file leastSquareTestPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                     {
    ITestPolicy< GUM_SCALAR >::addObservation(attr, value);
    _sumO_ += value;

    if (_sumAttrTable_.exists(attr))
      _sumAttrTable_[attr] += value;
    else
      _sumAttrTable_.insert(attr, value);

    if (_nbObsTable_.exists(attr))
      _nbObsTable_[attr]++;
    else
      _nbObsTable_.insert(attr, 1);

    if (!_obsTable_.exists(attr)) _obsTable_.insert(attr, new LinkedList< double >());
    _obsTable_[attr]->addLink(value);
  }

Here is the call graph for this function:

computeScore() [1/2]

template<typename GUM_SCALAR >

void gum::LeastSquareTestPolicy< GUM_SCALAR >::computeScore

(

)

Returns the performance of current variable according to the test.

Definition at line 79 of file leastSquareTestPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                         {
    ITestPolicy< GUM_SCALAR >::computeScore();
    double mean         = _sumO_ / (double)this->nbObservation();
    double errorO       = 0.0;
    double sumErrorAttr = 0.0;
    for (auto attrIter = _sumAttrTable_.cbeginSafe(); attrIter != _sumAttrTable_.cendSafe();
         ++attrIter) {
      Idx    key       = attrIter.key();
      double meanAttr  = _sumAttrTable_[key] / (double)_nbObsTable_[key];
      double errorAttr = 0.0;

      const Link< double >* linky = _obsTable_[key]->list();
      while (linky) {
        errorAttr += std::pow(linky->element() - meanAttr, 2);
        errorO += std::pow(linky->element() - mean, 2);
        linky = linky->nextLink();
      }

      sumErrorAttr += ((double)_nbObsTable_[key] / (double)this->nbObservation()) * errorAttr;
    }
    _score_ = errorO - sumErrorAttr;
  }

Here is the call graph for this function:

computeScore() [2/2]

template<typename GUM_SCALAR >

virtual void gum::ITestPolicy< GUM_SCALAR >::computeScore ( ) const

inlinevirtualinherited

Recomputes the statistic from the beginning.

Reimplemented in gum::GTestPolicy< GUM_SCALAR >, and gum::Chi2TestPolicy< GUM_SCALAR >.

Definition at line 116 of file ITestPolicy.h.

References gum::ITestPolicy< GUM_SCALAR >::_isModified_.

{ _isModified_ = false; }

isModified_()

template<typename GUM_SCALAR >

bool gum::ITestPolicy< GUM_SCALAR >::isModified_ ( ) const

inlineprotectedinherited

Definition at line 164 of file ITestPolicy.h.

References gum::ITestPolicy< GUM_SCALAR >::_isModified_.

{ return _isModified_; }

isTestRelevant()

template<typename GUM_SCALAR >

bool gum::LeastSquareTestPolicy< GUM_SCALAR >::isTestRelevant ( ) const

inlinevirtual

Returns true if enough observation were made so that the test can be relevant.

Implements gum::ITestPolicy< GUM_SCALAR >.

Definition at line 101 of file leastSquareTestPolicy.h.

{ return (this->nbObservation() > 20); }

nbObservation()

template<typename GUM_SCALAR >

Idx gum::ITestPolicy< GUM_SCALAR >::nbObservation ( ) const

inlineinherited

Comptabilizes the new observation.

Definition at line 97 of file ITestPolicy.h.

{ return _nbObs_; }

nbObsTable()

template<typename GUM_SCALAR >

const HashTable< Idx, Idx >& gum::LeastSquareTestPolicy< GUM_SCALAR >::nbObsTable ( ) const

inline

Returns nbobs per modality table (needed for the merging)

Definition at line 149 of file leastSquareTestPolicy.h.

{ return _nbObsTable_; }

obsTable()

template<typename GUM_SCALAR >

const HashTable< Idx, LinkedList< double >* >& gum::LeastSquareTestPolicy< GUM_SCALAR >::obsTable ( ) const

inline

Returns global sum (needed for the merging)

Definition at line 159 of file leastSquareTestPolicy.h.

{ return _obsTable_; }

operator delete()

template<typename GUM_SCALAR >

void gum::LeastSquareTestPolicy< GUM_SCALAR >::operator delete ( void *  p )

inline

Constructor.

Definition at line 70 of file leastSquareTestPolicy.h.

                                   {
      SmallObjectAllocator::instance().deallocate(p, sizeof(LeastSquareTestPolicy));
    }

operator new()

template<typename GUM_SCALAR >

void* gum::LeastSquareTestPolicy< GUM_SCALAR >::operator new ( size_t  s )

inline

Allocators and Deallocators redefinition.

Definition at line 69 of file leastSquareTestPolicy.h.

{ return SmallObjectAllocator::instance().allocate(s); }

score() [1/2]

template<typename GUM_SCALAR >

double gum::LeastSquareTestPolicy< GUM_SCALAR >::score

(

)

Returns the performance of current variable according to the test.

Definition at line 106 of file leastSquareTestPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                    {
    if (this->isModified_()) computeScore();
    return _score_;
  }

Here is the call graph for this function:

score() [2/2]

template<typename GUM_SCALAR >

virtual double gum::ITestPolicy< GUM_SCALAR >::score ( ) const

pure virtualinherited

Returns the performance of current variable according to the test.

Implemented in gum::GTestPolicy< GUM_SCALAR >, and gum::Chi2TestPolicy< GUM_SCALAR >.

secondaryscore()

template<typename GUM_SCALAR >

double gum::LeastSquareTestPolicy< GUM_SCALAR >::secondaryscore ( ) const

virtual

Returns a second criterion to severe ties.

Implements gum::ITestPolicy< GUM_SCALAR >.

Definition at line 115 of file leastSquareTestPolicy_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                   {
    if (this->isModified_()) computeScore();
    return _score_;
  }

Here is the call graph for this function:

sumAttrTable()

template<typename GUM_SCALAR >

const HashTable< Idx, double >& gum::LeastSquareTestPolicy< GUM_SCALAR >::sumAttrTable ( ) const

inline

Returns sum per modality table (needed for the merging)

Definition at line 154 of file leastSquareTestPolicy.h.

{ return _sumAttrTable_; }

sumValue()

template<typename GUM_SCALAR >

double gum::LeastSquareTestPolicy< GUM_SCALAR >::sumValue ( ) const

inline

Returns global sum (needed for the merging)

Definition at line 144 of file leastSquareTestPolicy.h.

{ return _sumO_; }

toString()

template<typename GUM_SCALAR >

std::string gum::ITestPolicy< GUM_SCALAR >::toString ( ) const

inlineinherited

Definition at line 155 of file ITestPolicy.h.

                               {
      std::stringstream ss;
      ss << "\t\t\tNb Obs : " << _nbObs_ << std::endl;
      return ss.str();
    }

Member Data Documentation

_nbObsTable_

template<typename GUM_SCALAR >

HashTable< Idx, Idx > gum::LeastSquareTestPolicy< GUM_SCALAR >::_nbObsTable_

private

Nb Observation for each modality assumed by variable.

Definition at line 166 of file leastSquareTestPolicy.h.

_obsTable_

template<typename GUM_SCALAR >

HashTable< Idx, LinkedList< double >* > gum::LeastSquareTestPolicy< GUM_SCALAR >::_obsTable_

private

Not sure if needed.

Definition at line 172 of file leastSquareTestPolicy.h.

_score_

template<typename GUM_SCALAR >

double gum::LeastSquareTestPolicy< GUM_SCALAR >::_score_

private

Keeping computed score.

Definition at line 175 of file leastSquareTestPolicy.h.

_sumAttrTable_

template<typename GUM_SCALAR >

HashTable< Idx, double > gum::LeastSquareTestPolicy< GUM_SCALAR >::_sumAttrTable_

private

Sum for each modality assumed by variable.

Definition at line 169 of file leastSquareTestPolicy.h.

_sumO_

template<typename GUM_SCALAR >

double gum::LeastSquareTestPolicy< GUM_SCALAR >::_sumO_

private

Global sum.

Definition at line 163 of file leastSquareTestPolicy.h.

---

The documentation for this class was generated from the following files:

• agrum/FMDP/learning/core/testPolicy/leastSquareTestPolicy.h
• agrum/FMDP/learning/core/testPolicy/leastSquareTestPolicy_tpl.h