Gluco2::Heap2< Comp, Obj > Class Template Reference

#include <Heap2.h>

Public Member Functions
	Heap2 (const Comp &c)
int	size () const
bool	empty () const
bool	inHeap (int n) const
int	operator[] (int index) const
void	decrease (int n)
void	increase (int n)
void	prelocate (int ext_cap)
int	data_attr (int n) const
void	update (const Obj &x)
void	insert (const Obj &x)
int	removeMin (int &_attr)
void	clear (bool dealloc=false)
void	clear_ (bool dealloc=false)

Detailed Description

template<class Comp, class Obj>
class Gluco2::Heap2< Comp, Obj >

Definition at line 35 of file Heap2.h.

Constructor & Destructor Documentation

Heap2()

template<class Comp, class Obj>

Gluco2::Heap2< Comp, Obj >::Heap2 ( const Comp & c )

inline

Definition at line 79 of file Heap2.h.

: lt(c) { }

Member Function Documentation

clear()

template<class Comp, class Obj>

void Gluco2::Heap2< Comp, Obj >::clear ( bool dealloc = false )

inline

Definition at line 145 of file Heap2.h.

    { 
        int i;
        for (i = 0; i < heap.size(); i++)
            indices[heap[i].data()] = -1;
        heap.clear(dealloc); 
    }

clear_()

template<class Comp, class Obj>

void Gluco2::Heap2< Comp, Obj >::clear_ ( bool dealloc = false )

inline

Definition at line 152 of file Heap2.h.

    { 
        int i;
        for (i = 0; i < heap.size(); i++)
            indices[heap[i].data()] = -1;
 
        if( ! dealloc ) heap.shrink_( heap.size() );
        else            heap.clear(true); 
    }

data_attr()

template<class Comp, class Obj>

int Gluco2::Heap2< Comp, Obj >::data_attr ( int n ) const

inline

Definition at line 90 of file Heap2.h.

{ return heap[indices[n]].attr(); }

decrease()

template<class Comp, class Obj>

void Gluco2::Heap2< Comp, Obj >::decrease ( int n )

inline

Definition at line 87 of file Heap2.h.

{ assert(inHeap(n)); percolateUp  (indices[n]); }

Here is the call graph for this function:

empty()

template<class Comp, class Obj>

bool Gluco2::Heap2< Comp, Obj >::empty ( ) const

inline

Definition at line 82 of file Heap2.h.

{ return heap.size() == 0; }

increase()

template<class Comp, class Obj>

void Gluco2::Heap2< Comp, Obj >::increase ( int n )

inline

Definition at line 88 of file Heap2.h.

{ assert(inHeap(n)); percolateDown(indices[n]); }

Here is the call graph for this function:

inHeap()

template<class Comp, class Obj>

bool Gluco2::Heap2< Comp, Obj >::inHeap ( int n ) const

inline

Definition at line 83 of file Heap2.h.

{ return n < indices.size() && indices[n] >= 0; }

Here is the caller graph for this function:

insert()

template<class Comp, class Obj>

void Gluco2::Heap2< Comp, Obj >::insert ( const Obj & x )

inline

Definition at line 104 of file Heap2.h.

    {
        int n = x.data();
        indices.growTo(n+1, -1);
        assert(!inHeap(n));
 
        indices[n] = heap.size();
        heap.push(x);
        percolateUp(indices[n]); 
    }

Here is the call graph for this function:

Here is the caller graph for this function:

operator[]()

template<class Comp, class Obj>

int Gluco2::Heap2< Comp, Obj >::operator[] ( int index ) const

inline

Definition at line 84 of file Heap2.h.

{ assert(index < heap.size()); return heap[index].data(); }

prelocate()

template<class Comp, class Obj>

void Gluco2::Heap2< Comp, Obj >::prelocate ( int ext_cap )

inline

Definition at line 89 of file Heap2.h.

{ indices.prelocate(ext_cap); }

removeMin()

template<class Comp, class Obj>

int Gluco2::Heap2< Comp, Obj >::removeMin ( int & _attr )

inline

Definition at line 116 of file Heap2.h.

    {
        Obj x            = heap[0];
        heap[0]          = heap.last();
        indices[heap[0].data()] = 0;
        indices[x.data()]= -1;
        heap.pop();
        if (heap.size() > 1) percolateDown(0);
        //prev = x;
        _attr = x.attr();
        return x.data();
    }

size()

template<class Comp, class Obj>

int Gluco2::Heap2< Comp, Obj >::size ( ) const

inline

Definition at line 81 of file Heap2.h.

{ return heap.size(); }

update()

template<class Comp, class Obj>

void Gluco2::Heap2< Comp, Obj >::update ( const Obj & x )

inline

Definition at line 92 of file Heap2.h.

    {
        int n = x.data();
        if (!inHeap(n))
            insert(x);
        else {
            heap[indices[x.data()]] = x;
            percolateUp(indices[n]);
            percolateDown(indices[n]); }
    }

Here is the call graph for this function:

---

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

• src/sat/glucose2/Heap2.h