gum::LeafPair Class Reference

<agrum/FMDP/learning/datastructure/leaves/leafPair.h> More...

#include <leafPair.h>

Collaboration diagram for gum::LeafPair:

Public Member Functions
AbstractLeaf *	firstLeaf ()
AbstractLeaf *	secondLeaf ()
bool	contains (NodeId testedId)
	Returns true if pair has leaf in it.
AbstractLeaf *	convert2Leaf (NodeId leafId) const
	Returns a leaf matching data and having given id as id.
AbstractLeaf *	otherLeaf (AbstractLeaf *l) const
std::string	toString ()
Constructor & destructor.
	LeafPair (AbstractLeaf *l1, AbstractLeaf *l2)
	Default constructor.
	~LeafPair ()
	Default destructor.
void *	operator new (size_t s)
	Allocators and Deallocators redefinition.
void	operator delete (void *p)
	Default constructor.
Likelyhood Methods
void	updateLikelyhood ()
	Updates GStatistic.
double	likelyhood ()
	Updates GStatistic.

Private Attributes
AbstractLeaf *	_l1_
AbstractLeaf *	_l2_
double	_likelyhood1_
double	_likelyhood2_

Detailed Description

<agrum/FMDP/learning/datastructure/leaves/leafPair.h>

Handles a pair of leaves

Definition at line 69 of file leafPair.h.

Constructor & Destructor Documentation

LeafPair()

INLINE gum::LeafPair::LeafPair	(	AbstractLeaf *	l1,
		AbstractLeaf *	l2 )

Default constructor.

Definition at line 48 of file leafPair_inl.h.

                                                              : _l1_(l1), _l2_(l2) {
    GUM_CONSTRUCTOR(LeafPair);
  }

References LeafPair(), _l1_, and _l2_.

Referenced by LeafPair(), ~LeafPair(), and operator delete().

Here is the call graph for this function:

Here is the caller graph for this function:

~LeafPair()

INLINE gum::LeafPair::~LeafPair

(

)

Default destructor.

Definition at line 52 of file leafPair_inl.h.

                             {
    GUM_DESTRUCTOR(LeafPair);
    ;
  }

References LeafPair().

Here is the call graph for this function:

Member Function Documentation

contains()

INLINE bool gum::LeafPair::contains

(

NodeId

testedId

)

Returns true if pair has leaf in it.

Definition at line 69 of file leafPair_inl.h.

                                                {
    return _l1_->contains(testedId) || _l2_->contains(testedId);
  }

References _l1_, and _l2_.

convert2Leaf()

INLINE AbstractLeaf * gum::LeafPair::convert2Leaf

(

NodeId

leafId

)

const

Returns a leaf matching data and having given id as id.

Definition at line 73 of file leafPair_inl.h.

                                                                 {
    return new ComposedLeaf(leafId, _l1_, _l2_);
  }

References _l1_, and _l2_.

Referenced by gum::LeafAggregator::update().

Here is the caller graph for this function:

firstLeaf()

INLINE AbstractLeaf * gum::LeafPair::firstLeaf

(

)

Definition at line 65 of file leafPair_inl.h.

{ return _l1_; }

References _l1_.

likelyhood()

double gum::LeafPair::likelyhood

(

)

Updates GStatistic.

Definition at line 99 of file leafPair.cpp.

                              {
    //      updateLikelyhood();
    return 1
         - ChiSquare::probaChi2(_likelyhood1_ > _likelyhood2_ ? _likelyhood1_ : _likelyhood2_,
                                (_l1_->nbModa() - 1));
  }

References _l1_, _likelyhood1_, _likelyhood2_, and gum::ChiSquare::probaChi2().

Referenced by gum::LeafAggregator::update(), and gum::FusionContext< isInitial >::updatePair().

Here is the call graph for this function:

Here is the caller graph for this function:

operator delete()

INLINE void gum::LeafPair::operator delete

(

void *

p

)

Default constructor.

Definition at line 61 of file leafPair_inl.h.

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

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

Here is the call graph for this function:

operator new()

INLINE void * gum::LeafPair::operator new

(

size_t

s

)

Allocators and Deallocators redefinition.

Definition at line 57 of file leafPair_inl.h.

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

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

Here is the call graph for this function:

otherLeaf()

INLINE AbstractLeaf * gum::LeafPair::otherLeaf

(

AbstractLeaf *

l

)

const

Definition at line 77 of file leafPair_inl.h.

                                                                {
    return l == _l1_ ? _l2_ : _l1_;
  }

References _l1_, and _l2_.

Referenced by gum::LeafAggregator::~LeafAggregator().

Here is the caller graph for this function:

secondLeaf()

INLINE AbstractLeaf * gum::LeafPair::secondLeaf

(

)

Definition at line 67 of file leafPair_inl.h.

{ return _l2_; }

References _l2_.

toString()

std::string gum::LeafPair::toString

(

)

Definition at line 106 of file leafPair.cpp.

                               {
    //      std::format("~ M={}.L1={}.L2={} ~", moda, _l1_->effectif(moda), _l2_->effectif(moda))
    return std::format("\t[  Leaf1 : {} - Leaf2 : {} - GStat : {} ]",
                       _l1_->toString(),
                       _l2_->toString(),
                       this->likelyhood());
  }

References _l1_, and _l2_.

updateLikelyhood()

void gum::LeafPair::updateLikelyhood

(

)

Updates GStatistic.

Definition at line 68 of file leafPair.cpp.

                                  {
    _likelyhood1_ = 0.0;
    _likelyhood2_ = 0.0;
 
    if (!_l1_->total() || !_l2_->total()) {
      _likelyhood1_ = std::numeric_limits< double >::max();
      _likelyhood2_ = std::numeric_limits< double >::max();
      return;
    }
 
    double scaleFactor1 = _l1_->total() / (_l1_->total() + _l2_->total());
    double scaleFactor2 = _l2_->total() / (_l1_->total() + _l2_->total());
    for (Idx moda = 0; moda < _l1_->nbModa(); ++moda) {
      if (_l1_->effectif(moda)) {
        double add = _l1_->effectif(moda)
                   * std::log(_l1_->effectif(moda)
                              / (scaleFactor1 * (_l1_->effectif(moda) + _l2_->effectif(moda))));
        _likelyhood1_ += add;
      }
      if (_l2_->effectif(moda)) {
        double add = _l2_->effectif(moda)
                   * std::log(_l2_->effectif(moda)
                              / (scaleFactor2 * (_l1_->effectif(moda) + _l2_->effectif(moda))));
        _likelyhood2_ += add;
      }
    }
 
    _likelyhood1_ *= 2;
    _likelyhood2_ *= 2;
  }

References _l1_, _l2_, _likelyhood1_, and _likelyhood2_.

Referenced by gum::LeafAggregator::addLeaf().

Here is the caller graph for this function:

Member Data Documentation

_l1_

AbstractLeaf* gum::LeafPair::_l1_

private

Definition at line 134 of file leafPair.h.

Referenced by LeafPair(), contains(), convert2Leaf(), firstLeaf(), likelyhood(), otherLeaf(), toString(), and updateLikelyhood().

_l2_

AbstractLeaf* gum::LeafPair::_l2_

private

Definition at line 135 of file leafPair.h.

Referenced by LeafPair(), contains(), convert2Leaf(), otherLeaf(), secondLeaf(), toString(), and updateLikelyhood().

_likelyhood1_

double gum::LeafPair::_likelyhood1_

private

Definition at line 137 of file leafPair.h.

Referenced by likelyhood(), and updateLikelyhood().

_likelyhood2_

double gum::LeafPair::_likelyhood2_

private

Definition at line 138 of file leafPair.h.

Referenced by likelyhood(), and updateLikelyhood().

---

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

• agrum/FMDP/learning/datastructure/leaves/leafPair.h
• agrum/FMDP/learning/datastructure/leaves/leafPair.cpp
• agrum/FMDP/learning/datastructure/leaves/leafPair_inl.h