<agrum/FMDP/learning/core/contingencyTable.h> More...

#include <contingencyTable.h>

Collaboration diagram for gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >:

Public Member Functions
ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B > &	operator+= (const ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B > &src)

std::string	toString () const

Constructor & destructor.
	ContingencyTable ()
	Default constructor. More...

	~ContingencyTable ()
	Default destructor. More...

void *	operator new (size_t s)
	Allocators and Deallocators redefinition. More...

void	operator delete (void *p)
	Default constructor. More...


void	add (GUM_SCALAR_A valueA, GUM_SCALAR_B valueB)
	Increments the number of sample for case( iattr, ivalue ) More...

Idx	joint (GUM_SCALAR_A valueA, GUM_SCALAR_B valueB) const
	Returns the number of samples for case (iattr, ivalue) More...

Idx	attrAMarginal (GUM_SCALAR_A valueA) const
	Returns the number of samples for case (iattr, ivalue) More...

Idx	attrBMarginal (GUM_SCALAR_B valueB) const
	Returns the number of samples for case (iattr, ivalue) More...

HashTableConstIteratorSafe< GUM_SCALAR_A, Idx >	attrABeginSafe () const
	Returns the number of samples for line iattr. More...

HashTableConstIteratorSafe< GUM_SCALAR_A, Idx >	attrAEndSafe () const
	Increments the number of sample for case( iattr, ivalue ) More...

HashTableConstIteratorSafe< GUM_SCALAR_B, Idx >	attrBBeginSafe () const
	Returns the number of samples for column ivalue. More...

HashTableConstIteratorSafe< GUM_SCALAR_B, Idx >	attrBEndSafe () const
	Increments the number of sample for case( iattr, ivalue ) More...

Idx	attrASize () const
	Returns the number of samples for line iattr. More...

Idx	attrBSize () const
	Returns the number of samples for column ivalue. More...

Detailed Description

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>
class gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >

Definition at line 57 of file contingencyTable.h.

Constructor & Destructor Documentation

◆ ContingencyTable()

template<typename GUM_SCALAR_A , typename GUM_SCALAR_B >

gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >::ContingencyTable ( )

Default constructor.

Definition at line 43 of file contingencyTable_tpl.h.

                                                                    {
     GUM_CONSTRUCTOR(ContingencyTable);
   }

◆ ~ContingencyTable()

template<typename GUM_SCALAR_A , typename GUM_SCALAR_B >

gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >::~ContingencyTable ( )

Default destructor.

Definition at line 52 of file contingencyTable_tpl.h.

                                                                     {
     GUM_DESTRUCTOR(ContingencyTable);
   }

Member Function Documentation

◆ add()

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>

void gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >::add	(	GUM_SCALAR_A	valueA,
		GUM_SCALAR_B	valueB
	)

Increments the number of sample for case( iattr, ivalue )

Definition at line 65 of file contingencyTable_tpl.h.

                                                                                 {
     // Updating
     if (_attrAMarginalTable_.exists(valueA))
       _attrAMarginalTable_[valueA]++;
     else
       _attrAMarginalTable_.insert(valueA, 1);
 
     if (_attrBMarginalTable_.exists(valueB))
       _attrBMarginalTable_[valueB]++;
     else
       _attrBMarginalTable_.insert(valueB, 1);
 
     std::pair< GUM_SCALAR_A, GUM_SCALAR_B > cell(valueA, valueB);
     if (_jointTable_.exists(cell))
       _jointTable_[cell]++;
     else
       _jointTable_.insert(cell, 1);
   }

◆ attrABeginSafe()

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>

HashTableConstIteratorSafe< GUM_SCALAR_A, Idx > gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >::attrABeginSafe ( ) const

inline

Returns the number of samples for line iattr.

Definition at line 122 of file contingencyTable.h.

                                                                            {
       return _attrAMarginalTable_.cbeginSafe();
     }

◆ attrAEndSafe()

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>

HashTableConstIteratorSafe< GUM_SCALAR_A, Idx > gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >::attrAEndSafe ( ) const

inline

Increments the number of sample for case( iattr, ivalue )

Definition at line 125 of file contingencyTable.h.

                                                                          {
       return _attrAMarginalTable_.cendSafe();
     }

◆ attrAMarginal()

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>

Idx gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >::attrAMarginal ( GUM_SCALAR_A valueA ) const

inline

Returns the number of samples for case (iattr, ivalue)

Definition at line 106 of file contingencyTable.h.

                                                  {
       return _attrAMarginalTable_.exists(valueA) ? _attrAMarginalTable_[valueA] : 0;
     }

◆ attrASize()

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>

Idx gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >::attrASize ( ) const

inline

Returns the number of samples for line iattr.

Definition at line 144 of file contingencyTable.h.

144 { return _attrAMarginalTable_.size(); }

gum::HashTable::size

Size size() const noexcept

Returns the number of elements stored into the hashtable.

Definition: hashTable_tpl.h:705

gum::ContingencyTable::_attrAMarginalTable_

HashTable< GUM_SCALAR_A, Idx > _attrAMarginalTable_

Definition: contingencyTable.h:175

◆ attrBBeginSafe()

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>

HashTableConstIteratorSafe< GUM_SCALAR_B, Idx > gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >::attrBBeginSafe ( ) const

inline

Returns the number of samples for column ivalue.

Definition at line 134 of file contingencyTable.h.

                                                                            {
       return _attrBMarginalTable_.cbeginSafe();
     }

◆ attrBEndSafe()

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>

HashTableConstIteratorSafe< GUM_SCALAR_B, Idx > gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >::attrBEndSafe ( ) const

inline

Increments the number of sample for case( iattr, ivalue )

Definition at line 137 of file contingencyTable.h.

                                                                          {
       return _attrBMarginalTable_.cendSafe();
     }

◆ attrBMarginal()

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>

Idx gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >::attrBMarginal ( GUM_SCALAR_B valueB ) const

inline

Returns the number of samples for case (iattr, ivalue)

Definition at line 113 of file contingencyTable.h.

                                                  {
       return _attrAMarginalTable_.exists(valueB) ? _attrAMarginalTable_[valueB] : 0;
     }

◆ attrBSize()

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>

Idx gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >::attrBSize ( ) const

inline

Returns the number of samples for column ivalue.

Definition at line 149 of file contingencyTable.h.

149 { return _attrBMarginalTable_.size(); }

gum::ContingencyTable::_attrBMarginalTable_

HashTable< GUM_SCALAR_B, Idx > _attrBMarginalTable_

Definition: contingencyTable.h:176

gum::HashTable::size

Size size() const noexcept

Returns the number of elements stored into the hashtable.

Definition: hashTable_tpl.h:705

◆ joint()

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>

Idx gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >::joint	(	GUM_SCALAR_A	valueA,
		GUM_SCALAR_B	valueB
	)		const

inline

Returns the number of samples for case (iattr, ivalue)

Definition at line 97 of file contingencyTable.h.

                                                               {
       return _jointTable_.exists(std::pair< GUM_SCALAR_A, GUM_SCALAR_B >(valueA, valueB))
               ? _jointTable_[std::pair< GUM_SCALAR_A, GUM_SCALAR_B >(valueA, valueB)]
               : 0;
     }

◆ operator delete()

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>

void gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >::operator delete ( void * p )

inline

Default constructor.

Definition at line 78 of file contingencyTable.h.

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

◆ operator new()

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>

void* gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >::operator new ( size_t s )

inline

Allocators and Deallocators redefinition.

Definition at line 77 of file contingencyTable.h.

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

gum::SmallObjectAllocator::allocate

void * allocate(const size_t &objectSize)

Allocates a block.

Definition: smallObjectAllocator_inl.h:86

gum::SmallObjectAllocator::instance

static SmallObjectAllocator & instance()

Definition: smallObjectAllocator_inl.h:73

◆ operator+=()

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>

ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B > & gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >::operator+= ( const ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B > & src )

Definition at line 87 of file contingencyTable_tpl.h.

                                                                    {
     // Ajout dans marginal A et table joint des valeurs pour src
     for (auto aTer = src.attrABeginSafe(); aTer != src.attrAEndSafe(); ++aTer) {
       if (_attrAMarginalTable_.exists(aTer.key()))
         _attrAMarginalTable_[aTer.key()] += aTer.val();
       else
         _attrAMarginalTable_.insert(aTer.key(), aTer.val());
 
       for (auto bTer = src.attrBBeginSafe(); bTer != src.attrBEndSafe(); ++bTer) {
         std::pair< GUM_SCALAR_A, GUM_SCALAR_B > cell(aTer.key(), bTer.key());
         if (_jointTable_.exists(cell))
           _jointTable_[cell] += src.joint(aTer.key(), bTer.key());
         else
           _jointTable_.insert(cell, src.joint(aTer.key(), bTer.key()));
       }
     }
 
     // Ajout dans marginal B des valeurs de src
     for (auto bTer = src.attrBBeginSafe(); bTer != src.attrBEndSafe(); ++bTer) {
       if (_attrBMarginalTable_.exists(bTer.key()))
         _attrBMarginalTable_[bTer.key()] += bTer.val();
       else
         _attrBMarginalTable_.insert(bTer.key(), bTer.val());
     }
     return *this;
   }

◆ toString()

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>

std::string gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >::toString ( ) const

inline

Definition at line 156 of file contingencyTable.h.

                                {
       std::stringstream ss;
       ss << "\t\t\t\t" << _attrAMarginalTable_ << std::endl
          << "\t\t\t\t" << _attrBMarginalTable_ << std::endl
          << "\t\t\t\t" << _jointTable_ << std::endl;
       return ss.str();
     }

Member Data Documentation

◆ _attrAMarginalTable_

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>

HashTable< GUM_SCALAR_A, Idx > gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >::_attrAMarginalTable_

private

Definition at line 175 of file contingencyTable.h.

◆ _attrBMarginalTable_

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>

HashTable< GUM_SCALAR_B, Idx > gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >::_attrBMarginalTable_

private

Definition at line 176 of file contingencyTable.h.

◆ _jointTable_

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>

HashTable< std::pair< GUM_SCALAR_A, GUM_SCALAR_B >, Idx > gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >::_jointTable_

private

The contingency table used to compute the GStat Left Idx is for the attribute Right Idx for the value.

NB: This is a silly and in a hurry implementation of contingency table If someone ever use this class and has time to correctly implements a efficient contingency table, you're welcome

Definition at line 174 of file contingencyTable.h.

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

agrum/FMDP/learning/core/contingencyTable.h
agrum/FMDP/learning/core/contingencyTable_tpl.h

Public Member Functions

Detailed Description

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B> class gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >

Constructor & Destructor Documentation

◆ ContingencyTable()

◆ ~ContingencyTable()

Member Function Documentation

◆ add()

◆ attrABeginSafe()

◆ attrAEndSafe()

◆ attrAMarginal()

◆ attrASize()

◆ attrBBeginSafe()

◆ attrBEndSafe()

◆ attrBMarginal()

◆ attrBSize()

◆ joint()

◆ operator delete()

◆ operator new()

◆ operator+=()

◆ toString()

Member Data Documentation

◆ _attrAMarginalTable_

◆ _attrBMarginalTable_

◆ _jointTable_

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>
class gum::ContingencyTable< GUM_SCALAR_A, GUM_SCALAR_B >