This is a template for a set of objects of the given type. More...

#include <hashsets.h>

Public Types
typedef element	value_type
	The type of elements stored in the set. More...

typedef hashkeys	hashing_method
	The type of hashing. More...

Public Member Functions
	hashedset (int_t initialsize=0, int bequiet=1)
	The default constructor for creating an empty set of objects. More...

	hashedset (const hashedset< element, hashkeys > &s)
	The copy constructor. More...

hashedset &	operator= (const hashedset< element, hashkeys > &s)
	The assignment operator. More...

	~hashedset (void)
	The destructor. More...

int_t	getnumber (const element &e) const
	Finds the given element and returns its number. More...

bool	checknum (int_t n) const
	Checks if the given number is an index of some element in the set, that is, if the number is non-negative and strictly smaller than the number of elements in the set. More...

bool	check (const element &e) const
	Checks if the given element is in the set. More...

const element &	operator[] (int_t n) const
	Returns the element with the given number from the set. More...

const element &	get (int_t n) const
	Returns the element with the given number from the set. More...

const element &	front () const
	Returns the last element in the set. More...

const element &	top () const
	Returns the last element in the set. More...

int_t	add (const element &e)
	Adds the given element to the set and returns its number. More...

int_t	push (const element &e)
	Adds an element to the set (this is an equivalent of 'add'). More...

int_t	push_back (const element &e)
	Adds an element to the set (this is an equivalent of 'add'). More...

int	remove (const element &e)
	Removes the given element from the set. More...

int	removenum (int_t n)
	Returns an element with the given number from the set. More...

int_t	pop ()
	Removes the last element from the set. More...

hashedset< element, hashkeys > &	add (const hashedset< element, hashkeys > &s)
	Adds an entire set of elements to the set. More...

hashedset< element, hashkeys > &	remove (const hashedset< element, hashkeys > &s)
	Removes an entire set of elements from the set. More...

int_t	size () const
	Returns the number of elements in the set. More...

bool	empty () const
	Returns true if the set is empty. Otherwise returns false. More...

void	swap (hashedset< element, hashkeys > &other)
	Swaps two hashed sets by swapping their internal data. More...

bool	operator== (const hashedset< element, hashkeys > &other) const
	Verifies whether two hashed sets have the same elements. More...

void	intersection (const hashedset< element, hashkeys > &s1, const hashedset< element, hashkeys > &s2)
	Computes the intersection of two hashed sets and adds the result to the current set. More...

Public Attributes
hashstat *	stat
	Hashed set statistics. More...

Private Member Functions
int_t	hashfind (const element &e, int_t *addpos=NULL) const
	Finds the position in the hashing table at which the number of the given element should be. More...

void	rehash (int_t newsize=0)
	Replace the old hashing table with a new one. More...

Static Private Member Functions
static bool	numberisprime (const int_t &n)
	Verifies whether the given number is prime or not. More...

static int_t	rounduptoprime (int_t n)
	Rounds up the given number to a prime number. More...

Private Attributes
int_t	nelem
	The number of elements stored in the set. More...

multitable< element >	tab
	The table of these elements. More...

int	hashing
	Is the hashing table in use? More...

int_t	hashsize
	The size of the hashing table. More...

int_t	hashcleared
	The number of cleared entries in the hashing table. More...

multitable< int_t >	hashtable
	The hashing table. More...

Static Private Attributes
static const int_t	InitHashSize
	The default initial size of a hashing table. More...

static const int_t	InitTabSize
	The initial size of a table in a hashed set. More...

static const int_t	StartHashingSize
	The minimal number of elements above which hashing table is actually used. More...

Detailed Description

template<class element, class hashkeys = HashingGlobal<element>>
class chomp::homology::hashedset< element, hashkeys >

This is a template for a set of objects of the given type.

Each of the objects should have two functions for generating hashing keys: "int_t hashkey1 (const object &x)" and "int_t hashkey2 (x)". Note: If you remove elements which are not at the end of the set, then the numbers of other elements can change! In the current solution, the last element is put in place of the removed one, but this behavior may be changed in the future versions of this template.

Definition at line 184 of file hashsets.h.

Member Typedef Documentation

◆ hashing_method

template<class element , class hashkeys = HashingGlobal<element>>

typedef hashkeys chomp::homology::hashedset< element, hashkeys >::hashing_method

The type of hashing.

Definition at line 191 of file hashsets.h.

◆ value_type

template<class element , class hashkeys = HashingGlobal<element>>

typedef element chomp::homology::hashedset< element, hashkeys >::value_type

The type of elements stored in the set.

Definition at line 188 of file hashsets.h.

Constructor & Destructor Documentation

◆ hashedset() [1/2]

template<class element , class hashkeys >

chomp::homology::hashedset< element, hashkeys >::hashedset	(	int_t	initialsize = `0`,
		int	bequiet = `1`
	)

explicit

The default constructor for creating an empty set of objects.

If you expect the set to keep a lot of elements, you may want to set the initial size to something large.

Definition at line 355 of file hashsets.h.

                                                                     :
        nelem (0), tab ((initialsize > 0) ? initialsize :
                int_t (InitTabSize)),
        hashing (0),
        hashsize (initialsize + (initialsize >> 2) + InitHashSize),
        hashcleared (0), hashtable (hashsize)
{
        hashedset<element,hashkeys>::rounduptoprime (hashsize);
        if (bequiet)
                stat = NULL;
        else
                stat = new hashstat;
        return;
} /* hashedset<element,hashkeys>::hashedset */

References chomp::homology::hashedset< element, hashkeys >::hashsize, chomp::homology::hashedset< element, hashkeys >::rounduptoprime(), and chomp::homology::hashedset< element, hashkeys >::stat.

◆ hashedset() [2/2]

template<class element , class hashkeys >

chomp::homology::hashedset< element, hashkeys >::hashedset ( const hashedset< element, hashkeys > & s )

The copy constructor.

Definition at line 371 of file hashsets.h.

                                                                           :
        nelem (s. nelem), tab (s. tab),
        hashing (s. hashing), hashsize (s. hashsize),
        hashcleared (s. hashcleared), hashtable (s. hashtable)
{
        if (s. stat)
                stat = new hashstat;
        else
                stat = NULL;
        return;
} /* hashedset<element,hashkeys>::hashedset */

References chomp::homology::hashedset< element, hashkeys >::stat.

◆ ~hashedset()

template<class element , class hashkeys >

chomp::homology::hashedset< element, hashkeys >::~hashedset ( void )

The destructor.

Definition at line 403 of file hashsets.h.

{
        if (!stat)
                return;
        sout << "  " << *stat << '\n';
        delete stat;
        stat = NULL;
        return;
} /* hashedset<element,hashkeys>::~hashedset */

References chomp::homology::sout.

Member Function Documentation

◆ add() [1/2]

template<class element , class hashkeys >

int_t chomp::homology::hashedset< element, hashkeys >::add ( const element & e )

Adds the given element to the set and returns its number.

If the element was already in the set, it is not added the second time, only its number is returned.

Definition at line 471 of file hashsets.h.

{
        if (!hashing)
        {
                for (int_t i = 0; i < nelem; ++ i)
                {
                        if (tab (i) == e)
                                return i;
                }
                tab [nelem ++] = e;
                if (nelem >= StartHashingSize)
                {
                        hashing = 1;
                        rehash ();
                }
                return (nelem - 1);
        }
 
        // rehash if there is very little free space in the hashing table
        if (hashsize - hashcleared < nelem + (nelem >> 1) + 19)
                rehash ();
 
        // find the position of the element's number in the hashing table
        int_t addpos = -1;
        int_t pos = hashfind (e, &addpos);
 
        // if it alread was in the set, then just return its number
        if (hashtable (pos) >= 0)
                return hashtable (pos);
 
        // add this element to the set and return its new number
        if (addpos >= 0)
                pos = addpos;
        hashtable [pos] = nelem;
        tab [nelem] = e;
        return nelem ++;
} /* hashedset<element,hashkeys>::add */

◆ add() [2/2]

template<class element , class hashkeys >

hashedset< element, hashkeys > & chomp::homology::hashedset< element, hashkeys >::add ( const hashedset< element, hashkeys > & s )

Adds an entire set of elements to the set.

Definition at line 596 of file hashsets.h.

{
        int_t n = s. size ();
        for (int_t i = 0; i < n; ++ i)
                add (s [i]);
        return *this;
} /* hashedset<element,hashkeys>::add */

◆ check()

template<class element , class hashkeys >

bool chomp::homology::hashedset< element, hashkeys >::check ( const element & e ) const

inline

Checks if the given element is in the set.

Returns true if yes, false if no.

Definition at line 439 of file hashsets.h.

{
        return (getnumber (e) >= 0);
} /* hashedset<element,hashkeys>::check */

◆ checknum()

template<class element , class hashkeys >

bool chomp::homology::hashedset< element, hashkeys >::checknum ( int_t n ) const

inline

Checks if the given number is an index of some element in the set, that is, if the number is non-negative and strictly smaller than the number of elements in the set.

Returns true if yes, false if no.

Definition at line 433 of file hashsets.h.

{
        return ((n >= 0) && (n < nelem));
} /* hashedset<element,hashkeys>::checknum */

◆ empty()

template<class element , class hashkeys >

bool chomp::homology::hashedset< element, hashkeys >::empty

inline

Returns true if the set is empty. Otherwise returns false.

Definition at line 625 of file hashsets.h.

{
        return !nelem;
} /* hashedset<element,hashkeys>::empty */

◆ front()

template<class element , class hashkeys >

const element & chomp::homology::hashedset< element, hashkeys >::front

inline

Returns the last element in the set.

Definition at line 459 of file hashsets.h.

{
        return get (nelem - 1);
} /* hashedset<element,hashkeys>::front */

◆ get()

template<class element , class hashkeys >

const element & chomp::homology::hashedset< element, hashkeys >::get ( int_t n ) const

inline

Returns the element with the given number from the set.

Definition at line 445 of file hashsets.h.

{
        if ((n < 0) || (n >= nelem))
                throw "Trying to get an element out of range.";
        return tab (n);
} /* hashedset<element,hashkeys>::get */

◆ getnumber()

template<class element , class hashkeys >

int_t chomp::homology::hashedset< element, hashkeys >::getnumber ( const element & e ) const

Finds the given element and returns its number.

Returns -1 if the element is not in the set.

Definition at line 414 of file hashsets.h.

{
        if (hashing)
        {
                int_t pos = hashfind (e);
                return (hashtable (pos));
        }
        else
        {
                for (int_t i = 0; i < nelem; ++ i)
                {
                        if (tab (i) == e)
                                return i;
                }
                return -1;
        }
} /* hashedset<element,hashkeys>::getnumber */

◆ hashfind()

template<class element , class hashkeys >

int_t chomp::homology::hashedset< element, hashkeys >::hashfind	(	const element &	e,
		int_t *	addpos = `NULL`
	)		const

private

Finds the position in the hashing table at which the number of the given element should be.

If there is -1 there, then the number's element should be written there if adding. Saves to 'addposition' the first cleared position in the hashing table if found or sets it to -1 otherwise.

Definition at line 692 of file hashsets.h.

{
        if (!hashing)
                throw "Hashing is turned off.";
 
        int_t key = hashkey1 (e);
        if (key < 0)
                key = -(key + 1);
        int_t pos = key % hashsize;
        if (addpos)
                *addpos = -1;
 
        // start updating hashing statistics
        if (stat)
                ++ (stat -> hashhits);
 
        // find the position of the element in the hashing table
        int_t number;
        int_t add = 0;
        while ((number = hashtable (pos)) != -1)
        {
                if ((number >= 0) && (e == tab (number)))
                        return (pos);
                if (addpos && (*addpos < 0) && (number == -2))
                        *addpos = pos;
                if (!add)
                {
                        int_t key = hashkey2 (e);
                        if (key < 0)
                                key = -(key + 1);
                        add = key % (hashsize - 1) + 1;
                }
                pos += add;
                if (pos >= hashsize)
                        pos -= hashsize;
                if (stat)
                        ++ (stat -> hashmisses);
        }
 
        // return the position located in the hashing table
        return (pos);
 
} /* hashedset<element,hashkeys>::hashfind */

References chomp::homology::hashkey1(), and chomp::homology::hashkey2().

◆ intersection()

template<class element , class hashkeys >

void chomp::homology::hashedset< element, hashkeys >::intersection	(	const hashedset< element, hashkeys > &	s1,
		const hashedset< element, hashkeys > &	s2
	)

inline

Computes the intersection of two hashed sets and adds the result to the current set.

Definition at line 664 of file hashsets.h.

{
        int_t size1 = s1. size ();
        int_t size2 = s2. size ();
 
        if (size1 <= size2)
        {
                for (int_t i = 0; i < size1; ++ i)
                {
                        const element &elem = s1. tab [i];
                        if (s2. check (elem))
                                this -> add (elem);
                }
        }
        else
        {
                for (int_t i = 0; i < size2; ++ i)
                {
                        const element &elem = s2. tab [i];
                        if (s1. check (elem))
                                this -> add (elem);
                }
        }
        return;
} /* hashedset<element,hashkeys>::intersection */

◆ numberisprime()

template<class element , class hashkeys >

bool chomp::homology::hashedset< element, hashkeys >::numberisprime ( const int_t & n )

inlinestaticprivate

Verifies whether the given number is prime or not.

Note: This procedure is quite inefficient for large numbers.

Definition at line 781 of file hashsets.h.

{
        if (n < 2)
                return 0;
 
        int_t i = 2;
        while (i * i <= n)
        {
                if (!(n % i))
                        return false;
                ++ i;
        }
 
        return true;
} /* hashedset<element,hashkeys>::numberisprime */

◆ operator=()

template<class element , class hashkeys >

hashedset< element, hashkeys > & chomp::homology::hashedset< element, hashkeys >::operator= ( const hashedset< element, hashkeys > & s )

The assignment operator.

Definition at line 384 of file hashsets.h.

{
        if (this == &s)
                return *this;
 
        if (s. stat)
                stat = new hashstat (*stat);
        nelem = s. nelem;
        tab = s. tab;
        hashing = s. hashing;
        hashsize = s. hashsize;
        hashcleared = s. hashcleared;
        hashtable = s. hashtable;
 
        return *this;
} /* multitable<element,hashkeys>::operator = */

◆ operator==()

template<class element , class hashkeys >

bool chomp::homology::hashedset< element, hashkeys >::operator== ( const hashedset< element, hashkeys > & other ) const

inline

Verifies whether two hashed sets have the same elements.

Uses the standard comparison operator for the elements.

Definition at line 650 of file hashsets.h.

{
        if (this -> nelem != other. nelem)
                return false;
        for (int_t i = 0; i < nelem; ++ i)
        {
                if (!other. check (this -> tab [i]))
                        return false;
        }
        return true;
} /* hashedset<element,hashkeys>::swap */

◆ operator[]()

template<class element , class hashkeys >

const element & chomp::homology::hashedset< element, hashkeys >::operator[] ( int_t n ) const

inline

Returns the element with the given number from the set.

Definition at line 453 of file hashsets.h.

{
        return get (n);
} /* hashedset<element,hashkeys>::operator [] */

◆ pop()

template<class element , class hashkeys >

int_t chomp::homology::hashedset< element, hashkeys >::pop

inline

Removes the last element from the set.

Throws an exception if the set is empty.

Definition at line 588 of file hashsets.h.

{
        if (!nelem)
                throw "Trying to remove an element from an empty set.";
        return removenum (nelem - 1);
} /* hashedset<element,hashkeys>::pop */

◆ push()

template<class element , class hashkeys >

int_t chomp::homology::hashedset< element, hashkeys >::push ( const element & e )

inline

Adds an element to the set (this is an equivalent of 'add').

Definition at line 510 of file hashsets.h.

{
        return add (e);
} /* hashedset<element,hashkeys>::push */

◆ push_back()

template<class element , class hashkeys >

int_t chomp::homology::hashedset< element, hashkeys >::push_back ( const element & e )

inline

Adds an element to the set (this is an equivalent of 'add').

Definition at line 516 of file hashsets.h.

{
        return add (e);
} /* hashedset<element,hashkeys>::push_back */

◆ rehash()

template<class element , class hashkeys >

void chomp::homology::hashedset< element, hashkeys >::rehash ( int_t newsize = 0 )

private

Replace the old hashing table with a new one.

The desired size may be given, otherwise an optimal size is determined and the table is made larger or smaller.

Definition at line 737 of file hashsets.h.

{
        if (stat)
                ++ (stat -> rehashcount);
 
        // adjust the new size of the hashing table
        if ((newsize < (nelem << 1) + InitHashSize) ||
                (newsize > (nelem << 2) + InitHashSize))
                newsize = (nelem << 1) + nelem + InitHashSize;
 
        // DEBUG
//      sbug << "(rehash: nelem=" << nelem <<
//              ", hashsize=" << hashsize << ", newsize=" << newsize << ")\n";
 
        // check if it is not too large for 16-bit programs
        int_t x = 0xFFFF;
        if ((x < 0) && (newsize >= 16384))
                throw "Set too large for this 16-bit program.";
 
        // free unused memory if desired
        if (newsize < hashsize)
        {
                multitable<int_t> empty;
                hashtable = empty;
        }
        
        // set the new value of the hashing table and re-buid it
        hashsize = hashedset<element,hashkeys>::rounduptoprime (newsize);
        hashcleared = 0;
 
        // build the entire hash table from the beginning
        hashtable. fill (-1, hashsize);
        for (int_t i = 0; i < nelem; ++ i)
        {
                int_t pos = hashfind (tab (i));
                if (hashtable (pos) != -1)
                        throw "A repeated element in a set!";
                hashtable [pos] = i;
        }
 
        return;
} /* hashedset<element,hashkeys>::rehash */

References chomp::homology::hashedset< element, hashkeys >::rounduptoprime().

◆ remove() [1/2]

template<class element , class hashkeys >

int chomp::homology::hashedset< element, hashkeys >::remove ( const element & e )

Removes the given element from the set.

Returns 0 if successful, -1 if the element was not in the set.

Definition at line 522 of file hashsets.h.

{
        if (!hashing)
        {
                for (int_t i = 0; i < nelem; ++ i)
                {
                        if (tab (i) == e)
                        {
                                tab [i] = tab (-- nelem);
                                return 0;
                        }
                }
                return -1;
        }
 
        // find the position in the hashing table with this element's number
        int_t pos = hashfind (e);
 
        // if it was not there, then finish
        if (hashtable (pos) < 0)
                return -1;
        int_t n = hashtable (pos);
 
        // update the hashing table and the number of elements in the set
        hashtable [pos] = -2;
        -- nelem;
        ++ hashcleared;
 
        // if it was not the last element in the set, move the last one
        // to the vacated place
        if (n != nelem)
        {
                pos = hashfind (tab (nelem));
                hashtable [pos] = n;
                tab [n] = tab (nelem);
        }
 
        // if there are very few elements in the table, turn off hashing
        if (nelem < StartHashingSize / 2)
        {
                hashing = 0;
        }
 
        // if there are very many cleared entries, then rehash
        else if (hashcleared > nelem + 19)
                rehash ();
 
        return 0;
} /* hashedset<element,hashkeys>::remove */

◆ remove() [2/2]

template<class element , class hashkeys >

hashedset< element, hashkeys > & chomp::homology::hashedset< element, hashkeys >::remove ( const hashedset< element, hashkeys > & s )

Removes an entire set of elements from the set.

Definition at line 605 of file hashsets.h.

{
        if (this -> size () < s. size ())
        {
                for (int_t i = 0; i < this -> size (); ++ i)
                {
                        if (s. check ((*this) [i]))
                                this -> removenum (i --);
                }
        }
        else
        {
                int_t n = s. size ();
                for (int_t i = 0; i < n; ++ i)
                        remove (s [i]);
        }
        return *this;
} /* hashedset<element,hashkeys>::remove */

◆ removenum()

template<class element , class hashkeys >

int chomp::homology::hashedset< element, hashkeys >::removenum ( int_t n )

inline

Returns an element with the given number from the set.

Returns 0 if successful, -1 if the number is out of range.

Definition at line 573 of file hashsets.h.

{
        if ((n < 0) || (n >= nelem))
                return -1;
        if (!hashing)
        {
                -- nelem;
                if (n != nelem)
                        tab [n] = tab (nelem);
                return 0;
        }
        return remove (tab (n));
} /* hashedset<element,hashkeys>::removenum */

◆ rounduptoprime()

template<class element , class hashkeys >

int_t chomp::homology::hashedset< element, hashkeys >::rounduptoprime ( int_t n )

staticprivate

Rounds up the given number to a prime number.

Definition at line 798 of file hashsets.h.

{
        while (!hashedset<element,hashkeys>::numberisprime (n))
                ++ n;
 
        return n;
} /* hashedset<element,hashkeys>::rounduptoprime */

Referenced by chomp::homology::hashedset< element, hashkeys >::hashedset(), and chomp::homology::hashedset< element, hashkeys >::rehash().

◆ size()

template<class element , class hashkeys >

int_t chomp::homology::hashedset< element, hashkeys >::size

inline

Returns the number of elements in the set.

Definition at line 631 of file hashsets.h.

{
        return nelem;
} /* hashedset<element,hashkeys>::size */

◆ swap()

template<class element , class hashkeys >

void chomp::homology::hashedset< element, hashkeys >::swap ( hashedset< element, hashkeys > & other )

inline

Swaps two hashed sets by swapping their internal data.

Definition at line 637 of file hashsets.h.

{
        std::swap (stat, other. stat);
        std::swap (nelem, other. nelem);
        tab. swap (other. tab);
        std::swap (hashing, other. hashing);
        std::swap (hashsize, other. hashsize);
        std::swap (hashcleared, other. hashcleared);
        hashtable. swap (other. hashtable);
        return;
} /* hashedset<element,hashkeys>::swap */

References chomp::multiwork::swap().

◆ top()

template<class element , class hashkeys >

const element & chomp::homology::hashedset< element, hashkeys >::top

inline

Returns the last element in the set.

Definition at line 465 of file hashsets.h.

{
        return get (nelem - 1);
} /* hashedset<element,hashkeys>::top */

Member Data Documentation

◆ hashcleared

template<class element , class hashkeys = HashingGlobal<element>>

int_t chomp::homology::hashedset< element, hashkeys >::hashcleared

private

The number of cleared entries in the hashing table.

Definition at line 314 of file hashsets.h.

◆ hashing

template<class element , class hashkeys = HashingGlobal<element>>

int chomp::homology::hashedset< element, hashkeys >::hashing

private

Is the hashing table in use?

Definition at line 308 of file hashsets.h.

◆ hashsize

template<class element , class hashkeys = HashingGlobal<element>>

int_t chomp::homology::hashedset< element, hashkeys >::hashsize

private

The size of the hashing table.

Definition at line 311 of file hashsets.h.

Referenced by chomp::homology::hashedset< element, hashkeys >::hashedset().

◆ hashtable

template<class element , class hashkeys = HashingGlobal<element>>

multitable<int_t> chomp::homology::hashedset< element, hashkeys >::hashtable

private

The hashing table.

Each entry contains the index of the element in the set, or -1 if the entry is free, or -2 if it was cleared.

Definition at line 318 of file hashsets.h.

◆ InitHashSize

template<class element , class hashkeys >

const int_t chomp::homology::hashedset< element, hashkeys >::InitHashSize

staticprivate

The default initial size of a hashing table.

Definition at line 289 of file hashsets.h.

◆ InitTabSize

template<class element , class hashkeys >

const int_t chomp::homology::hashedset< element, hashkeys >::InitTabSize

staticprivate

The initial size of a table in a hashed set.

Definition at line 292 of file hashsets.h.

◆ nelem

template<class element , class hashkeys = HashingGlobal<element>>

int_t chomp::homology::hashedset< element, hashkeys >::nelem

private

The number of elements stored in the set.

Definition at line 302 of file hashsets.h.

◆ StartHashingSize

template<class element , class hashkeys >

const int_t chomp::homology::hashedset< element, hashkeys >::StartHashingSize

staticprivate

The minimal number of elements above which hashing table is actually used.

If the number of elements is below this threshold, then a simple array is used and elements are searched for by going through all the elements of the array.

Definition at line 299 of file hashsets.h.

◆ stat

template<class element , class hashkeys = HashingGlobal<element>>

hashstat* chomp::homology::hashedset< element, hashkeys >::stat

Hashed set statistics.

Allocate this structure to make the set gather usage and effectiveness statistics. By default this pointer is set to 0. It is deallocated in the destructor.

Definition at line 285 of file hashsets.h.

Referenced by chomp::homology::hashedset< element, hashkeys >::hashedset().

◆ tab

template<class element , class hashkeys = HashingGlobal<element>>

multitable<element> chomp::homology::hashedset< element, hashkeys >::tab

private

The table of these elements.

Definition at line 305 of file hashsets.h.

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

chomp/struct/hashsets.h

Public Types

Public Member Functions

Public Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ hashing_method

◆ value_type

Constructor & Destructor Documentation

◆ hashedset() [1/2]

◆ hashedset() [2/2]

◆ ~hashedset()

Member Function Documentation

◆ add() [1/2]

◆ add() [2/2]

◆ check()

◆ checknum()

◆ empty()

◆ front()

◆ get()

◆ getnumber()

◆ hashfind()

◆ intersection()

◆ numberisprime()

◆ operator=()

◆ operator==()

◆ operator[]()

◆ pop()

◆ push()

◆ push_back()

◆ rehash()

◆ remove() [1/2]

◆ remove() [2/2]

◆ removenum()

◆ rounduptoprime()

◆ size()

◆ swap()

◆ top()

Member Data Documentation

◆ hashcleared

◆ hashing

◆ hashsize

◆ hashtable

◆ InitHashSize

◆ InitTabSize

◆ nelem

◆ StartHashingSize

◆ stat

◆ tab