Java PrimeFinder类代码示例

import gnu.trove.impl.PrimeFinder; //导入依赖的package包/类
/**
 * After an insert, this hook is called to adjust the size/free
 * values of the set and to perform rehashing if necessary.
 *
 * @param usedFreeSlot the slot
 */
protected final void postInsertHook( boolean usedFreeSlot ) {
    if ( usedFreeSlot ) {
        _free--;
    }

    // rehash whenever we exhaust the available space in the table
    if ( ++_size > _maxSize || _free == 0 ) {
        // choose a new capacity suited to the new state of the table
        // if we've grown beyond our maximum size, double capacity;
        // if we've exhausted the free spots, rehash to the same capacity,
        // which will free up any stale removed slots for reuse.
        int newCapacity = _size > _maxSize ? PrimeFinder.nextPrime( capacity() << 1 ) : capacity();
        rehash( newCapacity );
        computeMaxSize( capacity() );
    }
}
 

import gnu.trove.impl.PrimeFinder; //导入依赖的package包/类
/**
 * After an insert, this hook is called to adjust the size/free
 * values of the set and to perform rehashing if necessary.
 *
 * @param usedFreeSlot the slot
 */
protected final void postInsertHook(final boolean usedFreeSlot ) {
    if ( usedFreeSlot ) {
        _free--;
    }

    // rehash whenever we exhaust the available space in the table
    if ( ++_size > _maxSize || _free == 0 ) {
        // choose a new capacity suited to the new state of the table
        // if we've grown beyond our maximum size, double capacity;
        // if we've exhausted the free spots, rehash to the same capacity,
        // which will free up any stale removed slots for reuse.
        final int newCapacity = _size > _maxSize ? PrimeFinder.nextPrime( capacity() << 1 ) : capacity();
        rehash( newCapacity );
        computeMaxSize( capacity() );
    }
}
 

import gnu.trove.impl.PrimeFinder; //导入依赖的package包/类
/**
 * After an insert, this hook is called to adjust the size/free
 * values of the set and to perform rehashing if necessary.
 *
 * @param usedFreeSlot the slot
 */
protected final void postInsertHook( boolean usedFreeSlot ) {
	if ( usedFreeSlot ) {
		_free--;
	}

	// rehash whenever we exhaust the available space in the table
	if ( ++_size > _maxSize || _free == 0 ) {
		// choose a new capacity suited to the new state of the table
		// if we've grown beyond our maximum size, double capacity;
		// if we've exhausted the free spots, rehash to the same capacity,
		// which will free up any stale removed slots for reuse.
		int newCapacity = _size > _maxSize ? PrimeFinder.nextPrime( capacity() << 1 ) : capacity();
		rehash( newCapacity );
		computeMaxSize( capacity() );
	}
}
 

import gnu.trove.impl.PrimeFinder; //导入依赖的package包/类
/**
 * initializes the hashtable to a prime capacity which is at least
 * <tt>initialCapacity + 1</tt>.
 *
 * @param initialCapacity an <code>int</code> value
 * @return the actual capacity chosen
 */
protected int setUp( int initialCapacity ) {
    int capacity;

    capacity = PrimeFinder.nextPrime( initialCapacity );
    computeMaxSize( capacity );
    computeNextAutoCompactionAmount( initialCapacity );

    return capacity;
}
 

import gnu.trove.impl.PrimeFinder; //导入依赖的package包/类
/**
 * initializes the hashtable to a prime capacity which is at least
 * <tt>initialCapacity + 1</tt>.
 *
 * @param initialCapacity an <code>int</code> value
 * @return the actual capacity chosen
 */
int setUp(final int initialCapacity) {
    final int capacity;

    capacity = PrimeFinder.nextPrime( initialCapacity );
    computeMaxSize( capacity );
    computeNextAutoCompactionAmount( initialCapacity );

    return capacity;
}
 

import gnu.trove.impl.PrimeFinder; //导入依赖的package包/类
/**
 * 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(Math.max( _size + 1,
           saturatedCast( fastCeil( ( desiredCapacity + _size ) / (double) _loadFactor) + 1 ) ) ) );
        if ( capacity() >= PrimeFinder.largestPrime ) {
            _loadFactor = 1.0f;
        }
        computeMaxSize( capacity() );
    }
}
 

import gnu.trove.impl.PrimeFinder; //导入依赖的package包/类
/**
 * initializes the hashtable to a prime capacity which is at least
 * <tt>initialCapacity + 1</tt>.
 *
 * @param initialCapacity an <code>int</code> value
 * @return the actual capacity chosen
 */
protected int setUp( int initialCapacity ) {
    int capacity;

    capacity = PrimeFinder.nextPrime( initialCapacity );
    if ( capacity >= PrimeFinder.largestPrime ) {
        _loadFactor = 1.0f;
    }
    computeMaxSize( capacity );
    computeNextAutoCompactionAmount( initialCapacity );

    return capacity;
}
 

import gnu.trove.impl.PrimeFinder; //导入依赖的package包/类
public void xxtestMaxHashSetCapacity() throws Exception {
    TIntHashSet full = new TIntHashSet( Integer.MAX_VALUE, 0.5f );
    assertEquals( PrimeFinder.nextPrime( Integer.MAX_VALUE ), full.capacity() );

    int i;
    for (i = 0; full.size() < full.capacity() - 1; i++) {
        full.add(i);
    }

    try {
        full.add(++i);
        fail( "should have failed to add last key" );
    } catch (IllegalStateException ignored) {
    }
}
 

import gnu.trove.impl.PrimeFinder; //导入依赖的package包/类
/**
 * 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(Math.max( _size + 1,
			saturatedCast( fastCeil( ( desiredCapacity + _size ) / (double) _loadFactor) + 1 ) ) ) );
		if ( capacity() >= PrimeFinder.largestPrime ) {
			_loadFactor = 1.0f;
		}
		computeMaxSize( capacity() );
	}
}
 

import gnu.trove.impl.PrimeFinder; //导入依赖的package包/类
private void compactToSize(int targetCapacity) {
	// need at least one free spot for open addressing
	rehash( PrimeFinder.nextPrime( Math.max( targetCapacity + 1,
		saturatedCast( fastCeil( targetCapacity / (double) _loadFactor ) + 1 ) ) ) );
	computeMaxSize( capacity() );

	// If auto-compaction is enabled, re-determine the compaction interval
	if ( _autoCompactionFactor != 0 ) {
		computeNextAutoCompactionAmount( size() );
	}
}
 

import gnu.trove.impl.PrimeFinder; //导入依赖的package包/类
/**
 * initializes the hashtable to a prime capacity which is at least
 * <tt>initialCapacity + 1</tt>.
 *
 * @param initialCapacity an <code>int</code> value
 * @return the actual capacity chosen
 */
protected int setUp( int initialCapacity ) {
	int capacity;

	capacity = PrimeFinder.nextPrime( initialCapacity );
	if ( capacity >= PrimeFinder.largestPrime ) {
		_loadFactor = 1.0f;
	}
	computeMaxSize( capacity );
	computeNextAutoCompactionAmount( initialCapacity );

	return capacity;
}
 

import gnu.trove.impl.PrimeFinder; //导入依赖的package包/类
public void testPrimeFinder() throws Exception {
    int r = PrimeFinder.nextPrime(999999);
    assertEquals(1070981,r);
}
 

import gnu.trove.impl.PrimeFinder; //导入依赖的package包/类
public void testLargeCapacity() {
    final int twentyFourBitPrime = PrimeFinder.nextPrime( 1 << 24 );
    TByteHashSet set = new TByteHashSet( twentyFourBitPrime + 1, 1.0f );

    assertTrue( "capacity was not large enough to hold desired elements" , set.capacity() > twentyFourBitPrime );
}
 

import gnu.trove.impl.PrimeFinder; //导入依赖的package包/类
public void testMaxValue() throws Exception {
    int r = PrimeFinder.nextPrime(Integer.MAX_VALUE);
    assertEquals(2004663929, r);
}