public int hashCode() {
int h = 0;
for (int i = _pos; i-- > 0; ) {
h += HashFunctions.hash(_data[i]);
}
return h;
}
/**
* @param key the key to be searched in the receiver.
* @return the index where the key is contained in the receiver, else returns -1.
*/
protected int indexOfKey(int key) {
final int tab[] = table;
final byte stat[] = state;
final int length = tab.length;
final int hash = HashFunctions.hash(key) & 0x7FFFFFFF;
int i = hash % length;
int decrement =
hash
% (length
- 2); // double hashing, see
// http://www.eece.unm.edu/faculty/heileman/hash/node4.html
// int decrement = (hash / length) % length;
if (decrement == 0) decrement = 1;
// stop if we find a free slot, or if we find the key itself.
// do skip over removed slots (yes, open addressing is like that...)
// assertion: there is at least one FREE slot.
while (stat[i] != FREE && (stat[i] == REMOVED || tab[i] != key)) {
i -= decrement;
// hashCollisions++;
if (i < 0) i += length;
}
if (stat[i] == FREE) return -1; // not found
return i; // found, return index where key is contained
}
public int hashCode() {
int h = 0;
int i = this._pos;
while (i-- > 0) {
h = 37 * h + HashFunctions.hash(this._data[i]);
}
return h;
}
/**
* Ensure that this hashtable has sufficient capacity to hold <tt>desiredCapacity<tt>
* <b>additional</b> elements without requiring a rehash. This is a tuning method you can call
* before doing a large insert.
*
* @param desiredCapacity an <code>int</code> value
*/
public void ensureCapacity(int desiredCapacity) {
if (desiredCapacity > (_maxSize - size())) {
rehash(
PrimeFinder.nextPrime(
HashFunctions.fastCeil((desiredCapacity + size()) / _loadFactor) + 1));
computeMaxSize(capacity());
}
}
/** {@inheritDoc} */
@Override
public int hashCode() {
int h = 0;
for (int i = size(); i-- > 0; ) {
h += HashFunctions.hash(get(i));
}
return h;
}
/** {@inheritDoc} */
public int hashCode() {
int hashcode = 0;
for (int i = _states.length; i-- > 0; ) {
if (_states[i] == FULL) {
hashcode += HashFunctions.hash(_set[i]);
}
}
return hashcode;
}
/**
* Creates a new <code>THash</code> instance with a prime capacity at or near the minimum needed
* to hold <tt>initialCapacity</tt> elements with load factor <tt>loadFactor</tt> without
* triggering a rehash.
*
* @param initialCapacity an <code>int</code> value
* @param loadFactor a <code>float</code> value
*/
public THash(int initialCapacity, float loadFactor) {
super();
_loadFactor = loadFactor;
// Through testing, the load factor (especially the default load factor) has been
// found to be a pretty good starting auto-compaction factor.
_autoCompactionFactor = loadFactor;
setUp(HashFunctions.fastCeil(initialCapacity / loadFactor));
}
/**
* Compresses the hashtable to the minimum prime size (as defined by PrimeFinder) that will hold
* all of the elements currently in the table. If you have done a lot of <tt>remove</tt>
* operations and plan to do a lot of queries or insertions or iteration, it is a good idea to
* invoke this method. Doing so will accomplish two things:
*
* <ol>
* <li>You'll free memory allocated to the table but no longer needed because of the remove()s.
* <li>You'll get better query/insert/iterator performance because there won't be any
* <tt>REMOVED</tt> slots to skip over when probing for indices in the table.
* </ol>
*/
public void compact() {
// need at least one free spot for open addressing
rehash(PrimeFinder.nextPrime(HashFunctions.fastCeil(size() / _loadFactor) + 1));
computeMaxSize(capacity());
// If auto-compaction is enabled, re-determine the compaction interval
if (_autoCompactionFactor != 0) {
computeNextAutoCompactionAmount(size());
}
}
/**
* @param key the key to be added to the receiver.
* @return the index where the key would need to be inserted, if it is not already contained.
* Returns -index-1 if the key is already contained at slot index. Therefore, if the returned
* index < 0, then it is already contained at slot -index-1. If the returned index >= 0, then
* it is NOT already contained and should be inserted at slot index.
*/
protected int indexOfInsertion(double key) {
final int length = table.length;
final int hash = HashFunctions.hash(key) & 0x7FFFFFFF;
int i = hash % length;
int decrement =
hash
% (length
- 2); // double hashing, see
// http://www.eece.unm.edu/faculty/heileman/hash/node4.html
// int decrement = (hash / length) % length;
if (decrement == 0) {
decrement = 1;
}
// stop if we find a removed or free slot, or if we find the key itself
// do NOT skip over removed slots (yes, open addressing is like that...)
while (state[i] == FULL && table[i] != key) {
i -= decrement;
// hashCollisions++;
if (i < 0) {
i += length;
}
}
if (state[i] == REMOVED) {
// stop if we find a free slot, or if we find the key itself.
// do skip over removed slots (yes, open addressing is like that...)
// assertion: there is at least one FREE slot.
final int j = i;
while (state[i] != FREE && (state[i] == REMOVED || table[i] != key)) {
i -= decrement;
// hashCollisions++;
if (i < 0) {
i += length;
}
}
if (state[i] == FREE) {
i = j;
}
}
if (state[i] == FULL) {
// key already contained at slot i.
// return a negative number identifying the slot.
return -i - 1;
}
// not already contained, should be inserted at slot i.
// return a number >= 0 identifying the slot.
return i;
}
public final boolean execute(float key, int value) {
h += (_hashingStrategy.computeHashCode(key) ^ HashFunctions.hash(value));
return true;
}
public final boolean execute(final int key, final Object value) {
this.h +=
(TIntObjectHashMap.this._hashingStrategy.computeHashCode(key)
^ HashFunctions.hash(value));
return true;
}
