The internal class for representing priority queues. More...

#include <agrum/base/core/priorityQueue.h>

Collaboration diagram for gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >:

Public Types

using	value_type = Val
	Types for STL compliance.
using	reference = Val&
	Types for STL compliance.
using	const_reference = const Val&
	Types for STL compliance.
using	pointer = Val*
	Types for STL compliance.
using	const_pointer = const Val*
	Types for STL compliance.
using	difference_type = std::ptrdiff_t
	Types for STL compliance.

Public Member Functions
template<typename... Args>
INLINE Size	emplace (Args &&... args)
Operators
PriorityQueueImplementation< Val, Priority, Cmp, Gen > &	operator= (const PriorityQueueImplementation< Val, Priority, Cmp, Gen > &from)
	Copy operator.
PriorityQueueImplementation< Val, Priority, Cmp, Gen > &	operator= (PriorityQueueImplementation< Val, Priority, Cmp, Gen > &&from)
	Move operator.
const Val &	operator[] (Size index_elt) const
	Returns the element at index "index_elt" from the priority queue.
Accessors / Modifiers
Size	size () const noexcept
	Returns the number of elements in the priority queue.
bool	empty () const noexcept
	Indicates whether the priority queue is empty.
bool	contains (const Val &val) const
	Indicates whether the priority queue contains a given value.
const Val &	top () const
	returns the element at the top of the priority queue
const Priority &	topPriority () const
	Returns the priority of the top element.
Val	pop ()
	Removes the top element from the priority queue and return it.
Size	insert (const Val &val, const Priority &priority)
	Inserts a new (a copy) element in the priority queue.
Size	insert (Val &&val, Priority &&priority)
	Inserts (by move) a new element in the priority queue.
template<typename... Args>
Size	emplace (Args &&... args)
	Emplace a new element into the priority queue.
void	eraseTop ()
	Removes the top of the priority queue (but does not return it).
void	eraseByPos (Size index)
	Removes the element at position "index" from the priority queue.
void	erase (const Val &val)
	Removes a given element from the priority queue (but does not return it).
Size	setPriorityByPos (Size index, const Priority &new_priority)
	Modifies the priority of the element at position "index" of the queue.
Size	setPriorityByPos (Size index, Priority &&new_priority)
	Modifies the priority of the element at position "index" of the queue.
void	setPriority (const Val &elt, const Priority &new_priority)
	Modifies the priority of each instance of a given element.
void	setPriority (const Val &elt, Priority &&new_priority)
	Modifies the priority of each instance of a given element.
const Priority &	priority (const Val &elt) const
	Returns the priority of an instance of the value passed in argument.
const Priority &	priorityByPos (Size index) const
	Returns the priority of the value passed in argument.
void	clear ()
	Removes all the elements from the queue.
const HashTable< Val, Size > &	allValues () const noexcept
	Returns a hashtable the keys of which are the values stored in the queue.
std::string	toString () const
	Displays the content of the queue.
Fine tuning
Size	capacity () const noexcept
	Returns the size of the internal structure storing the priority queue.
void	resize (Size new_size)
	Changes the size of the internal structure storing the priority queue.

Private Member Functions
Constructors / Destructors
	PriorityQueueImplementation (Cmp compare, Size capacity)
	Basic constructor.
	PriorityQueueImplementation (std::initializer_list< std::pair< Val, Priority > > list)
	Initializer list constructor.
	PriorityQueueImplementation (const PriorityQueueImplementation< Val, Priority, Cmp, Gen > &from)
	Copy constructor.
	PriorityQueueImplementation (PriorityQueueImplementation< Val, Priority, Cmp, Gen > &&from)
	Move constructor.
	~PriorityQueueImplementation ()
	Class destructor.

Private Attributes
std::vector< std::pair< Priority, const Val * > >	_heap_
	An array storing all the elements of the heap as well as their score.
HashTable< Val, Size >	_indices_ {HashTableConst::default_size, true, true}
	A hashtable for quickly finding the elements by their value.
Size	_nb_elements_ {0}
	The number of elements in the heap.
Cmp	_cmp_
	Comparison function.

Friends
class	PriorityQueue< Val, Priority, Cmp >
	All gum::PriorityQueue are friends with themselves.

Detailed Description

template<typename Val, typename Priority, typename Cmp, bool Gen>
class gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >

The internal class for representing priority queues.

Priority Queues have different implementations depending on the nature of the values they store. Basically, scalar values can lead to optimization of the code whereas general types like classes cannot. The current class is used for general types (and therefore for classes). The user shall not use directly the implementation but rather use the PriorityQueue class. The latter will be assigned the best implementation at compile time.

Template Parameters

Val	The values type.
Priority	The priorities type.
Cmp	The priorities comparator.
Gen	Used for metaprogramation, for scalar and non-scalar priority queues.

Definition at line 100 of file priorityQueue.h.

Member Typedef Documentation

◆ const_pointer

template<typename Val, typename Priority, typename Cmp, bool Gen>

using gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >::const_pointer = const Val*

Types for STL compliance.

Definition at line 111 of file priorityQueue.h.

◆ const_reference

template<typename Val, typename Priority, typename Cmp, bool Gen>

using gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >::const_reference = const Val&

Types for STL compliance.

Definition at line 109 of file priorityQueue.h.

◆ difference_type

template<typename Val, typename Priority, typename Cmp, bool Gen>

using gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >::difference_type = std::ptrdiff_t

Types for STL compliance.

Definition at line 112 of file priorityQueue.h.

◆ pointer

template<typename Val, typename Priority, typename Cmp, bool Gen>

using gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >::pointer = Val*

Types for STL compliance.

Definition at line 110 of file priorityQueue.h.

◆ reference

template<typename Val, typename Priority, typename Cmp, bool Gen>

using gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >::reference = Val&

Types for STL compliance.

Definition at line 108 of file priorityQueue.h.

◆ value_type

template<typename Val, typename Priority, typename Cmp, bool Gen>

using gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >::value_type = Val

Types for STL compliance.

Definition at line 107 of file priorityQueue.h.

Constructor & Destructor Documentation

◆ PriorityQueueImplementation() [1/4]

template<typename Val, typename Priority, typename Cmp>

INLINE gum::PriorityQueueImplementation< Val, Priority, Cmp >::PriorityQueueImplementation	(	Cmp	compare,
		Size	capacity )

explicitprivate

Basic constructor.

Creates an empty priority queue.

Parameters

compare	A function taking two elements in argument, say e1 and e2, and returning a Boolean indicating wether e1 < e2, i.e., whether e1 should be nearer than e2 to the top of the heap.
capacity	The size of the internal data structures containing the elements (could be for instance vectors or hashtables)

Definition at line 60 of file priorityQueue_tpl.h.

                     : _indices_(capacity >> 1, true, true), _cmp_(compare) {
    _heap_.reserve(capacity);
 
    GUM_CONSTRUCTOR(PriorityQueueImplementation);
  }

References PriorityQueueImplementation(), _cmp_, _heap_, _indices_, and capacity().

Referenced by PriorityQueueImplementation(), PriorityQueueImplementation(), PriorityQueueImplementation(), PriorityQueueImplementation(), ~PriorityQueueImplementation(), operator=(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PriorityQueueImplementation() [2/4]

template<typename Val, typename Priority, typename Cmp>

gum::PriorityQueueImplementation< Val, Priority, Cmp >::PriorityQueueImplementation ( std::initializer_list< std::pair< Val, Priority > > list )

explicitprivate

Initializer list constructor.

The elements of the initializer list are pairs <Val,Priority>. The comparison function is the default one, i.e., std::less<Priority>.

Parameters

list	The initializer list.

Definition at line 70 of file priorityQueue_tpl.h.

                                                            :
      _indices_(Size(list.size()) / 2, true, true) {
    // fill the queue
    _heap_.reserve(list.size());
    for (const auto& elt: list) {
      insert(elt.first, elt.second);
    }
 
    GUM_CONSTRUCTOR(PriorityQueueImplementation);
  }

References PriorityQueueImplementation(), _heap_, _indices_, insert(), and size().

Here is the call graph for this function:

◆ PriorityQueueImplementation() [3/4]

template<typename Val, typename Priority, typename Cmp, bool Gen>

gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >::PriorityQueueImplementation ( const PriorityQueueImplementation< Val, Priority, Cmp, Gen > & from )

private

Copy constructor.

Parameters

from	The gum::PriorityQueueImplementation to copy.

Definition at line 84 of file priorityQueue_tpl.h.

                                                                          :
      _heap_(from._heap_), _indices_(from._indices_), _nb_elements_(from._nb_elements_),
      _cmp_(from._cmp_) {
    // fill the heap structure
    for (const auto& elt: _indices_) {
      _heap_[elt.second].second = &(elt.first);
    }
 
    GUM_CONS_CPY(PriorityQueueImplementation);
  }

References PriorityQueueImplementation(), _cmp_, _heap_, _indices_, and _nb_elements_.

Here is the call graph for this function:

◆ PriorityQueueImplementation() [4/4]

template<typename Val, typename Priority, typename Cmp, bool Gen>

gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >::PriorityQueueImplementation ( PriorityQueueImplementation< Val, Priority, Cmp, Gen > && from )

private

Move constructor.

Parameters

from	The gum::PriorityQueueImplementation to move.

Definition at line 98 of file priorityQueue_tpl.h.

                                                                     :
      _heap_(std::move(from._heap_)), _indices_(std::move(from._indices_)),
      _nb_elements_(std::move(from._nb_elements_)), _cmp_(std::move(from._cmp_)) {
    GUM_CONS_MOV(PriorityQueueImplementation)
  }

References PriorityQueueImplementation(), _cmp_, _heap_, _indices_, and _nb_elements_.

Here is the call graph for this function:

◆ ~PriorityQueueImplementation()

template<typename Val, typename Priority, typename Cmp>

gum::PriorityQueueImplementation< Val, Priority, Cmp >::~PriorityQueueImplementation ( )

private

Class destructor.

Definition at line 107 of file priorityQueue_tpl.h.

                                                                                       {
    GUM_DESTRUCTOR(PriorityQueueImplementation);
  }

References PriorityQueueImplementation().

Here is the call graph for this function:

Member Function Documentation

◆ allValues()

template<typename Val, typename Priority, typename Cmp>

INLINE const HashTable< Val, Size > & gum::PriorityQueueImplementation< Val, Priority, Cmp >::allValues ( ) const

noexcept

Returns a hashtable the keys of which are the values stored in the queue.

The keys of the hashtable correspond to the values stored in the priority queue and, for each key, the corresponding value is the index in the queue where we can find the key.

Returns: Returns a hashtable the keys of which are the values stored in the queue.

Definition at line 272 of file priorityQueue_tpl.h.

                                                                                                {
    return reinterpret_cast< const HashTable< Val, Size >& >(_indices_);
  }

References _indices_.

◆ capacity()

template<typename Val, typename Priority, typename Cmp>

INLINE Size gum::PriorityQueueImplementation< Val, Priority, Cmp >::capacity ( ) const

noexcept

Returns the size of the internal structure storing the priority queue.

Returns: Returns the size of the internal structure storing the priority queue.

Definition at line 188 of file priorityQueue_tpl.h.

                                                                                              {
    return Size(_heap_.capacity());
  }

References _heap_.

Referenced by PriorityQueueImplementation().

Here is the caller graph for this function:

◆ clear()

template<typename Val, typename Priority, typename Cmp>

INLINE void gum::PriorityQueueImplementation< Val, Priority, Cmp >::clear ( )

Removes all the elements from the queue.

Definition at line 203 of file priorityQueue_tpl.h.

                                                                            {
    _nb_elements_ = 0;
    _heap_.clear();
    _indices_.clear();
  }

References _heap_, _indices_, and _nb_elements_.

◆ contains()

template<typename Val, typename Priority, typename Cmp, bool Gen>

INLINE bool gum::PriorityQueueImplementation< Val, Priority, Cmp >::contains ( const Val & val ) const

Indicates whether the priority queue contains a given value.

Parameters

val	The value to look for.

Returns: Returns true if val is in the priority queue.

Definition at line 365 of file priorityQueue_tpl.h.

                                                                                           {
    return _indices_.exists(val);
  }

References _indices_.

◆ emplace() [1/2]

template<typename Val, typename Priority, typename Cmp, bool Gen>

template<typename... Args>

Size gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >::emplace ( Args &&... args )

Emplace a new element into the priority queue.

See gum::PriorityQueueImplementation::eraseByPos(Size) for more details about the index.

Template Parameters

Args	The emplace arguments types.

Parameters

args	The emplace arguments.

Returns: Returns the index of the element inserted into the priority queue.

Exceptions

DuplicateElement Raised if the element already exists.

◆ emplace() [2/2]

template<typename Val, typename Priority, typename Cmp>

template<typename... Args>

INLINE Size gum::PriorityQueueImplementation< Val, Priority, Cmp >::emplace ( Args &&... args )

Definition at line 350 of file priorityQueue_tpl.h.

                                                                                            {
    std::pair< Val, Priority > new_elt
        = std::make_pair< Val, Priority >(std::forward< Args >(args)...);
    return insert(std::move(new_elt.first), std::move(new_elt.second));
  }

◆ empty()

template<typename Val, typename Priority, typename Cmp>

INLINE bool gum::PriorityQueueImplementation< Val, Priority, Cmp >::empty ( ) const

noexcept

Indicates whether the priority queue is empty.

Returns: Returns true if the priority queue is empty.

Definition at line 358 of file priorityQueue_tpl.h.

                                                                                           {
    return (_nb_elements_ == 0);
  }

References _nb_elements_.

◆ erase()

template<typename Val, typename Priority, typename Cmp, bool Gen>

INLINE void gum::PriorityQueueImplementation< Val, Priority, Cmp >::erase ( const Val & val )

Removes a given element from the priority queue (but does not return it).

If the element cannot be found, the function returns without throwing any exception.

If the queue contains several times this element, then the one with the smallest index is removed.

Parameters

val	the element we wish to remove.

Definition at line 246 of file priorityQueue_tpl.h.

                                                                                          {
    try {
      eraseByPos(_indices_[val]);
    } catch (NotFound const&) {}
  }

References _indices_, and eraseByPos().

Referenced by gum::BinaryJoinTreeConverterDefault::_convertClique_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eraseByPos()

template<typename Val, typename Priority, typename Cmp>

void gum::PriorityQueueImplementation< Val, Priority, Cmp >::eraseByPos ( Size index )

Removes the element at position "index" from the priority queue.

If the element cannot be found, the function returns without throwing any exception.

The priority is computed as follows: suppose that the queue is a complete binary tree where all levels are completely filled except, eventually, the last one. In this case, the elements of the last level are all on the left of the tree.

We assign 0 to the root, then parsing the tree from top to bottom then from left to right we increment the index and assigned it to the current node. Doing so, we get a unique index for each element. This is precisely what the index passed in argument of the function represents.

Parameters

index represents the position of the element to be removed.

Definition at line 211 of file priorityQueue_tpl.h.

                                                                                    {
    if (index >= _nb_elements_) return;
 
    // remove the element from the hashtable
    _indices_.erase(*(_heap_[index].second));
 
    // put the last element at the "index" location
    std::pair< Priority, const Val* > last = std::move(_heap_[_nb_elements_ - 1]);
    _heap_.pop_back();
    --_nb_elements_;
 
    if (!_nb_elements_ || (index == _nb_elements_)) return;
 
    // restore the heap property
    Size i = index;
 
    for (Size j = (index << 1) + 1; j < _nb_elements_; i = j, j = (j << 1) + 1) {
      // let j be the max child
      if ((j + 1 < _nb_elements_) && _cmp_(_heap_[j + 1].first, _heap_[j].first)) ++j;
 
      // if "last" is lower than heap[j], "last" must be stored at index i
      if (_cmp_(last.first, _heap_[j].first)) break;
 
      // else pull up the jth node
      _heap_[i]                      = std::move(_heap_[j]);
      _indices_[*(_heap_[i].second)] = i;
    }
 
    // put "last" back into the heap
    _heap_[i]                      = std::move(last);
    _indices_[*(_heap_[i].second)] = i;
  }

References _nb_elements_.

Referenced by erase(), eraseTop(), and pop().

Here is the caller graph for this function:

◆ eraseTop()

template<typename Val, typename Priority, typename Cmp>

INLINE void gum::PriorityQueueImplementation< Val, Priority, Cmp >::eraseTop ( )

Removes the top of the priority queue (but does not return it).

If the heap is empty, it does nothing (in particular, it does not throw any exception).

Definition at line 254 of file priorityQueue_tpl.h.

                                                                               {
    eraseByPos(0);
  }

References eraseByPos().

Here is the call graph for this function:

◆ insert() [1/2]

template<typename Val, typename Priority, typename Cmp, bool Gen>

INLINE Size gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >::insert	(	const Val &	val,
		const Priority &	priority )

Inserts a new (a copy) element in the priority queue.

See gum::PriorityQueueImplementation::eraseByPos(Size) for more details about the index.

Parameters

val	The value to insert.
priority	The value's priority in the queue.

Returns: Returns the index of the element inserted into the priority queue.

Exceptions

DuplicateElement Raised if the element already exists.

Definition at line 279 of file priorityQueue_tpl.h.

                                                                                               {
    // create the entry in the indices hashtable (if the element already exists,
    //  _indices_.insert will raise a Duplicateelement exception)
    typename HashTable< Val, Size >::value_type& new_elt = _indices_.insert(val, 0);
 
    try {
      _heap_.push_back(std::pair< Priority, const Val* >(priority, &new_elt.first));
    } catch (...) {
      _indices_.erase(val);
      throw;
    }
 
    std::pair< Priority, const Val* > new_heap_val = std::move(_heap_[_nb_elements_]);
    ++_nb_elements_;
 
    // restore the heap property
    Size i = _nb_elements_ - 1;
 
    for (Size j = (i - 1) >> 1; i && _cmp_(new_heap_val.first, _heap_[j].first);
         i = j, j = (j - 1) >> 1) {
      _heap_[i]                      = std::move(_heap_[j]);
      _indices_[*(_heap_[i].second)] = i;
    }
 
    // put the new bucket into the heap
    _heap_[i].first  = std::move(new_heap_val.first);
    _heap_[i].second = &(new_elt.first);
    new_elt.second   = i;
 
    return i;
  }

References _heap_, _indices_, and priority().

Referenced by PriorityQueueImplementation(), gum::StaticTriangulation::_computeRecursiveThinning_(), and gum::BinaryJoinTreeConverterDefault::_convertClique_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ insert() [2/2]

template<typename Val, typename Priority, typename Cmp, bool Gen>

INLINE Size gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >::insert	(	Val &&	val,
		Priority &&	priority )

Inserts (by move) a new element in the priority queue.

See gum::PriorityQueueImplementation::eraseByPos(Size) for more details about the index.

Parameters

val	The value to insert.
priority	The value's priority in the queue.

Returns: Returns the index of the element inserted into the priority queue.

Exceptions

DuplicateElement Raised if the element already exists.

Definition at line 314 of file priorityQueue_tpl.h.

                                                                                                  {
    // create the entry in the indices hashtable (if the element already exists,
    //  _indices_.insert will raise a Duplicateelement exception)
    typename HashTable< Val, Size >::value_type& new_elt = _indices_.insert(std::move(val), 0);
 
    try {
      _heap_.push_back(std::pair< Priority, const Val* >(std::move(priority), &(new_elt.first)));
    } catch (...) {
      _indices_.erase(new_elt.first);
      throw;
    }
 
    std::pair< Priority, const Val* > new_heap_val = std::move(_heap_[_nb_elements_]);
    ++_nb_elements_;
 
    // restore the heap property
    Size i = _nb_elements_ - 1;
 
    for (Size j = (i - 1) >> 1; i && _cmp_(new_heap_val.first, _heap_[j].first);
         i = j, j = (j - 1) >> 1) {
      _heap_[i]                      = std::move(_heap_[j]);
      _indices_[*(_heap_[i].second)] = i;
    }
 
    // put the new bucket into the heap
    _heap_[i].first  = std::move(new_heap_val.first);
    _heap_[i].second = &(new_elt.first);
    new_elt.second   = i;
 
    return i;
  }

References _heap_, _indices_, and priority().

Here is the call graph for this function:

◆ operator=() [1/2]

template<typename Val, typename Priority, typename Cmp, bool Gen>

PriorityQueueImplementation< Val, Priority, Cmp, Gen > & gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >::operator= ( const PriorityQueueImplementation< Val, Priority, Cmp, Gen > & from )

Copy operator.

When a problem occurs during the copy (for instance when not enough memory is available), the operator guarantees that the heap stays in a coherent state. Actually, the priority queue becomes empty. An exception is then thrown.

Parameters

from	The gum::PriorityQueueImplementation to copy.

Returns: Returns this gum::PriorityQueueImplementation.

Definition at line 114 of file priorityQueue_tpl.h.

                                                                              {
    // avoid self assignment
    if (this != &from) {
      GUM_OP_CPY(PriorityQueueImplementation)
 
      try {
        // set the comparison function
        _cmp_ = from._cmp_;
 
        // copy the indices and the heap
        _indices_     = from._indices_;
        _heap_        = from._heap_;
        _nb_elements_ = from._nb_elements_;
 
        // restore the link between  _indices_ and  _heap_
        for (const auto& elt: _indices_) {
          _heap_[elt.second].second = &(elt.first);
        }
      } catch (...) {
        _heap_.clear();
        _indices_.clear();
        _nb_elements_ = 0;
 
        throw;
      }
    }
 
    return *this;
  }

References PriorityQueueImplementation(), _cmp_, _heap_, _indices_, and _nb_elements_.

Referenced by gum::PriorityQueue< Val, Priority, Cmp >::operator=(), and gum::PriorityQueue< Val, Priority, Cmp >::operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=() [2/2]

template<typename Val, typename Priority, typename Cmp, bool Gen>

INLINE PriorityQueueImplementation< Val, Priority, Cmp, Gen > & gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >::operator= ( PriorityQueueImplementation< Val, Priority, Cmp, Gen > && from )

Move operator.

Parameters

from	The gum::PriorityQueueImplementation to move.

Returns: Returns this gum::PriorityQueueImplementation.

Definition at line 148 of file priorityQueue_tpl.h.

                                                                         {
    // avoid self assignment
    if (this != &from) {
      GUM_OP_MOV(PriorityQueueImplementation)
 
      _indices_     = std::move(from._indices_);
      _heap_        = std::move(from._heap_);
      _cmp_         = std::move(from._cmp_);
      _nb_elements_ = std::move(from._nb_elements_);
    }
 
    return *this;
  }

References PriorityQueueImplementation(), _cmp_, _heap_, and _indices_.

Here is the call graph for this function:

◆ operator[]()

template<typename Val, typename Priority, typename Cmp>

INLINE const Val & gum::PriorityQueueImplementation< Val, Priority, Cmp >::operator[] ( Size index_elt ) const

Returns the element at index "index_elt" from the priority queue.

Parameters

index_elt The index of the element to return.

Returns: Returns the element at index "index_elt" from the priority queue.

Exceptions

NotFound Raised if the element does not exist.

Definition at line 372 of file priorityQueue_tpl.h.

                                                                                         {
    if (index >= _nb_elements_) {
      GUM_ERROR(NotFound, "not enough elements in the PriorityQueueImplementation")
    }
 
    return *(_heap_[index].second);
  }

References _nb_elements_.

◆ pop()

template<typename Val, typename Priority, typename Cmp>

INLINE Val gum::PriorityQueueImplementation< Val, Priority, Cmp >::pop ( )

Removes the top element from the priority queue and return it.

Returns: Returns the top element from the priority queue.

Exceptions

NotFound Raised if the queue is empty.

Definition at line 260 of file priorityQueue_tpl.h.

                                                                         {
    if (!_nb_elements_) { GUM_ERROR(NotFound, "empty priority queue") }
 
    Val v = *(_heap_[0].second);
    eraseByPos(0);
 
    return v;
  }

References _heap_, _nb_elements_, eraseByPos(), and GUM_ERROR.

Referenced by gum::StaticTriangulation::_computeRecursiveThinning_(), and gum::BinaryJoinTreeConverterDefault::_convertClique_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ priority()

template<typename Val, typename Priority, typename Cmp, bool Gen>

INLINE const Priority & gum::PriorityQueueImplementation< Val, Priority, Cmp >::priority ( const Val & elt ) const

Returns the priority of an instance of the value passed in argument.

Parameters

elt	The element for which the priority is returned.

Returns: Returns the priority of an instance of the value passed in argument.

Exceptions

NotFound Raised if the element cannot be found.

Definition at line 505 of file priorityQueue_tpl.h.

                                                                                           {
    return _heap_[_indices_[elt]].first;
  }

References _heap_, and _indices_.

Referenced by gum::StaticTriangulation::_computeRecursiveThinning_(), insert(), and insert().

Here is the caller graph for this function:

◆ priorityByPos()

template<typename Val, typename Priority, typename Cmp>

INLINE const Priority & gum::PriorityQueueImplementation< Val, Priority, Cmp >::priorityByPos ( Size index ) const

Returns the priority of the value passed in argument.

Parameters

index The index of the value of which the priority is returned.

Exceptions

NotFound Raised if the element cannot be found.

Definition at line 512 of file priorityQueue_tpl.h.

                                                                                            {
    if (index > _nb_elements_) {
      GUM_ERROR(NotFound, "not enough elements in the PriorityQueueImplementation")
    }
    return _heap_[index].first;
  }

References _heap_, _nb_elements_, and GUM_ERROR.

◆ resize()

template<typename Val, typename Priority, typename Cmp>

INLINE void gum::PriorityQueueImplementation< Val, Priority, Cmp >::resize ( Size new_size )

Changes the size of the internal structure storing the priority queue.

Parameters

new_size The internal structure new size.

Definition at line 194 of file priorityQueue_tpl.h.

                                                                                          {
    if (new_size < _nb_elements_) return;
 
    _heap_.reserve(new_size);
    _indices_.resize(new_size / 2);
  }

References _nb_elements_.

◆ setPriority() [1/2]

template<typename Val, typename Priority, typename Cmp, bool Gen>

void gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >::setPriority	(	const Val &	elt,
		const Priority &	new_priority )

Modifies the priority of each instance of a given element.

Parameters

elt	The value to update.
new_priority	The values new priority.

Exceptions

NotFound Raised if the element cannot be found.

Definition at line 488 of file priorityQueue_tpl.h.

                                    {
    setPriorityByPos(_indices_[elt], new_priority);
  }

References _indices_, and setPriorityByPos().

Referenced by gum::StaticTriangulation::_computeRecursiveThinning_(), and gum::BinaryJoinTreeConverterDefault::_convertClique_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setPriority() [2/2]

template<typename Val, typename Priority, typename Cmp, bool Gen>

void gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >::setPriority	(	const Val &	elt,
		Priority &&	new_priority )

Modifies the priority of each instance of a given element.

Parameters

elt	The value to update.
new_priority	The values new priority.

Exceptions

NotFound Raised if the element cannot be found.

Definition at line 497 of file priorityQueue_tpl.h.

                                                                                                   {
    setPriorityByPos(_indices_[elt], std::move(new_priority));
  }

References _indices_, and setPriorityByPos().

Here is the call graph for this function:

◆ setPriorityByPos() [1/2]

template<typename Val, typename Priority, typename Cmp>

Size gum::PriorityQueueImplementation< Val, Priority, Cmp >::setPriorityByPos	(	Size	index,
		const Priority &	new_priority )

Modifies the priority of the element at position "index" of the queue.

Parameters

index	The index of the element to update.
new_priority	The element's new priority.

Returns: Returns the elements new priority.

Exceptions

NotFound Raised if the element cannot be found.

Definition at line 400 of file priorityQueue_tpl.h.

                                    {
    // check whether the element the priority of which should be changed exists
    if (index >= _nb_elements_) {
      GUM_ERROR(NotFound, "not enough elements in the PriorityQueueImplementation")
    }
 
    // get the element itself
    const Val* val = _heap_[index].second;
 
    // restore the heap property
    Size i = index;
 
    // move val upward if needed
    for (Size j = (i - 1) >> 1; i && _cmp_(new_priority, _heap_[j].first);
         i = j, j = (j - 1) >> 1) {
      _heap_[i]                      = std::move(_heap_[j]);
      _indices_[*(_heap_[i].second)] = i;
    }
 
    // move val downward if needed
    for (Size j = (i << 1) + 1; j < _nb_elements_; i = j, j = (j << 1) + 1) {
      // let j be the max child
      if ((j + 1 < _nb_elements_) && _cmp_(_heap_[j + 1].first, _heap_[j].first)) ++j;
 
      // if "val" is lower than heap[j], "val" must be stored at index i
      if (_cmp_(new_priority, _heap_[j].first)) break;
 
      // else pull up the jth node
      _heap_[i]                      = std::move(_heap_[j]);
      _indices_[*(_heap_[i].second)] = i;
    }
 
    // update the index of val
    _heap_[i].first  = new_priority;
    _heap_[i].second = val;
    _indices_[*val]  = i;
 
    return i;
  }

References _nb_elements_.

Referenced by setPriority(), and setPriority().

Here is the caller graph for this function:

◆ setPriorityByPos() [2/2]

template<typename Val, typename Priority, typename Cmp>

Size gum::PriorityQueueImplementation< Val, Priority, Cmp >::setPriorityByPos	(	Size	index,
		Priority &&	new_priority )

Modifies the priority of the element at position "index" of the queue.

Parameters

index	The index of the element to update.
new_priority	The element's new priority.

Returns: Returns the elements new priority.

Exceptions

NotFound Raised if the element cannot be found.

Definition at line 444 of file priorityQueue_tpl.h.

                               {
    // check whether the element the priority of which should be changed exists
    if (index >= _nb_elements_) {
      GUM_ERROR(NotFound, "not enough elements in the PriorityQueueImplementation")
    }
 
    // get the element itself
    const Val* val = _heap_[index].second;
 
    // restore the heap property
    Size i = index;
 
    // move val upward if needed
    for (Size j = (i - 1) >> 1; i && _cmp_(new_priority, _heap_[j].first);
         i = j, j = (j - 1) >> 1) {
      _heap_[i]                      = std::move(_heap_[j]);
      _indices_[*(_heap_[i].second)] = i;
    }
 
    // move val downward if needed
    for (Size j = (i << 1) + 1; j < _nb_elements_; i = j, j = (j << 1) + 1) {
      // let j be the max child
      if ((j + 1 < _nb_elements_) && _cmp_(_heap_[j + 1].first, _heap_[j].first)) ++j;
 
      // if "val" is lower than heap[j], "val" must be stored at index i
      if (_cmp_(new_priority, _heap_[j].first)) break;
 
      // else pull up the jth node
      _heap_[i]                      = std::move(_heap_[j]);
      _indices_[*(_heap_[i].second)] = i;
    }
 
    // update the index of val
    _heap_[i].first  = std::move(new_priority);
    _heap_[i].second = val;
    _indices_[*val]  = i;
 
    return i;
  }

References _cmp_, _heap_, _indices_, _nb_elements_, and GUM_ERROR.

◆ size()

template<typename Val, typename Priority, typename Cmp>

INLINE Size gum::PriorityQueueImplementation< Val, Priority, Cmp >::size ( ) const

noexcept

Returns the number of elements in the priority queue.

Returns: Returns the number of elements in the priority queue.

Definition at line 182 of file priorityQueue_tpl.h.

                                                                                          {
    return _nb_elements_;
  }

References _nb_elements_.

Referenced by PriorityQueueImplementation().

Here is the caller graph for this function:

◆ top()

template<typename Val, typename Priority, typename Cmp>

INLINE const Val & gum::PriorityQueueImplementation< Val, Priority, Cmp >::top ( ) const

returns the element at the top of the priority queue

Exceptions

NotFound Raised if the queue is empty

Definition at line 165 of file priorityQueue_tpl.h.

                                                                                      {
    if (!_nb_elements_) { GUM_ERROR(NotFound, "empty priority queue") }
 
    return *(_heap_[0].second);
  }

References _heap_, _nb_elements_, and GUM_ERROR.

◆ topPriority()

template<typename Val, typename Priority, typename Cmp>

INLINE const Priority & gum::PriorityQueueImplementation< Val, Priority, Cmp >::topPriority ( ) const

Returns the priority of the top element.

Returns: Returns the priority of the top element.

Exceptions

NotFound Raised if the queue is empty.

Definition at line 174 of file priorityQueue_tpl.h.

                                                                                {
    if (!_nb_elements_) { GUM_ERROR(NotFound, "empty priority queue") }
 
    return _heap_[0].first;
  }

References _heap_, _nb_elements_, and GUM_ERROR.

◆ toString()

template<typename Val, typename Priority, typename Cmp>

std::string gum::PriorityQueueImplementation< Val, Priority, Cmp >::toString ( ) const

Displays the content of the queue.

Returns: Returns the content of the queue.

Definition at line 382 of file priorityQueue_tpl.h.

                                                                                   {
    bool              deja = false;
    std::stringstream stream;
    stream << "[";
 
    for (Size i = 0; i != _nb_elements_; ++i, deja = true) {
      if (deja) stream << " , ";
 
      stream << "(" << _heap_[i].first << " , " << *(_heap_[i].second) << ")";
    }
 
    stream << "]";
 
    return stream.str();
  }

Referenced by gum::operator<<().

Here is the caller graph for this function:

◆ PriorityQueue< Val, Priority, Cmp >

template<typename Val, typename Priority, typename Cmp, bool Gen>

friend class PriorityQueue< Val, Priority, Cmp >

friend

All gum::PriorityQueue are friends with themselves.

Definition at line 74 of file priorityQueue.h.

Member Data Documentation

◆ _cmp_

template<typename Val, typename Priority, typename Cmp, bool Gen>

Cmp gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >::_cmp_

private

Comparison function.

Definition at line 441 of file priorityQueue.h.

Referenced by PriorityQueueImplementation(), PriorityQueueImplementation(), PriorityQueueImplementation(), operator=(), operator=(), and setPriorityByPos().

◆ _heap_

template<typename Val, typename Priority, typename Cmp, bool Gen>

std::vector< std::pair< Priority, const Val* > > gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >::_heap_

private

An array storing all the elements of the heap as well as their score.

Definition at line 432 of file priorityQueue.h.

Referenced by PriorityQueueImplementation(), PriorityQueueImplementation(), PriorityQueueImplementation(), PriorityQueueImplementation(), capacity(), clear(), insert(), insert(), operator=(), operator=(), pop(), priority(), priorityByPos(), setPriorityByPos(), top(), and topPriority().

◆ _indices_

template<typename Val, typename Priority, typename Cmp, bool Gen>

HashTable< Val, Size > gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >::_indices_ {HashTableConst::default_size, true, true}

private

A hashtable for quickly finding the elements by their value.

Definition at line 435 of file priorityQueue.h.

435{HashTableConst::default_size, true, true};

Referenced by PriorityQueueImplementation(), PriorityQueueImplementation(), PriorityQueueImplementation(), PriorityQueueImplementation(), allValues(), clear(), contains(), erase(), insert(), insert(), operator=(), operator=(), priority(), setPriority(), setPriority(), and setPriorityByPos().

◆ _nb_elements_

template<typename Val, typename Priority, typename Cmp, bool Gen>

Size gum::PriorityQueueImplementation< Val, Priority, Cmp, Gen >::_nb_elements_ {0}

private

The number of elements in the heap.

Definition at line 438 of file priorityQueue.h.

438{0};

Referenced by PriorityQueueImplementation(), PriorityQueueImplementation(), clear(), empty(), eraseByPos(), operator=(), operator[](), pop(), priorityByPos(), resize(), setPriorityByPos(), setPriorityByPos(), size(), top(), and topPriority().

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

agrum/base/core/priorityQueue.h
agrum/base/core/priorityQueue_tpl.h

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ const_pointer

◆ const_reference

◆ difference_type

◆ pointer

◆ reference

◆ value_type

Constructor & Destructor Documentation

◆ PriorityQueueImplementation() [1/4]

◆ PriorityQueueImplementation() [2/4]

◆ PriorityQueueImplementation() [3/4]

◆ PriorityQueueImplementation() [4/4]

◆ ~PriorityQueueImplementation()

Member Function Documentation

◆ allValues()

◆ capacity()

◆ clear()

◆ contains()

◆ emplace() [1/2]

◆ emplace() [2/2]

◆ empty()

◆ erase()

◆ eraseByPos()

◆ eraseTop()

◆ insert() [1/2]

◆ insert() [2/2]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator[]()

◆ pop()

◆ priority()

◆ priorityByPos()

◆ resize()

◆ setPriority() [1/2]

◆ setPriority() [2/2]

◆ setPriorityByPos() [1/2]

◆ setPriorityByPos() [2/2]

◆ size()

◆ top()

◆ topPriority()

◆ toString()

Friends And Related Symbol Documentation

◆ PriorityQueue< Val, Priority, Cmp >

Member Data Documentation

◆ _cmp_

◆ _heap_

◆ _indices_

◆ _nb_elements_