<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.
	~ContingencyTable ()
	Default destructor.
void *	operator new (size_t s)
	Allocators and Deallocators redefinition.
void	operator delete (void *p)
	Default constructor.

void	add (GUM_SCALAR_A valueA, GUM_SCALAR_B valueB)
	Increments the number of sample for case( iattr, ivalue ).
Idx	joint (GUM_SCALAR_A valueA, GUM_SCALAR_B valueB) const
	Returns the number of samples for case (iattr, ivalue).
Idx	attrAMarginal (GUM_SCALAR_A valueA) const
	Returns the number of samples for case (iattr, ivalue).
Idx	attrBMarginal (GUM_SCALAR_B valueB) const
	Returns the number of samples for case (iattr, ivalue).
HashTableConstIteratorSafe< GUM_SCALAR_A, Idx >	attrABeginSafe () const
	Returns the number of samples for line iattr.
HashTableConstIteratorSafe< GUM_SCALAR_A, Idx >	attrAEndSafe () const
	Increments the number of sample for case( iattr, ivalue ).
HashTableConstIteratorSafe< GUM_SCALAR_B, Idx >	attrBBeginSafe () const
	Returns the number of samples for column ivalue.
HashTableConstIteratorSafe< GUM_SCALAR_B, Idx >	attrBEndSafe () const
	Increments the number of sample for case( iattr, ivalue ).
Idx	attrASize () const
	Returns the number of samples for line iattr.
Idx	attrBSize () const
	Returns the number of samples for column ivalue.

Private Attributes
HashTable< std::pair< GUM_SCALAR_A, GUM_SCALAR_B >, Idx >	_jointTable_
	The contingency table used to compute the GStat Left Idx is for the attribute Right Idx for the value.
HashTable< GUM_SCALAR_A, Idx >	_attrAMarginalTable_
HashTable< GUM_SCALAR_B, Idx >	_attrBMarginalTable_

Detailed Description

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

Definition at line 71 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 65 of file contingencyTable_tpl.h.

                                                                   {
    GUM_CONSTRUCTOR(ContingencyTable);
  }

References ContingencyTable().

Referenced by ContingencyTable(), ~ContingencyTable(), operator delete(), and operator+=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~ContingencyTable()

template<typename GUM_SCALAR_A, typename GUM_SCALAR_B>

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

Default destructor.

Definition at line 73 of file contingencyTable_tpl.h.

                                                                    {
    GUM_DESTRUCTOR(ContingencyTable);
  }

References ContingencyTable().

Here is the call graph for this function:

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 85 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 133 of file contingencyTable.h.

                                                                           {
      return _attrAMarginalTable_.cbeginSafe();
    }

References _attrAMarginalTable_.

Referenced by operator+=().

Here is the caller graph for this function:

◆ 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 137 of file contingencyTable.h.

                                                                         {
      return _attrAMarginalTable_.cendSafe();
    }

References _attrAMarginalTable_.

Referenced by operator+=().

Here is the caller graph for this function:

◆ 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 119 of file contingencyTable.h.

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

References _attrAMarginalTable_.

◆ 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 155 of file contingencyTable.h.

155{ return _attrAMarginalTable_.size(); }

References _attrAMarginalTable_.

◆ 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 145 of file contingencyTable.h.

                                                                           {
      return _attrBMarginalTable_.cbeginSafe();
    }

References _attrBMarginalTable_.

◆ 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 149 of file contingencyTable.h.

                                                                         {
      return _attrBMarginalTable_.cendSafe();
    }

References _attrBMarginalTable_.

◆ 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 125 of file contingencyTable.h.

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

References _attrAMarginalTable_.

◆ 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 159 of file contingencyTable.h.

159{ return _attrBMarginalTable_.size(); }

References _attrBMarginalTable_.

◆ 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 111 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;
    }

References _jointTable_.

Referenced by gum::ContingencyTable< Idx, GUM_SCALAR >::add().

Here is the caller graph for this function:

◆ 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 93 of file contingencyTable.h.

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

References ContingencyTable(), gum::SmallObjectAllocator::deallocate(), and gum::SmallObjectAllocator::instance().

Here is the call graph for this function:

◆ 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 91 of file contingencyTable.h.

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

gum::SmallObjectAllocator::allocate

void * allocate(const size_t &objectSize)

Allocates a block.

Definition smallObjectAllocator_inl.h:108

References gum::SmallObjectAllocator::allocate(), and gum::SmallObjectAllocator::instance().

Here is the call graph for this function:

◆ 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 101 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;
  }

References ContingencyTable(), _attrAMarginalTable_, attrABeginSafe(), and attrAEndSafe().

Here is the call graph for this function:

◆ 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 166 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();
    }

References _attrAMarginalTable_, _attrBMarginalTable_, and _jointTable_.

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 185 of file contingencyTable.h.

Referenced by attrABeginSafe(), attrAEndSafe(), attrAMarginal(), attrASize(), attrBMarginal(), operator+=(), and toString().

◆ _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 186 of file contingencyTable.h.

Referenced by attrBBeginSafe(), attrBEndSafe(), attrBSize(), and toString().

◆ _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 184 of file contingencyTable.h.

Referenced by joint(), and toString().

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

Private Attributes

Detailed Description

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_