gum::ComposedLeaf Class Reference

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

#include <composedLeaf.h>

Inheritance diagram for gum::ComposedLeaf:

Collaboration diagram for gum::ComposedLeaf:

Public Member Functions
double	effectif (Idx moda) const override
	Gaves the leaf effectif for given modality.
double	total () const override
bool	contains (NodeId testedId) const override
	Returns true if abstractleaf has leaf in it.
Idx	nbModa () const override
std::string	toString () override
NodeId	id ()
Constructor & destructor.
	ComposedLeaf (NodeId leafId, AbstractLeaf *l1, AbstractLeaf *l2)
	Default constructor.
	~ComposedLeaf () override
	Default destructor.
void *	operator new (size_t s)
	Allocators and Deallocators redefinition.
void	operator delete (void *p)
	Default constructor.

Private Attributes
AbstractLeaf *	_l1_
AbstractLeaf *	_l2_
NodeId	_leafId_

Detailed Description

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

A leaf that has leaves inside

Definition at line 68 of file composedLeaf.h.

Constructor & Destructor Documentation

ComposedLeaf()

INLINE gum::ComposedLeaf::ComposedLeaf	(	NodeId	leafId,
		AbstractLeaf *	l1,
		AbstractLeaf *	l2 )

Default constructor.

Definition at line 48 of file composedLeaf_inl.h.

                                                                                     :
      AbstractLeaf(leafId), _l1_(l1), _l2_(l2) {
    GUM_CONSTRUCTOR(ComposedLeaf);
  }

References gum::AbstractLeaf::AbstractLeaf(), ComposedLeaf(), _l1_, and _l2_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

~ComposedLeaf()

INLINE gum::ComposedLeaf::~ComposedLeaf ( )

override

Default destructor.

Definition at line 53 of file composedLeaf_inl.h.

                                     {
    GUM_DESTRUCTOR(ComposedLeaf);
    ;
  }

References ComposedLeaf().

Here is the call graph for this function:

Member Function Documentation

contains()

INLINE bool gum::ComposedLeaf::contains ( NodeId testedId ) const

overridevirtual

Returns true if abstractleaf has leaf in it.

Reimplemented from gum::AbstractLeaf.

Definition at line 72 of file composedLeaf_inl.h.

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

References _l1_, _l2_, and gum::AbstractLeaf::contains().

Here is the call graph for this function:

effectif()

INLINE double gum::ComposedLeaf::effectif ( Idx moda ) const

overridevirtual

Gaves the leaf effectif for given modality.

Implements gum::AbstractLeaf.

Definition at line 66 of file composedLeaf_inl.h.

                                                     {
    return _l1_->effectif(moda) + _l2_->effectif(moda);
  }

References _l1_, and _l2_.

id()

INLINE NodeId gum::AbstractLeaf::id ( )

inherited

Definition at line 67 of file abstractLeaf_inl.h.

{ return _leafId_; }

References _leafId_.

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

Here is the caller graph for this function:

nbModa()

INLINE Idx gum::ComposedLeaf::nbModa ( ) const

overridevirtual

Implements gum::AbstractLeaf.

Definition at line 76 of file composedLeaf_inl.h.

{ return _l1_->nbModa(); }

References _l1_.

operator delete()

INLINE void gum::ComposedLeaf::operator delete

(

void *

p

)

Default constructor.

Definition at line 62 of file composedLeaf_inl.h.

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

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

Here is the call graph for this function:

operator new()

INLINE void * gum::ComposedLeaf::operator new

(

size_t

s

)

Allocators and Deallocators redefinition.

Definition at line 58 of file composedLeaf_inl.h.

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

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

Here is the call graph for this function:

toString()

std::string gum::ComposedLeaf::toString ( )

overridevirtual

Implements gum::AbstractLeaf.

Definition at line 60 of file composedLeaf.cpp.

                                   {
    return std::format("{{ Id : {} - Left : {} - Right : {}}}",
                       this->id(),
                       _l1_->toString(),
                       _l2_->toString());
  }

References _l1_, and _l2_.

total()

INLINE double gum::ComposedLeaf::total ( ) const

overridevirtual

Implements gum::AbstractLeaf.

Definition at line 70 of file composedLeaf_inl.h.

{ return _l1_->total() + _l2_->total(); }

References _l1_, and _l2_.

Member Data Documentation

_l1_

AbstractLeaf* gum::ComposedLeaf::_l1_

private

Definition at line 111 of file composedLeaf.h.

Referenced by ComposedLeaf(), contains(), effectif(), nbModa(), toString(), and total().

_l2_

AbstractLeaf* gum::ComposedLeaf::_l2_

private

Definition at line 112 of file composedLeaf.h.

Referenced by ComposedLeaf(), contains(), effectif(), toString(), and total().

_leafId_

NodeId gum::AbstractLeaf::_leafId_

privateinherited

Definition at line 116 of file abstractLeaf.h.

Referenced by AbstractLeaf(), contains(), and id().

---

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

• agrum/FMDP/learning/datastructure/leaves/composedLeaf.h
• agrum/FMDP/learning/datastructure/leaves/composedLeaf.cpp
• agrum/FMDP/learning/datastructure/leaves/composedLeaf_inl.h