{
private final static int NOT_CACHED = 0;
private final static int CACHED = 1;
private final static int AT_END = 2;
/** Current iterator state. */
private int state = NOT_CACHED;
/**
* The next element to be returned from {@link #next()} if
* fetched.
*/
private E nextElement;
/**
* {@inheritDoc}
*/
@Override
public boolean hasNext()
{
if (state == NOT_CACHED)
{
state = CACHED;
nextElement = fetch();
}
return state == CACHED;
}
/**
* {@inheritDoc}
*/
@Override
public E next()
{
if (!hasNext())
throw new NoSuchElementException();
state = NOT_CACHED;
return nextElement;
}
/**
* Default implementation throws {@link UnsupportedOperationException}.
*/
@Override
public void remove()
{
throw new UnsupportedOperationException();
}
/**
* Fetch next element. The implementation must
* return {@link #done()} when all elements have been
* fetched.
*/
protected abstract E fetch();
/**
* Call when done.
*/
protected final E done()
{
state = AT_END;
return null;
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/ArraySizingStrategy.java 0000664 0000000 0000000 00000002211 12403265743 0030006 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc;
/**
* Resizing (growth) strategy for array-backed buffers.
*/
public interface ArraySizingStrategy
{
/**
* Array sizing strategies may require that the initial size fulfills
* certain constraints (is a prime or a power of two, for example). This
* method must return the first size that fulfills these conditions
* and is greater or equal to capacity.
*/
int round(int capacity);
/**
* @param currentBufferLength Current size of the array (buffer). This number
* should comply with the strategy's policies (it is a result of initial rounding
* or further growths). It can also be zero, indicating the growth from an empty
* buffer.
*
* @param elementsCount Number of elements stored in the buffer.
*
* @param expectedAdditions Expected number of additions (resize hint).
*
* @return Must return a new size at least as big as to hold
* elementsCount + expectedAdditions.
*/
int grow(int currentBufferLength, int elementsCount, int expectedAdditions);
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/BitSet.java 0000664 0000000 0000000 00000074612 12403265743 0025231 0 ustar 00root root 0000000 0000000 /*
* Repackaged from org.apache.lucene.util.OpenBitSet (Lucene).
* svn rev. 1479633, https://svn.apache.org/repos/asf/lucene/dev/trunk
*
* Minor changes in class hierarchy, removed serialization and several methods.
* Added container adapters.
*/
/**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.carrotsearch.hppc;
import java.util.*;
import com.carrotsearch.hppc.cursors.IntCursor;
import com.carrotsearch.hppc.cursors.LongCursor;
import com.carrotsearch.hppc.predicates.IntPredicate;
import com.carrotsearch.hppc.predicates.LongPredicate;
import com.carrotsearch.hppc.procedures.IntProcedure;
import com.carrotsearch.hppc.procedures.LongProcedure;
/**
* An "open" BitSet implementation that allows direct access to the array of words storing
* the bits.
*
* Unlike java.util.bitset, the fact that bits are packed into an array of longs is part
* of the interface. This allows efficient implementation of other algorithms by someone
* other than the author. It also allows one to efficiently implement alternate
* serialization or interchange formats.
*
* The index range for a bitset can easily exceed positive int range in Java
* (0x7fffffff), so many methods in this class accept or return a long. There
* are adapter methods that return views compatible with
* {@link LongLookupContainer} and {@link IntLookupContainer} interfaces.
*
* @see #asIntLookupContainer()
* @see #asLongLookupContainer()
*
* @author "Original implementation from the Lucene project."
*/
public class BitSet implements Cloneable
{
/**
* The initial default number of bits ({@value #DEFAULT_NUM_BITS}).
*/
private static final long DEFAULT_NUM_BITS = 64;
/**
* Internal representation of bits in this bit set.
*/
public long [] bits;
/**
* The number of words (longs) used in the {@link #bits} array.
*/
public int wlen;
/**
* Constructs a bit set with the default capacity.
*/
public BitSet()
{
this(DEFAULT_NUM_BITS);
}
/**
* Constructs an BitSet large enough to hold numBits.
*/
public BitSet(long numBits)
{
bits = new long [bits2words(numBits)];
wlen = bits.length;
}
/**
* Constructs an BitSet from an existing long[].
* The first 64 bits are in long[0], with bit index 0 at the least significant bit,
* and bit index 63 at the most significant. Given a bit index, the word containing it
* is long[index/64], and it is at bit number index%64 within that word.
*
* numWords are the number of elements in the array that contain set bits (non-zero
* longs). numWords should be <= bits.length, and any existing words in the array at
* position >= numWords should be zero.
*/
public BitSet(long [] bits, int numWords)
{
this.bits = bits;
this.wlen = numWords;
}
/**
* Static constructor-like method similar to other (generic) collections.
*/
public static BitSet newInstance()
{
return new BitSet();
}
/**
* @return Returns an iterator over all set bits of this bitset. The iterator should
* be faster than using a loop around {@link #nextSetBit(int)}.
*/
public BitSetIterator iterator()
{
return new BitSetIterator(bits, wlen);
}
/**
* Returns the current capacity in bits (1 greater than the index of the last bit).
*/
public long capacity()
{
return bits.length << 6;
}
/**
* Returns the current capacity of this set. Included for compatibility. This is not
* equal to {@link #cardinality}.
*
* @see #cardinality()
* @see java.util.BitSet#size()
*/
public long size()
{
return capacity();
}
/**
* @see java.util.BitSet#length()
*/
public long length()
{
trimTrailingZeros();
if (wlen == 0) return 0;
return (((long) wlen - 1) << 6)
+ (64 - Long.numberOfLeadingZeros(bits[wlen - 1]));
}
/**
* Returns true if there are no set bits
*/
public boolean isEmpty()
{
return cardinality() == 0;
}
/**
* Returns true or false for the specified bit index.
*/
public boolean get(int index)
{
int i = index >> 6; // div 64
// signed shift will keep a negative index and force an
// array-index-out-of-bounds-exception, removing the need for an explicit check.
if (i >= bits.length) return false;
int bit = index & 0x3f; // mod 64
long bitmask = 1L << bit;
return (bits[i] & bitmask) != 0;
}
/**
* Returns true or false for the specified bit index.
*/
public boolean get(long index)
{
int i = (int) (index >> 6); // div 64
if (i >= bits.length) return false;
int bit = (int) index & 0x3f; // mod 64
long bitmask = 1L << bit;
return (bits[i] & bitmask) != 0;
}
/**
* Sets a bit, expanding the set size if necessary.
*/
public void set(long index)
{
int wordNum = expandingWordNum(index);
int bit = (int) index & 0x3f;
long bitmask = 1L << bit;
bits[wordNum] |= bitmask;
}
/**
* Sets a range of bits, expanding the set size if necessary
*
* @param startIndex lower index
* @param endIndex one-past the last bit to set
*/
public void set(long startIndex, long endIndex)
{
if (endIndex <= startIndex) return;
int startWord = (int) (startIndex >> 6);
// since endIndex is one past the end, this is index of the last
// word to be changed.
int endWord = expandingWordNum(endIndex - 1);
long startmask = -1L << startIndex;
long endmask = -1L >>> -endIndex; // 64-(endIndex&0x3f) is the same as -endIndex
// due to wrap
if (startWord == endWord)
{
bits[startWord] |= (startmask & endmask);
return;
}
bits[startWord] |= startmask;
Arrays.fill(bits, startWord + 1, endWord, -1L);
bits[endWord] |= endmask;
}
protected int expandingWordNum(long index)
{
int wordNum = (int) (index >> 6);
if (wordNum >= wlen)
{
ensureCapacity(index + 1);
wlen = wordNum + 1;
}
return wordNum;
}
/** Clears all bits. */
public void clear()
{
Arrays.fill(bits, 0);
this.wlen = 0;
}
/**
* clears a bit, allowing access beyond the current set size without changing the
* size.
*/
public void clear(long index)
{
int wordNum = (int) (index >> 6); // div 64
if (wordNum >= wlen) return;
int bit = (int) index & 0x3f; // mod 64
long bitmask = 1L << bit;
bits[wordNum] &= ~bitmask;
}
/**
* Clears a range of bits. Clearing past the end does not change the size of the set.
*
* @param startIndex lower index
* @param endIndex one-past the last bit to clear
*/
public void clear(int startIndex, int endIndex)
{
if (endIndex <= startIndex) return;
int startWord = (startIndex >> 6);
if (startWord >= wlen) return;
// since endIndex is one past the end, this is index of the last
// word to be changed.
int endWord = ((endIndex - 1) >> 6);
long startmask = -1L << startIndex;
long endmask = -1L >>> -endIndex; // 64-(endIndex&0x3f) is the same as -endIndex
// due to wrap
// invert masks since we are clearing
startmask = ~startmask;
endmask = ~endmask;
if (startWord == endWord)
{
bits[startWord] &= (startmask | endmask);
return;
}
bits[startWord] &= startmask;
int middle = Math.min(wlen, endWord);
Arrays.fill(bits, startWord + 1, middle, 0L);
if (endWord < wlen)
{
bits[endWord] &= endmask;
}
}
/**
* Clears a range of bits. Clearing past the end does not change the size of the set.
*
* @param startIndex lower index
* @param endIndex one-past the last bit to clear
*/
public void clear(long startIndex, long endIndex)
{
if (endIndex <= startIndex) return;
int startWord = (int) (startIndex >> 6);
if (startWord >= wlen) return;
// since endIndex is one past the end, this is index of the last
// word to be changed.
int endWord = (int) ((endIndex - 1) >> 6);
long startmask = -1L << startIndex;
long endmask = -1L >>> -endIndex; // 64-(endIndex&0x3f) is the same as -endIndex
// due to wrap
// invert masks since we are clearing
startmask = ~startmask;
endmask = ~endmask;
if (startWord == endWord)
{
bits[startWord] &= (startmask | endmask);
return;
}
bits[startWord] &= startmask;
int middle = Math.min(wlen, endWord);
Arrays.fill(bits, startWord + 1, middle, 0L);
if (endWord < wlen)
{
bits[endWord] &= endmask;
}
}
/**
* Sets a bit and returns the previous value. The index should be less than the BitSet
* size.
*/
public boolean getAndSet(int index)
{
int wordNum = index >> 6; // div 64
int bit = index & 0x3f; // mod 64
long bitmask = 1L << bit;
boolean val = (bits[wordNum] & bitmask) != 0;
bits[wordNum] |= bitmask;
return val;
}
/**
* Sets a bit and returns the previous value. The index should be less than the BitSet
* size.
*/
public boolean getAndSet(long index)
{
int wordNum = (int) (index >> 6); // div 64
int bit = (int) index & 0x3f; // mod 64
long bitmask = 1L << bit;
boolean val = (bits[wordNum] & bitmask) != 0;
bits[wordNum] |= bitmask;
return val;
}
/**
* Flips a bit, expanding the set size if necessary.
*/
public void flip(long index)
{
int wordNum = expandingWordNum(index);
int bit = (int) index & 0x3f; // mod 64
long bitmask = 1L << bit;
bits[wordNum] ^= bitmask;
}
/**
* flips a bit and returns the resulting bit value. The index should be less than the
* BitSet size.
*/
public boolean flipAndGet(int index)
{
int wordNum = index >> 6; // div 64
int bit = index & 0x3f; // mod 64
long bitmask = 1L << bit;
bits[wordNum] ^= bitmask;
return (bits[wordNum] & bitmask) != 0;
}
/**
* flips a bit and returns the resulting bit value. The index should be less than the
* BitSet size.
*/
public boolean flipAndGet(long index)
{
int wordNum = (int) (index >> 6); // div 64
int bit = (int) index & 0x3f; // mod 64
long bitmask = 1L << bit;
bits[wordNum] ^= bitmask;
return (bits[wordNum] & bitmask) != 0;
}
/**
* Flips a range of bits, expanding the set size if necessary
*
* @param startIndex lower index
* @param endIndex one-past the last bit to flip
*/
public void flip(long startIndex, long endIndex)
{
if (endIndex <= startIndex) return;
int startWord = (int) (startIndex >> 6);
// since endIndex is one past the end, this is index of the last
// word to be changed.
int endWord = expandingWordNum(endIndex - 1);
long startmask = -1L << startIndex;
long endmask = -1L >>> -endIndex; // 64-(endIndex&0x3f) is the same as -endIndex
// due to wrap
if (startWord == endWord)
{
bits[startWord] ^= (startmask & endmask);
return;
}
bits[startWord] ^= startmask;
for (int i = startWord + 1; i < endWord; i++)
{
bits[i] = ~bits[i];
}
bits[endWord] ^= endmask;
}
/** @return the number of set bits */
public long cardinality()
{
return BitUtil.pop_array(bits, 0, wlen);
}
/**
* Returns the popcount or cardinality of the intersection of the two sets. Neither
* set is modified.
*/
public static long intersectionCount(BitSet a, BitSet b)
{
return BitUtil.pop_intersect(a.bits, b.bits, 0, Math.min(a.wlen, b.wlen));
}
/**
* Returns the popcount or cardinality of the union of the two sets. Neither set is
* modified.
*/
public static long unionCount(BitSet a, BitSet b)
{
long tot = BitUtil.pop_union(a.bits, b.bits, 0, Math.min(a.wlen, b.wlen));
if (a.wlen < b.wlen)
{
tot += BitUtil.pop_array(b.bits, a.wlen, b.wlen - a.wlen);
}
else if (a.wlen > b.wlen)
{
tot += BitUtil.pop_array(a.bits, b.wlen, a.wlen - b.wlen);
}
return tot;
}
/**
* Returns the popcount or cardinality of "a and not b" or "intersection(a, not(b))".
* Neither set is modified.
*/
public static long andNotCount(BitSet a, BitSet b)
{
long tot = BitUtil.pop_andnot(a.bits, b.bits, 0, Math.min(a.wlen, b.wlen));
if (a.wlen > b.wlen)
{
tot += BitUtil.pop_array(a.bits, b.wlen, a.wlen - b.wlen);
}
return tot;
}
/**
* Returns the popcount or cardinality of the exclusive-or of the two sets. Neither
* set is modified.
*/
public static long xorCount(BitSet a, BitSet b)
{
long tot = BitUtil.pop_xor(a.bits, b.bits, 0, Math.min(a.wlen, b.wlen));
if (a.wlen < b.wlen)
{
tot += BitUtil.pop_array(b.bits, a.wlen, b.wlen - a.wlen);
}
else if (a.wlen > b.wlen)
{
tot += BitUtil.pop_array(a.bits, b.wlen, a.wlen - b.wlen);
}
return tot;
}
/**
* Returns the index of the first set bit starting at the index specified. -1 is
* returned if there are no more set bits.
*/
public int nextSetBit(int index)
{
int i = index >> 6;
if (i >= wlen) return -1;
int subIndex = index & 0x3f; // index within the word
long word = bits[i] >> subIndex; // skip all the bits to the right of index
if (word != 0)
{
return (i << 6) + subIndex + Long.numberOfTrailingZeros(word);
}
while (++i < wlen)
{
word = bits[i];
if (word != 0) return (i << 6) + Long.numberOfTrailingZeros(word);
}
return -1;
}
/**
* Returns the index of the first set bit starting at the index specified. -1 is
* returned if there are no more set bits.
*/
public long nextSetBit(long index)
{
int i = (int) (index >>> 6);
if (i >= wlen) return -1;
int subIndex = (int) index & 0x3f; // index within the word
long word = bits[i] >>> subIndex; // skip all the bits to the right of index
if (word != 0)
{
return (((long) i) << 6) + (subIndex + Long.numberOfTrailingZeros(word));
}
while (++i < wlen)
{
word = bits[i];
if (word != 0) return (((long) i) << 6) + Long.numberOfTrailingZeros(word);
}
return -1;
}
@Override
public Object clone()
{
try
{
BitSet obs = (BitSet) super.clone();
obs.bits = (long []) obs.bits.clone(); // hopefully an array clone is as
// fast(er) than arraycopy
return obs;
}
catch (CloneNotSupportedException e)
{
throw new RuntimeException(e);
}
}
/** this = this AND other */
public void intersect(BitSet other)
{
int newLen = Math.min(this.wlen, other.wlen);
long [] thisArr = this.bits;
long [] otherArr = other.bits;
// testing against zero can be more efficient
int pos = newLen;
while (--pos >= 0)
{
thisArr[pos] &= otherArr[pos];
}
if (this.wlen > newLen)
{
// fill zeros from the new shorter length to the old length
Arrays.fill(bits, newLen, this.wlen, 0);
}
this.wlen = newLen;
}
/** this = this OR other */
public void union(BitSet other)
{
int newLen = Math.max(wlen, other.wlen);
ensureCapacityWords(newLen);
long [] thisArr = this.bits;
long [] otherArr = other.bits;
int pos = Math.min(wlen, other.wlen);
while (--pos >= 0)
{
thisArr[pos] |= otherArr[pos];
}
if (this.wlen < newLen)
{
System.arraycopy(otherArr, this.wlen, thisArr, this.wlen, newLen - this.wlen);
}
this.wlen = newLen;
}
/** Remove all elements set in other. this = this AND_NOT other */
public void remove(BitSet other)
{
int idx = Math.min(wlen, other.wlen);
long [] thisArr = this.bits;
long [] otherArr = other.bits;
while (--idx >= 0)
{
thisArr[idx] &= ~otherArr[idx];
}
}
/** this = this XOR other */
public void xor(BitSet other)
{
int newLen = Math.max(wlen, other.wlen);
ensureCapacityWords(newLen);
long [] thisArr = this.bits;
long [] otherArr = other.bits;
int pos = Math.min(wlen, other.wlen);
while (--pos >= 0)
{
thisArr[pos] ^= otherArr[pos];
}
if (this.wlen < newLen)
{
System.arraycopy(otherArr, this.wlen, thisArr, this.wlen, newLen - this.wlen);
}
this.wlen = newLen;
}
// some BitSet compatibility methods
// ** see {@link intersect} */
public void and(BitSet other)
{
intersect(other);
}
// ** see {@link union} */
public void or(BitSet other)
{
union(other);
}
// ** see {@link andNot} */
public void andNot(BitSet other)
{
remove(other);
}
/** returns true if the sets have any elements in common */
public boolean intersects(BitSet other)
{
int pos = Math.min(this.wlen, other.wlen);
long [] thisArr = this.bits;
long [] otherArr = other.bits;
while (--pos >= 0)
{
if ((thisArr[pos] & otherArr[pos]) != 0) return true;
}
return false;
}
/**
* Expand the long[] with the size given as a number of words (64 bit longs).
* getNumWords() is unchanged by this call.
*/
public void ensureCapacityWords(int numWords)
{
if (bits.length < numWords)
{
bits = grow(bits, numWords);
}
}
public static long [] grow(long [] array, int minSize)
{
if (array.length < minSize)
{
long [] newArray = new long [getNextSize(minSize)];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
else return array;
}
public static int getNextSize(int targetSize)
{
/*
* This over-allocates proportional to the list size, making room for additional
* growth. The over-allocation is mild, but is enough to give linear-time
* amortized behavior over a long sequence of appends() in the presence of a
* poorly-performing system realloc(). The growth pattern is: 0, 4, 8, 16, 25, 35,
* 46, 58, 72, 88, ...
*/
return (targetSize >> 3) + (targetSize < 9 ? 3 : 6) + targetSize;
}
/**
* Ensure that the long[] is big enough to hold numBits, expanding it if necessary.
* getNumWords() is unchanged by this call.
*/
public void ensureCapacity(long numBits)
{
ensureCapacityWords(bits2words(numBits));
}
/**
* Lowers {@link #wlen}, the number of words in use, by checking for trailing zero
* words.
*/
public void trimTrailingZeros()
{
int idx = wlen - 1;
while (idx >= 0 && bits[idx] == 0)
idx--;
wlen = idx + 1;
}
/** returns the number of 64 bit words it would take to hold numBits */
public static int bits2words(long numBits)
{
return (int) (((numBits - 1) >>> 6) + 1);
}
/** returns true if both sets have the same bits set */
@Override
public boolean equals(Object o)
{
if (this == o) return true;
if (!(o instanceof BitSet)) return false;
BitSet a;
BitSet b = (BitSet) o;
// make a the larger set.
if (b.wlen > this.wlen)
{
a = b;
b = this;
}
else
{
a = this;
}
// check for any set bits out of the range of b
for (int i = a.wlen - 1; i >= b.wlen; i--)
{
if (a.bits[i] != 0) return false;
}
for (int i = b.wlen - 1; i >= 0; i--)
{
if (a.bits[i] != b.bits[i]) return false;
}
return true;
}
@Override
public int hashCode()
{
// Start with a zero hash and use a mix that results in zero if the input is zero.
// This effectively truncates trailing zeros without an explicit check.
long h = 0;
for (int i = bits.length; --i >= 0;)
{
h ^= bits[i];
h = (h << 1) | (h >>> 63); // rotate left
}
// fold leftmost bits into right and add a constant to prevent
// empty sets from returning 0, which is too common.
return (int) ((h >> 32) ^ h) + 0x98761234;
}
@Override
public String toString()
{
long bit = nextSetBit(0);
if (bit < 0)
{
return "{}";
}
final StringBuilder builder = new StringBuilder();
builder.append("{");
builder.append(Long.toString(bit));
while ((bit = nextSetBit(bit + 1)) >= 0)
{
builder.append(", ");
builder.append(Long.toString(bit));
}
builder.append("}");
return builder.toString();
}
/**
* Returns a view over this bitset data compatible with {@link IntLookupContainer}. A new
* object is always returned, but its methods reflect the current state of the bitset
* (the view is not a snapshot).
*
*
Methods of the returned {@link IntLookupContainer} may throw a {@link RuntimeException}
* if the cardinality of this bitset exceeds the int range.
*/
public IntLookupContainer asIntLookupContainer()
{
return new IntLookupContainer()
{
@Override
public int size()
{
return getCurrentCardinality();
}
@Override
public boolean isEmpty()
{
return BitSet.this.isEmpty();
}
@Override
public Iterator iterator()
{
return new Iterator() {
private long nextBitSet = BitSet.this.nextSetBit(0);
private final IntCursor cursor = new IntCursor();
@Override
public boolean hasNext()
{
return nextBitSet >= 0;
}
@Override
public IntCursor next()
{
final long value = nextBitSet;
if (value < 0) throw new NoSuchElementException();
if (value > Integer.MAX_VALUE)
throw new RuntimeException("BitSet range larger than maximum positive integer.");
nextBitSet = BitSet.this.nextSetBit(value + 1);
cursor.index = cursor.value = (int) value;
return cursor;
}
@Override
public void remove()
{
throw new UnsupportedOperationException();
}
};
}
@Override
public int [] toArray()
{
final int [] data = new int [getCurrentCardinality()];
final BitSetIterator i = BitSet.this.iterator();
for (int j = 0, bit = i.nextSetBit(); bit >= 0; bit = i.nextSetBit())
{
data[j++] = bit;
}
return data;
}
@Override
public T forEach(T predicate)
{
final BitSetIterator i = BitSet.this.iterator();
for (int bit = i.nextSetBit(); bit >= 0; bit = i.nextSetBit())
{
if (predicate.apply(bit) == false)
break;
}
return predicate;
}
@Override
public T forEach(T procedure)
{
final BitSetIterator i = BitSet.this.iterator();
for (int bit = i.nextSetBit(); bit >= 0; bit = i.nextSetBit())
{
procedure.apply(bit);
}
return procedure;
}
@Override
public boolean contains(int index)
{
return index < 0 || BitSet.this.get(index);
}
/**
* Rounds the bitset's cardinality to an integer or throws a
* {@link RuntimeException} if the cardinality exceeds maximum int range.
*/
private int getCurrentCardinality()
{
long cardinality = BitSet.this.cardinality();
if (cardinality > Integer.MAX_VALUE)
throw new RuntimeException("Bitset is larger than maximum positive integer: "
+ cardinality);
return (int) cardinality;
}
};
}
/**
* Returns a view over this bitset data compatible with {@link LongLookupContainer}. A new
* object is always returned, but its methods reflect the current state of the bitset
* (the view is not a snapshot).
*/
public LongLookupContainer asLongLookupContainer()
{
return new LongLookupContainer()
{
@Override
public int size()
{
return getCurrentCardinality();
}
@Override
public boolean isEmpty()
{
return BitSet.this.isEmpty();
}
@Override
public Iterator iterator()
{
return new Iterator() {
private long nextBitSet = BitSet.this.nextSetBit(0);
private final LongCursor cursor = new LongCursor();
@Override
public boolean hasNext()
{
return nextBitSet >= 0;
}
@Override
public LongCursor next()
{
final long value = nextBitSet;
if (value < 0) throw new NoSuchElementException();
nextBitSet = BitSet.this.nextSetBit(value + 1);
cursor.index = (int) value;
cursor.value = value;
return cursor;
}
@Override
public void remove()
{
throw new UnsupportedOperationException();
}
};
}
@Override
public long [] toArray()
{
final long [] data = new long [getCurrentCardinality()];
final BitSet bset = BitSet.this;
int j = 0;
for (long bit = bset.nextSetBit((long) 0); bit >= 0; bit = bset.nextSetBit(bit + 1))
{
data[j++] = bit;
}
return data;
}
@Override
public T forEach(T predicate)
{
final BitSet bset = BitSet.this;
for (long bit = bset.nextSetBit((long) 0); bit >= 0; bit = bset.nextSetBit(bit + 1))
{
if (predicate.apply(bit) == false)
break;
}
return predicate;
}
@Override
public T forEach(T procedure)
{
final BitSet bset = BitSet.this;
for (long bit = bset.nextSetBit((long) 0); bit >= 0; bit = bset.nextSetBit(bit + 1))
{
procedure.apply(bit);
}
return procedure;
}
@Override
public boolean contains(long index)
{
return index < 0 || BitSet.this.get(index);
}
/**
* Rounds the bitset's cardinality to an integer or throws a
* {@link RuntimeException} if the cardinality exceeds maximum int range.
*/
private int getCurrentCardinality()
{
long cardinality = BitSet.this.cardinality();
if (cardinality > Integer.MAX_VALUE)
throw new RuntimeException("Bitset is larger than maximum positive integer: "
+ cardinality);
return (int) cardinality;
}
};
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/BitSetIterator.java 0000664 0000000 0000000 00000014205 12403265743 0026733 0 ustar 00root root 0000000 0000000
/*
* Repackaged from org.apache.lucene.util.OpenBitSet (Lucene).
* svn rev. 893130, http://svn.apache.org/repos/asf/lucene/java/trunk/
*
* Minor changes in class hierarchy, removed serialization.
*/
/**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.carrotsearch.hppc;
/**
* An iterator to iterate over set bits in an BitSet. This is faster than nextSetBit() for
* iterating over the complete set of bits, especially when the density of the bits set is
* high.
*/
public class BitSetIterator {
// The General Idea: instead of having an array per byte that has
// the offsets of the next set bit, that array could be
// packed inside a 32 bit integer (8 4 bit numbers). That
// should be faster than accessing an array for each index, and
// the total array size is kept smaller (256*sizeof(int))=1K
final static int[] bitlist={
0x0, 0x1, 0x2, 0x21, 0x3, 0x31, 0x32, 0x321, 0x4, 0x41, 0x42, 0x421, 0x43,
0x431, 0x432, 0x4321, 0x5, 0x51, 0x52, 0x521, 0x53, 0x531, 0x532, 0x5321,
0x54, 0x541, 0x542, 0x5421, 0x543, 0x5431, 0x5432, 0x54321, 0x6, 0x61, 0x62,
0x621, 0x63, 0x631, 0x632, 0x6321, 0x64, 0x641, 0x642, 0x6421, 0x643,
0x6431, 0x6432, 0x64321, 0x65, 0x651, 0x652, 0x6521, 0x653, 0x6531, 0x6532,
0x65321, 0x654, 0x6541, 0x6542, 0x65421, 0x6543, 0x65431, 0x65432, 0x654321,
0x7, 0x71, 0x72, 0x721, 0x73, 0x731, 0x732, 0x7321, 0x74, 0x741, 0x742,
0x7421, 0x743, 0x7431, 0x7432, 0x74321, 0x75, 0x751, 0x752, 0x7521, 0x753,
0x7531, 0x7532, 0x75321, 0x754, 0x7541, 0x7542, 0x75421, 0x7543, 0x75431,
0x75432, 0x754321, 0x76, 0x761, 0x762, 0x7621, 0x763, 0x7631, 0x7632,
0x76321, 0x764, 0x7641, 0x7642, 0x76421, 0x7643, 0x76431, 0x76432, 0x764321,
0x765, 0x7651, 0x7652, 0x76521, 0x7653, 0x76531, 0x76532, 0x765321, 0x7654,
0x76541, 0x76542, 0x765421, 0x76543, 0x765431, 0x765432, 0x7654321, 0x8,
0x81, 0x82, 0x821, 0x83, 0x831, 0x832, 0x8321, 0x84, 0x841, 0x842, 0x8421,
0x843, 0x8431, 0x8432, 0x84321, 0x85, 0x851, 0x852, 0x8521, 0x853, 0x8531,
0x8532, 0x85321, 0x854, 0x8541, 0x8542, 0x85421, 0x8543, 0x85431, 0x85432,
0x854321, 0x86, 0x861, 0x862, 0x8621, 0x863, 0x8631, 0x8632, 0x86321, 0x864,
0x8641, 0x8642, 0x86421, 0x8643, 0x86431, 0x86432, 0x864321, 0x865, 0x8651,
0x8652, 0x86521, 0x8653, 0x86531, 0x86532, 0x865321, 0x8654, 0x86541,
0x86542, 0x865421, 0x86543, 0x865431, 0x865432, 0x8654321, 0x87, 0x871,
0x872, 0x8721, 0x873, 0x8731, 0x8732, 0x87321, 0x874, 0x8741, 0x8742,
0x87421, 0x8743, 0x87431, 0x87432, 0x874321, 0x875, 0x8751, 0x8752, 0x87521,
0x8753, 0x87531, 0x87532, 0x875321, 0x8754, 0x87541, 0x87542, 0x875421,
0x87543, 0x875431, 0x875432, 0x8754321, 0x876, 0x8761, 0x8762, 0x87621,
0x8763, 0x87631, 0x87632, 0x876321, 0x8764, 0x87641, 0x87642, 0x876421,
0x87643, 0x876431, 0x876432, 0x8764321, 0x8765, 0x87651, 0x87652, 0x876521,
0x87653, 0x876531, 0x876532, 0x8765321, 0x87654, 0x876541, 0x876542,
0x8765421, 0x876543, 0x8765431, 0x8765432, 0x87654321
};
/***** the python code that generated bitlist
def bits2int(val):
arr=0
for shift in range(8,0,-1):
if val & 0x80:
arr = (arr << 4) | shift
val = val << 1
return arr
def int_table():
tbl = [ hex(bits2int(val)).strip('L') for val in range(256) ]
return ','.join(tbl)
******/
// hmmm, what about an iterator that finds zeros though,
// or a reverse iterator... should they be separate classes
// for efficiency, or have a common root interface? (or
// maybe both? could ask for a SetBitsIterator, etc...
private final long[] arr;
private final int words;
private int i=-1;
private long word;
private int wordShift;
private int indexArray;
public BitSetIterator(BitSet obs) {
this(obs.bits, obs.wlen);
}
public BitSetIterator(long[] bits, int numWords) {
arr = bits;
words = numWords;
}
// 64 bit shifts
private void shift() {
if ((int)word ==0) {wordShift +=32; word = word >>>32; }
if ((word & 0x0000FFFF) == 0) { wordShift +=16; word >>>=16; }
if ((word & 0x000000FF) == 0) { wordShift +=8; word >>>=8; }
indexArray = bitlist[(int)word & 0xff];
}
/***** alternate shift implementations
// 32 bit shifts, but a long shift needed at the end
private void shift2() {
int y = (int)word;
if (y==0) {wordShift +=32; y = (int)(word >>>32); }
if ((y & 0x0000FFFF) == 0) { wordShift +=16; y>>>=16; }
if ((y & 0x000000FF) == 0) { wordShift +=8; y>>>=8; }
indexArray = bitlist[y & 0xff];
word >>>= (wordShift +1);
}
private void shift3() {
int lower = (int)word;
int lowByte = lower & 0xff;
if (lowByte != 0) {
indexArray=bitlist[lowByte];
return;
}
shift();
}
******/
public final static int NO_MORE = -1;
public int nextSetBit() {
if (indexArray == 0) {
if (word != 0) {
word >>>= 8;
wordShift += 8;
}
while (word == 0) {
if (++i >= words) {
return NO_MORE;
}
word = arr[i];
wordShift = -1; // loop invariant code motion should move this
}
// after the first time, should I go with a linear search, or
// stick with the binary search in shift?
shift();
}
int bitIndex = (indexArray & 0x0f) + wordShift;
indexArray >>>= 4;
// should i<<6 be cached as a separate variable?
// it would only save one cycle in the best circumstances.
return (i<<6) + bitIndex;
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/BitUtil.java 0000664 0000000 0000000 00000007300 12403265743 0025401 0 ustar 00root root 0000000 0000000
/*
* Repackaged from org.apache.lucene.util.OpenBitSet (Lucene).
* svn rev. 1479633, https://svn.apache.org/repos/asf/lucene/dev/trunk
*
* Minor changes in class hierarchy, removed serialization.
*/
/**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.carrotsearch.hppc;
/**
* A variety of high efficiency bit twiddling routines.
*/
final class BitUtil {
private BitUtil() {} // no instance
// The pop methods used to rely on bit-manipulation tricks for speed but it
// turns out that it is faster to use the Long.bitCount method (which is an
// intrinsic since Java 6u18) in a naive loop, see LUCENE-2221
/** Returns the number of set bits in an array of longs. */
public static long pop_array(long[] arr, int wordOffset, int numWords) {
long popCount = 0;
for (int i = wordOffset, end = wordOffset + numWords; i < end; ++i) {
popCount += Long.bitCount(arr[i]);
}
return popCount;
}
/** Returns the popcount or cardinality of the two sets after an intersection.
* Neither array is modified. */
public static long pop_intersect(long[] arr1, long[] arr2, int wordOffset, int numWords) {
long popCount = 0;
for (int i = wordOffset, end = wordOffset + numWords; i < end; ++i) {
popCount += Long.bitCount(arr1[i] & arr2[i]);
}
return popCount;
}
/** Returns the popcount or cardinality of the union of two sets.
* Neither array is modified. */
public static long pop_union(long[] arr1, long[] arr2, int wordOffset, int numWords) {
long popCount = 0;
for (int i = wordOffset, end = wordOffset + numWords; i < end; ++i) {
popCount += Long.bitCount(arr1[i] | arr2[i]);
}
return popCount;
}
/** Returns the popcount or cardinality of A & ~B.
* Neither array is modified. */
public static long pop_andnot(long[] arr1, long[] arr2, int wordOffset, int numWords) {
long popCount = 0;
for (int i = wordOffset, end = wordOffset + numWords; i < end; ++i) {
popCount += Long.bitCount(arr1[i] & ~arr2[i]);
}
return popCount;
}
/** Returns the popcount or cardinality of A ^ B
* Neither array is modified. */
public static long pop_xor(long[] arr1, long[] arr2, int wordOffset, int numWords) {
long popCount = 0;
for (int i = wordOffset, end = wordOffset + numWords; i < end; ++i) {
popCount += Long.bitCount(arr1[i] ^ arr2[i]);
}
return popCount;
}
/** returns the next highest power of two, or the current value if it's already a power of two or zero*/
public static int nextHighestPowerOfTwo(int v) {
v--;
v |= v >> 1;
v |= v >> 2;
v |= v >> 4;
v |= v >> 8;
v |= v >> 16;
v++;
return v;
}
/** returns the next highest power of two, or the current value if it's already a power of two or zero*/
public static long nextHighestPowerOfTwo(long v) {
v--;
v |= v >> 1;
v |= v >> 2;
v |= v >> 4;
v |= v >> 8;
v |= v >> 16;
v |= v >> 32;
v++;
return v;
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/BoundedProportionalArraySizingStrategy.java0000664 0000000 0000000 00000006211 12403265743 0033724 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc;
import java.util.ArrayList;
/**
* Array resizing proportional to the current buffer size, optionally kept within the
* given minimum and maximum growth limits. Java's {@link ArrayList} uses:
*
* minGrow = 1
* maxGrow = Integer.MAX_VALUE (unbounded)
* growRatio = 1.5f
*
*/
public final class BoundedProportionalArraySizingStrategy
implements ArraySizingStrategy
{
/**
* Used by {@link ArrayList} internally to account for reference sizes.
*/
public static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE;
/** Minimum grow count. */
public final static int DEFAULT_MIN_GROW_COUNT = 10;
/** Maximum grow count (unbounded). */
public final static int DEFAULT_MAX_GROW_COUNT = MAX_ARRAY_SIZE;
/** Default resize is by half the current buffer's size. */
public final static float DEFAULT_GROW_RATIO = 1.5f;
/** Minimum number of elements to grow, if capacity exceeded. */
public final int minGrowCount;
/** Maximum number of elements to grow, if capacity exceeded. */
public final int maxGrowCount;
/**
* The current buffer length is multiplied by this ratio to get the
* first estimate for the new size. To double the size of the current
* buffer, for example, set to 2.
*/
public final float growRatio;
/**
* Create the default sizing strategy.
*/
public BoundedProportionalArraySizingStrategy()
{
this(DEFAULT_MIN_GROW_COUNT, DEFAULT_MAX_GROW_COUNT, DEFAULT_GROW_RATIO);
}
/**
* Create the sizing strategy with custom policies.
*/
public BoundedProportionalArraySizingStrategy(int minGrow, int maxGrow, float ratio)
{
assert minGrow >= 1 : "Min grow must be >= 1.";
assert maxGrow >= minGrow : "Max grow must be >= min grow.";
assert ratio >= 1f : "Growth ratio must be >= 1 (was " + ratio + ").";
this.minGrowCount = minGrow;
this.maxGrowCount = maxGrow;
this.growRatio = ratio - 1.0f;
}
/**
* Grow according to {@link #growRatio}, {@link #minGrowCount} and {@link #maxGrowCount}.
*/
public int grow(int currentBufferLength, int elementsCount, int expectedAdditions)
{
long growBy = (long) ((long) currentBufferLength * growRatio);
growBy = Math.max(growBy, minGrowCount);
growBy = Math.min(growBy, maxGrowCount);
long growTo = Math.min(MAX_ARRAY_SIZE, growBy + currentBufferLength);
long newSize = Math.max((long) elementsCount + expectedAdditions, growTo);
if (newSize > MAX_ARRAY_SIZE) {
throw new AssertionError(
"Cannot resize beyond " + MAX_ARRAY_SIZE +
" (" + (elementsCount + expectedAdditions) + ")");
}
return (int) newSize;
}
/**
* No specific requirements in case of this strategy - the argument is returned.
*/
public int round(int capacity)
{
assert capacity >= 0 : "Capacity must be a positive number.";
return capacity;
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/EmptyArrays.java 0000664 0000000 0000000 00000001166 12403265743 0026311 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc;
/**
* Empty arrays.
*/
public final class EmptyArrays
{
public final static byte [] EMPTY_BYTE_ARRAY = new byte [0];
public final static short [] EMPTY_SHORT_ARRAY = new short [0];
public final static char [] EMPTY_CHAR_ARRAY = new char [0];
public final static int [] EMPTY_INT_ARRAY = new int [0];
public final static float [] EMPTY_FLOAT_ARRAY = new float [0];
public final static double [] EMPTY_DOUBLE_ARRAY = new double [0];
public final static Object [] EMPTY_OBJECT_ARRAY = new Object [0];
private EmptyArrays()
{
// no instances.
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/IntDoubleLinkedSet.java 0000664 0000000 0000000 00000031622 12403265743 0027521 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc;
import java.util.Arrays;
import java.util.Iterator;
import com.carrotsearch.hppc.cursors.IntCursor;
import com.carrotsearch.hppc.predicates.IntPredicate;
import com.carrotsearch.hppc.procedures.IntProcedure;
/**
* A double-linked set of int values. This data structure is characterized by
* constant-time lookup, insertions, deletions and removal of all set elements (unlike a
* {@link BitSet} which takes time proportional to the maximum element's length).
*
* The implementation in based on
*
* Preston Briggs and Linda Torczon's paper "An Efficient Representation for Sparse Sets"
*/
public class IntDoubleLinkedSet implements IntLookupContainer, IntSet, Cloneable
{
/**
* Default capacity if no other capacity is given in the constructor.
*/
public final static int DEFAULT_CAPACITY = 5;
/**
* Dense array of set elements.
*/
public int [] dense = EmptyArrays.EMPTY_INT_ARRAY;
/**
* Sparse, element value-indexed array pointing back at {@link #dense}.
*/
public int [] sparse = EmptyArrays.EMPTY_INT_ARRAY;
/**
* Current number of elements stored in the set ({@link #dense}).
*/
public int elementsCount;
/**
* Buffer resizing strategy.
*/
protected final ArraySizingStrategy resizer;
/**
* Create with default sizing strategy and initial dense capacity of
* {@value #DEFAULT_CAPACITY} elements and initial sparse capacity of zero (first insert
* will cause reallocation).
*
* @see BoundedProportionalArraySizingStrategy
*/
public IntDoubleLinkedSet()
{
this(DEFAULT_CAPACITY, 0);
}
/**
* Create with default sizing strategy and the given initial capacity.
*
* @see BoundedProportionalArraySizingStrategy
*/
public IntDoubleLinkedSet(int denseCapacity, int sparseCapacity)
{
this(denseCapacity, sparseCapacity, new BoundedProportionalArraySizingStrategy());
}
/**
* Create with a custom dense array resizing strategy.
*/
public IntDoubleLinkedSet(int denseCapacity, int sparseCapacity, ArraySizingStrategy resizer)
{
assert denseCapacity >= 0 : "denseCapacity must be >= 0: " + denseCapacity;
assert sparseCapacity >= 0 : "sparseCapacity must be >= 0: " + sparseCapacity;
assert resizer != null;
this.resizer = resizer;
ensureDenseCapacity(resizer.round(denseCapacity));
ensureSparseCapacity(sparseCapacity);
}
/**
* Creates a set from elements of another container.
*/
public IntDoubleLinkedSet(IntContainer container)
{
this(container.size(), 1 + maxElement(container));
for (IntCursor cursor : container)
{
addNoChecks(cursor.value);
}
}
/**
* Ensures the internal dense buffer has enough free slots to store
* expectedAdditions.
*/
protected void ensureDenseCapacity(int expectedAdditions)
{
final int bufferLen = (dense == null ? 0 : dense.length);
final int elementsCount = size();
if (elementsCount > bufferLen - expectedAdditions)
{
final int newSize = resizer.grow(bufferLen, elementsCount, expectedAdditions);
assert newSize >= elementsCount + expectedAdditions : "Resizer failed to" +
" return sensible new size: " + newSize + " <= "
+ (elementsCount + expectedAdditions);
final int [] newBuffer = new int [newSize];
if (bufferLen > 0)
{
System.arraycopy(dense, 0, newBuffer, 0, elementsCount);
}
this.dense = newBuffer;
}
}
/**
* Ensures the internal sparse buffer has enough free slots to store
* index of value.
*/
protected void ensureSparseCapacity(int value)
{
assert value >= 0 : "value must be >= 0: " + value;
if (value >= sparse.length)
{
final int [] newBuffer = new int [value + 1];
if (sparse.length > 0)
{
System.arraycopy(sparse, 0, newBuffer, 0, sparse.length);
}
this.sparse = newBuffer;
}
}
@Override
public int size()
{
return elementsCount;
}
@Override
public int [] toArray()
{
int [] result = new int [size()];
System.arraycopy(dense, 0, result, 0, size());
return result;
}
@Override
public boolean isEmpty()
{
return size() == 0;
}
@Override
public void clear()
{
this.elementsCount = 0;
}
@Override
public boolean contains(int value)
{
int index;
return value >= 0
&& value < sparse.length
&& (index = sparse[value]) < elementsCount
&& dense[index] == value;
}
@Override
public boolean add(int value)
{
assert value >= 0 : "Double linked set supports values >= 0 only.";
final boolean containsAlready = contains(value);
if (!containsAlready)
{
// TODO: check if a fixed-size set is (much) faster without these checks?
ensureDenseCapacity(1);
ensureSparseCapacity(value);
sparse[value] = elementsCount;
dense[elementsCount++] = value;
}
return !containsAlready;
}
/**
* A faster version of {@link #add(int)} that does check or attempt to expand the
* internal buffers. Assertions are still present.
*/
private void addNoChecks(int value)
{
assert value >= 0 : "Double linked set supports values >= 0 only.";
final boolean containsAlready = contains(value);
if (!containsAlready)
{
assert size() + 1 < dense.length : "Dense array too small.";
assert value < sparse.length : "Value too large for sparse.";
sparse[value] = elementsCount;
dense[elementsCount++] = value;
}
}
/**
* Adds two elements to the set.
*/
public int add(int e1, int e2)
{
int count = 0;
if (add(e1)) count++;
if (add(e2)) count++;
return count;
}
/**
* Vararg-signature method for adding elements to this set.
* This method is handy, but costly if used in tight loops (anonymous
* array passing)
*
* @return Returns the number of elements that were added to the set
* (were not present in the set).
*/
public int add(int... elements)
{
int count = 0;
for (int e : elements)
if (add(e)) count++;
return count;
}
/**
* Adds all elements from a given container to this set.
*
* @return Returns the number of elements actually added as a result of this
* call (not previously present in the set).
*/
public int addAll(IntContainer container)
{
return addAll((Iterable) container);
}
/**
* Adds all elements from a given iterable to this set.
*
* @return Returns the number of elements actually added as a result of this
* call (not previously present in the set).
*/
public int addAll(Iterable iterable)
{
int count = 0;
for (IntCursor cursor : iterable)
{
if (add(cursor.value)) count++;
}
return count;
}
/*
*
*/
@Override
public int removeAllOccurrences(int value)
{
if (value >= 0 && value < sparse.length)
{
final int slot = sparse[value];
final int n = elementsCount - 1;
if (slot <= n && dense[slot] == value)
{
// Swap the last value with the removed value.
final int lastValue = dense[n];
elementsCount--;
dense[slot] = lastValue;
sparse[lastValue] = slot;
return 1;
}
}
return 0;
}
/**
* An alias for the (preferred) {@link #removeAllOccurrences}.
*/
public boolean remove(int key)
{
return removeAllOccurrences(key) == 1;
}
@Override
public Iterator iterator()
{
return new IntArrayList.ValueIterator(dense, size());
}
@Override
public T forEach(T procedure)
{
final int max = size();
final int [] dense = this.dense;
for (int i = 0; i < max; i++)
{
procedure.apply(dense[i]);
}
return procedure;
}
@Override
public T forEach(T predicate)
{
final int max = size();
final int [] dense = this.dense;
for (int i = 0; i < max; i++)
{
if (predicate.apply(dense[i]))
break;
}
return predicate;
}
@Override
public int removeAll(IntLookupContainer c)
{
int max = size(), removed = 0;
final int [] dense = this.dense;
for (int i = 0; i < max;)
{
if (c.contains(dense[i])) {
// Swap the last value with the removed value.
final int lastValue = dense[--max];
dense[i] = lastValue;
sparse[lastValue] = i;
removed++;
} else {
i++;
}
}
this.elementsCount = max;
return removed;
}
@Override
public int removeAll(IntPredicate predicate)
{
int max = size(), removed = 0;
final int [] dense = this.dense;
for (int i = 0; i < max;)
{
if (predicate.apply(dense[i])) {
// Swap the last value with the removed value.
final int lastValue = dense[--max];
dense[i] = lastValue;
sparse[lastValue] = i;
removed++;
} else {
i++;
}
}
this.elementsCount = max;
return removed;
}
@Override
public int retainAll(IntLookupContainer c)
{
int max = size(), removed = 0;
final int [] dense = this.dense;
for (int i = 0; i < max;)
{
if (!c.contains(dense[i])) {
// Swap the last value with the removed value.
final int lastValue = dense[--max];
dense[i] = lastValue;
sparse[lastValue] = i;
removed++;
} else {
i++;
}
}
this.elementsCount = max;
return removed;
}
@Override
public int retainAll(final IntPredicate predicate)
{
return removeAll(new IntPredicate()
{
public boolean apply(int value)
{
return !predicate.apply(value);
};
});
}
/**
* Create a set from a variable number of arguments or an array of int.
* The elements are copied from the argument to the internal buffer.
*/
public static IntDoubleLinkedSet from(int... elements)
{
final IntDoubleLinkedSet set =
new IntDoubleLinkedSet(elements.length, 1 + maxElement(elements));
for (int i : elements)
set.addNoChecks(i);
return set;
}
/**
* Create a set from elements of another container.
*/
public static IntDoubleLinkedSet from(IntContainer container)
{
return new IntDoubleLinkedSet(container);
}
/**
* Static constructor-like method similar to other (generic) collections.
*/
public static IntDoubleLinkedSet newInstance()
{
return new IntDoubleLinkedSet();
}
/**
* Return the value of the maximum element (or zero) in a given container.
*/
private static int maxElement(IntContainer container)
{
int max = 0;
for (IntCursor c : container)
max = Math.max(max, c.value);
return max;
}
/**
* Return the value of the maximum element (or zero) in a given container.
*/
private static int maxElement(int... elements)
{
int max = 0;
for (int c : elements)
max = Math.max(max, c);
return max;
}
/**
* Clone this object.
*/
@Override
public IntDoubleLinkedSet clone()
{
try
{
IntDoubleLinkedSet cloned = (IntDoubleLinkedSet) super.clone();
cloned.dense = dense.clone();
cloned.sparse = sparse.clone();
return cloned;
}
catch (CloneNotSupportedException e)
{
throw new RuntimeException(e);
}
}
/*
*
*/
@Override
public String toString()
{
return Arrays.toString(this.toArray());
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/Internals.java 0000664 0000000 0000000 00000003416 12403265743 0025770 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc;
import com.carrotsearch.hppc.hash.MurmurHash3;
/**
* Internal utilities.
*/
final class Internals
{
static int rehash(Object o, int p) { return o == null ? 0 : MurmurHash3.hash(o.hashCode() ^ p); }
static int rehash(byte v, int p) { return MurmurHash3.hash(v ^ p); }
static int rehash(short v, int p) { return MurmurHash3.hash(v ^ p); }
static int rehash(int v, int p) { return MurmurHash3.hash(v ^ p); }
static int rehash(long v, int p) { return (int) MurmurHash3.hash(v ^ p); }
static int rehash(char v, int p) { return MurmurHash3.hash(v ^ p); }
static int rehash(float v, int p) { return MurmurHash3.hash(Float.floatToIntBits(v) ^ p); }
static int rehash(double v, int p) { return (int) MurmurHash3.hash(Double.doubleToLongBits(v) ^ p); }
static int rehash(Object o) { return o == null ? 0 : MurmurHash3.hash(o.hashCode()); }
static int rehash(byte v) { return MurmurHash3.hash(v); }
static int rehash(short v) { return MurmurHash3.hash(v); }
static int rehash(int v) { return MurmurHash3.hash(v); }
static int rehash(long v) { return (int) MurmurHash3.hash(v); }
static int rehash(char v) { return MurmurHash3.hash(v); }
static int rehash(float v) { return MurmurHash3.hash(Float.floatToIntBits(v)); }
static int rehash(double v) { return (int) MurmurHash3.hash(Double.doubleToLongBits(v)); }
/**
* Create and return an array of template objects (Objects in the generic
* version, corresponding key-primitive type in the generated version).
*
* @param arraySize The size of the array to return.
*/
@SuppressWarnings("unchecked")
static T newArray(int arraySize)
{
return (T) new Object [arraySize];
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/XorShiftRandom.java 0000664 0000000 0000000 00000001673 12403265743 0026743 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc;
import java.util.Random;
/**
* XorShift pseudo random number generator. This class is not thread-safe and should be
* used from a single thread only.
*
* @see "http://en.wikipedia.org/wiki/Xorshift"
* @see "http://www.jstatsoft.org/v08/i14/paper"
* @see "http://www.javamex.com/tutorials/random_numbers/xorshift.shtml"
*/
@SuppressWarnings("serial")
public class XorShiftRandom extends Random
{
private long x;
public XorShiftRandom()
{
this(System.nanoTime());
}
public XorShiftRandom(long seed)
{
this.setSeed(seed);
}
@Override
public long nextLong()
{
x ^= (x << 21);
x ^= (x >>> 35);
x ^= (x << 4);
return x;
}
@Override
protected int next(int bits)
{
return (int) (nextLong() & ((1L << bits) - 1));
}
@Override
public void setSeed(long seed)
{
this.x = seed;
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/cursors/ 0000775 0000000 0000000 00000000000 12403265743 0024662 5 ustar 00root root 0000000 0000000 hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/cursors/package.html 0000664 0000000 0000000 00000000615 12403265743 0027145 0 ustar 00root root 0000000 0000000
High Performance Primitive Collections (HPPC): cursors
Cursors are primitive data holders used in iterators.
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/doc-files/ 0000775 0000000 0000000 00000000000 12403265743 0025027 5 ustar 00root root 0000000 0000000 hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/doc-files/interfaces.odg 0000664 0000000 0000000 00000107653 12403265743 0027661 0 ustar 00root root 0000000 0000000 PK +=(E.+ + mimetypeapplication/vnd.oasis.opendocument.graphicsPK +=(Eh,˲KOg[,Y>˒eߝeY)IH ؼ;9tf ` l$aAOOwUu{+ @Ԡw+0K=`)F 5F 5F 5F 5F 5F 5 IX# $L˂(Z ˂^,͠c+Q}
bJ6.*Tx䴖jP9 D/qffS41@z IL0͐iٴ.hm/lVxMFt
Ȁ5n&e&MӨ+ ?h
%l`MBjpC2iUO>
Ximɡg/]JM:f[L=y~2I0@'t*!| DW Cd
^QJi kl!j1 a3}re?:!C ?[ != ~
n7& <34ܳ?lж'?* G]ܟ8m. ;r̩>ӗ_ۿ|l^|iqU=oԭޭ"iǟZ
]z揞ӣ9y.|~oz{
Q\3Y,nm\ @+/w~/G?}]ƿ\x ¨M]m[w0i&?Y~ѷ<w9 }7o~O>N~~YMU
d2ٵ~wOgJ_l^to\ٕLLqn
dvUW.h_/3
< } HZ3)@]ڽ뚄lX̯{6jyc>~cWhAȓ@@`yEs s سY|,&~;>|]6÷uZrSݙ®iVC~HcХc|UǞ|ߦcg5 n \G ʀ}Ra +Oi Eg>2قE#я~n#AzGF?~2իAmU5|WڶZr *Tn ~Wwޟ4Tpco
HZW(:WOS,˚qMC=.gW'zZ"O0!_L iڥ̵IX,d~iC>IhU6{#JJIl3F a9p+-!lS CfNδLhCvX j 3:J 0Qə!/|vAl i[]r!Kn;H c':SAVP˵q!r)\KkU4E;RBAux\
{M`CMO}W,RiU "b{#
Yk `ʘWUn%aL|D'BMhÀV/FUe ?o>\A13RCv(K&}e*oZvttH: G? ɚڰ` X` |6.xNO &9uxT R`ؠd#%a4axxC5:$? =Dh0 AsNi~4b
BF,y;Z i3#Snh&-Mn< rrĔi@|OfbPy,X`IƢ`{˹ʗ=t_ G s Kk)!P<#ͣk#2\F2Lk /f([|\GA/BhA
Q0OZ >O? _8ׇl&)
VΥ ա+v羨s&Ohw"kpGd`ЖB͖I0ַK
I6 QG f6eDh ( vҬ_d T'Eh%cakpVX]r$$^H n=Q l9ʔ
g^jLh@iӠE ,
'iDkʍ8 <2 (| g/(՝5p3Ha 8K,٥6` ط$p 㸆AHBJAzE>D`֠cq5E{JAv*H2=]: 8JXV,ж uFX%K ؕ&x}sO<{lQNeYV xS7T_:VV CMZ"7Gÿ\^D$'}^U''̮Oqrs mBR`t9E`O|Dl Ax;bQ ^qd0
2麎Y[}Ģ<+D X^ok!-E|k믜H!
D ^%r` W4ÚpPZmlB AoبX峦ENcT`Ja
`~ gAaq].Bt1; /^س dFP$).f>i)*
1 W
[o3L·kTCI"Vi\ @4>O"D\W_0՜7`GDzx;z'q{UŪr#LV4k~Jvaچ[s:T̛# .ܛ), -afi.62WP![;,;+TZ<6l.~b /D[*Q,g@% Dy^(>
iFD9)d#1>w;8
QΦh-Nt`r!]v"m)_GYnd9_sZT><ʻ Rp{Tsٜ/ & w(fÓ0 Jj1YD>6@pUJjj kXϝ;ŷT, ̕+Wp \$IzꩧFFF +@{^Ү |{{;Bn.4?LB$Bbәыֵs
R99LyB@
6UƶSh,M9_z]&W?8-Dgϟĭ]Q3×F[.R
Qɔ@f?דYv\:Qa_h~ܵN7@1I-kyabD#\ozf! W^-m7H6 y\>w[g8cq ? < ?b s(&]P Uj[[7gև hxPe(4KNA{vp[p[ b$*i$EU]^[*(Pf%T?_keR*v-k`7Ʊe_1 D.r)teHSk 7D8X, LMXt4uo L H_?ڋkC*RP[[[kk#ýcÊy# mT1!sO.8e#MZ[ϴ?s[a& \ 64(rR 2ZDC%wG/D,. zw7^g ػ``s0Zc
СCĻ} 0R/3$KV8]clv" %-8z µ䫢~b?A-Xya.gY@a$je__xA)G&a9e 24i&P, /Ut4 ,(Wf6rhl%7jp4MѶ~ެ;|q S^y^ OtsOeۋGF']at|\W ݤ^t>P %O B>#x(@ܰ{U 8 f̠x?pUf0 os[iQehB@/$
.@"(9J1pb߮-4n)m,mXhR!`$C9=$9|50>4>^:74:$i}iY >ud$|~ڻy)<4E+._3bY՟3d)YNY}IB2u 6r& x N=d固FR{Ȭ7
gQUJe.Qh0/(ErK+aջvp8 dp;fQ,,=ɲ̮m[x^wNé AQ$v(@=x ͠8|uQO. K'.B{2quE#-9%s,KΌbL>21 4"fE)Բ &7K/1ϟ?owѨ,mѪHn !#e?ܵ`8alŸiR cW0sEېR ^AJy+LN _nS:,#szx/ڱNUr:7P 2
Ir'Gp ]4;$#~ >(2-# lذA վ >|x4 iQOO =|}=Kg2y# EQxG<7 IUyiի)!O(*a t0(Βf K Gh? v x-4Xo.GO?nݺƦFUQы!HL2
̢6Xo
a<*{0ܡ%mmmy4F8oO>9˔Hmݸq#\"e0|
O?4q7lv#/%xq;,+¥o|Sjll vy9b*vTەl3+8Ǽf͚}sT'*%RbPY0a2C3/h9OU&f4J!a+vw!sj
al-$1a,-kWÂܞb "DL1h$T3U1|D{"'XkW
T8B 5 \iM ?ci>ݒi9;4 lp^2xxM%)g9bhJ HT9uyQ $T&Dp> NL"zuMM#}G3cc}]*)RF1 =x$AD J6#pW.뢒@Hn/!gYWdM? Mk,Cx$`(P% nLC'~A6tYkxlj/䲂 eu+. yϞ82
/\<
DϦE,**$E|AA.B\p\fDUni8u4B06ҿL>+_{w@%XMD_(BaX\QY6lX( /euDqܬA5W
|0rm [5i JuB ! ss ,K1 )(p|[*?lW(3
W/&-bm :ڟ\aiv;VH;4'475\v4fPA8v B`*eWEG PH$Jx,!]E)9x$LqeT L mWAw| \XnDg[7q4~J;r͏#͆1VP@inhd0: a]
g \w*HK7 /Q9gDtt-u6и
RȓFҒ(
ot5jj66D5Ōߦ둖lZfdM8s)MQ $G܁@]#a^ΩR1dW/քÞ|FH2@S H k=b{ljx<#\3
t,z_ BbP+n,c\4F!NM٫44:zh#}?~nb|w[.1b 15}h&D`K5l(mb:>y॓@1m)F3J0*EZ'N+P鄤ھniwa>ӄ(
_<P^ |w~{{{:*eGF'3Um)?0J`8ubde_EӹR y #/ذj3ͲɄB!(3r@)PSTpFӤpUȒYZ>H&If@4REѮMpƣ
B(aX`x~3'21@k')
$-}; K+:\lYSyj Guz1/]eHnh8'$%.nohl88L
uWw(@{WC~ tvvU?x A 'X $Rnx̆42My(Lh0rCN *q8dc3'%YLb1,e
f:ZY8Ơ. Si+q74ncSB 5BhRFHx\ 4D,'Ts/җդKOK:0í]q [< rH 'De, se4gHӯrfe.ݼfc.B Lry0[Mx㖅(
TIמ<97L)Qg>߷/͢Ŧb+* 8AylxՃZW.ı,?gn{JGR4>cjO<u/>8} B__}>m\ŚGYAjh CE%p9b9 qG߃k ` P+ϩw3MWEss f U*dCBAS&>k:[HgpUrD"% vrpBo}7[[[ A~H7 iXn;w^fh{f UMGb > PO~kin laDKW # ؏}wiCeK 4'(QO{knܳA2LxaLf _3þ3w 1+]WjP'>zXgKaiR7b\hGtd^QU
[<gވUL
ǎ ymE֭[/--Xqu1a \
\W+W˗/ӟoF)Eݨ5\J)dC@7LSG?pF;Vm5 Y3AC_ǟx9d!/){.L[Oc lق)P$3@m ܐ){:vsh(t n]6b5!FWWכOLLB!(A&RW@BL
ohC)"L^9tYP~Ѡ ;FbݜF.[z,C ,Yq,T*HG }M]Ć^4Ϡ:W=, TTnQϪS~
%DzbiG )ݶVk<<_
.>,gwܔ f x E컩xmY"^.fVu,1'GشgMw: sP=+nJ oǿ i폳@cGszN a
sj6`>[p lɣ^^r$W4>gKk*k"TWn+Z#e҈fj o cY$rz&-4BYD;̂}OU
_p1Y~ZHjRhgb0â/*ݕcd1(=,|R1EYQ*מ]p I)G"@) z F=S$*Vy+9nJ 87 7 ,QfQ4zɨh
FF ]ҋ?fB0%ipHcE&iPx6gվ>,Ν8 B=M%19hZ $4 e<4sQp(~
T~p&| 0:eA 8 R\꫟mjM
uivȤmxi* ƛo
2
5 ,40
VY!⏏'>w#]hŢ~2I&[Aw4|^#X4t; XD{V
߹nq0WP2o[a%sq˖T(ʥS:`:%K GGb\'&nU(W`fY= `(M7A)'bR.\,xFδ'zt(:ـu倍,[MC/̂$)۲ޙ˙hrD"uQx*[]iW%y[:n:T -pe j&d]=Ǖ`DD
9dM k4Ea<ܒ -T F}}j,R#
ʼn 2PЃC
'Җn!іg 7fzxNZ1ig^hia:r[Z(U'i+>eS̛'s]}zVul*S0F8HˀٸJԧtvOu#Ycol@ab}}Y W
ǯ>(CjRvx5oirTH^͍?F(qO8E apri01Nf2\P SPDpp<{6 Qm , OU 1xnv$0U뺜gw.{Bʫ
# k:we437m24E7 G&k'ɜ(9$$壙].24) ; /a]Cg}pNdYPD qdP哢hTEpH
9
>oA'Ɔӣp]bѦz'ÚeY~llX,Bjo nA vՃ4InF-@ܣ}!4ͨ$EK%
p9ƘL _ 5݂ lP*21 "Ć0Ym [h@LLccY*uw7^ۇk߰ j \%s''Kkc}}Gj(K3xy~#:;$@dML')=NYZM鿱2h0
Y6 }YlE0SZUn y.U]RȀzLJ! :z" xG'u3 T{s3 Npްa',Ⰿ)vP W2C ɴ{j
mg> 8}jzy1<c7}YP :F Ww1om~KO6W|=ާMr~fP;s#U7ia7/JίoHlk14t
H HS Q ֡
o8T_3>˔~x0<
8r*df238o] 3pLy|!Bo>] m5ѫ>N3:JwVXd7DR<; ua!y\47eGLqe+,ti7lvgu[nD ԍnX}# ;q2TIo S
V $amB "L NMWs
n
z{lfe-e+[*§ {?x6S"P WSw85xA4}NWn}Kjvc9~غN[Ӓ+M_[pL&322²aXoc
E5("
[)P1UWҖ"(2A]m U [}/1 r/HkH; *2 -0հp US iAD. -T灂έ̎EYZQXbl4EvnyшǒZ*| rrr+͑Mfw/{̙BAk ?
14Ja4$TɯIWC o+X̲ \b-a) #`vܭ5X0I)m[/]Bm%d:UcJP"q##P7mniUƳR !ƢHm^HEQ^`01!؈H{R .K)8NB /J$,|Ez3qAf2*ե(WZ~GY
/k"`hPF[Z:MU .g>11}NngCi/_ y*91HA L[;鱱??MӳN +n
: 6lp/MvE}Fuv7~\=
ɾ " Jq
dbs "j:ʄ)~!W"%ڲ ѦVx>Z*q * ,=F
? ܞ*K86Sږp T "+>PXRV Eҝ6P s*uQ-9\rEUUeeJ$6^zf#@Si
5U4fUgb[P)1x_ Lu|:V$7 `EѻTPzm e( o I\RiaH]QID"**2R02JD3ӄJH8 PzWE
##,K#v
;p,>ͯΝ
:iD^du@&@46-
cl6ʫtwSiN\T`5(rhsMюݸjIh,cᕨʁm60MMUA,C3ɱ+hE؟ϗL[uU7XnM <(
açNG>20o ' fW_\wD6| 'CC9e2ɚ K54 c_7,hTeLF%ƉK- P, GrISn7 cfFG?mgRGz pjahtbMH^/ᓁx (wJ\hsgS4$x
$vzn]{aoC7>z@-Ȁ Ou궳.C0>:P֬r@/ n:|.& DAXbdelZeDӌgkCW
P)8NXviXqEL)Itؤ6pEݧU)\]C4 - 9ѡ#P #C]xi}OwhN~:U {dFs J;[Fc G_p==yXNY+iA_ޱnMכskxŗWmEa; ġ_0dFp;Kx{M 9v)>x埿rXiy#ꝫmv
j*98Z / +k{pP_1I+GNd̢*M[@ 9 fݽ\ / ;]]zTlhts.*_jOM]~^7?&`D@cعsgU5sbyx56kke̩U:0u!RO!vvt,`Eo
E6 6:6CRΪ[%s:7;z|
z2aXI)+2v<J U6@CH)kR@(yuQ5ec 6äscx[ ʎH>ٵcxl>_ &u-CIr'~B!?o),|VpÏFA
l](:`o|ʐ MRAeU]: 5f"Kɜ %U;Y>'4l떼^eKPع7c =]ɤ2N
(P Cmou{ rڽq4; Hu
ʕyJu
unP:*DSTH@p79^-PƦi/.U 5N/ qB _sU_(AXa)eyM=Q2@tu]Nxv`K gҷS7 |~/ A ⥟EմW`\[h+z̉+eɃlE5 }7@բ.XqȪ wD* i
ثϿ ~^埘Gr,I\IauU?{J*m!maTd"uv*#w)8(T_O։<(p ykQ|+aĔ"6| B "FaJC$tjI׃rr)?s?
EVS}eZe++ 56h
]EBy1 \"&3iML5^S樟C-j
7}/z6Bϩe!8m 7% Ģu_r9ܾ~fx{9^ }t*dxh.&T^Jݎ+}
m=-pMcsiZ=px!.7k]P]RUFS(Cq vKپG 40eM,Gx2i :t 熵f974&_
{؉,5/>?UiӪbІsf{TC<=~{ۇ sɉg.UH#b/th㦵T:m^ >= _z|?S8 /$MVtd^VA0WU? \Zu]=ʚjRZe#^USvWnR+UZeI~o8Sۼ٘A p[4+aL:JB)zÁ\,м?4 5(,diѺ`" SբN!? 3 $ëHcC\N
xH0j0 x(e)w;Ep_;4O{FFx/1 $''u-/X}m{m!ñt./
,W|Lk= ˲3\4쒵wV6kyPh}fSpuYQ{dSKǎ {
pv{ Cj!wĉI]fb.?;waFp[ŌL ?`:6@Pέm2lZiOç{VdRT>_fc-*s
˴.v8 'NPuBA;wp w+ @od*'4|'ǏLfBu`0ˮN-p |o<gӉG pO+ ػz¹;n'GIfWFbu$1ZaK6~vE)jmlݹcRGl|\p T3DwG9 ӹ^u8ל"컅
@%&B $ bf3Y|I0 Y4s%n+
)- g,Q 'uL<ق1Wwh%֝rn0
HKݼc0,itg J>-A| eAZ$x,qu>MLiϢzf
,P^؞35Xѿ,mvv,8XB>YQ'Fc(vL#{)捝/<_P I]Ms _^ܫfS/<%8n99%w9 6H,q:\:oR(Xǚ/'._Ý>s^E^T4# H.F u
U(
iʷع2irg6Ѓ| Atx`3nĮD ڳ2R7$>?e?rGM [Tme8`Y_^j:8RR. Cettb겒 O*uMNN۾{<h"Yb$i'¹ 7EiD]4 #JPu5vٛLC'l68X q+(Gt¡[{aPH3MDyaZZD1h Lr]BLimcAL7hi㦡sCW2E)di!H`ҵvͰ\266WT]m沙x4EvbrK.V5k7eZ`m7Q(IN"Ҟ ֥&85P.ڰa#phc$Sjf1LGá0MAڸ2=;Y}6 Z "9] ϜeR2*y̸"h},\<~," 倈*YB
0<5<8p×Ύzi,
-6LyAmqXl|hh! 뾁E, p:H$66ZC#)d L2L;(mRfI&jdz<njEܠDXԲmEA5:2 7ԣ-X3hl̃ I"*ICL 9 Qnh5=ڟzG z31z4SЃ&k
_<,lឃxKfJ y?G[:ZJ2{,b__\jUuN )'ƍ3Ol{
~E,=nE.$|kS h
)0f` /
M8~d hzãSjjjF6[$L\ 7@YPi/ kY< {_mі n/nI`͠6@ <0'x gkOH 4XTN4qA}` gA~ zu=7YW-+c(sΘxa( Óoʕ%.I'byc1`N.@+nMӴ G(t*r}lƔ}6 Tgffgz0PU(=w\/? &?t&wTTg) dmY
to$:w߹ "m۶&$LV9?/'vMʜ8RIP"KqGtAX9 (@U*
;+^/aE'O\9_XPGF OP7- EԒ': oxM"?] AK_.GpeJmM,m$Gt9$Q5) hLg/wj%J0 >ZG%i
jh'sʀJ 7Qb9#3
'9 #Iv>uB&MInkTvk(U#/F!su`w8(F fJbQ/$b^)-4NH "E]x +l'O.>,HFX
"/ y&[T'u>"A)j6m|[o b.b1w|=6RgeTPI=ڲ 9;]m5%x? XF/=ڳtmɺB,;4N t*CH
LMM U>OěV|Ύ_҄og:F/LcG SROpʼn'~/| 7͞-cL`
nV]&d%{9jtI.M,w`f6l=gib (i?l˾ RT&
tvUr+qA𝍍RI)~q!LB6жO*l"6-b˶cT
mݾv
f9v%Fan8])k2fO
M5b+p{{;
\ 4z<6@.\4 C!/GZEbF&L]kn.Z&ɫWnv:9|*AhJ*ʤi_!B+$ ݡ(rP`Y؞p*,/jd^mpyMHA͛]>ؠKFC-#0b>KYWb]X}ӳ"`^Bچ^*##F[%Qqx-;) c/Xd9nt457R i^bc1ө*cC[$ݾ'~ᤖ?o
Y#k]=6\yh7K
/8x5r6wzdu98 95IДG\umNM(W.BsK}cY9J շ2u4zCP·BD
r*4IVy5"h} Lex 0̖ p4, R))fcC˰,D &|:> Jr9yFppw"QB`
UxEXP4#QdM
`DM A;]L:^ GrT46N]=zi.lAZ1|A%B7,q
bmaBeā%m6onoۼXT*}Y7lq`n N[˩k* ;}]Hb/ O:7 25U3 ni穘5H$YX3QD[>/o!Rh{PiVE |tӦvrZ1]0]ufJ
k 4Axpj TdԲ5قhP,7HMdaNih8''b"QB
Py67N`iJYȺs#I_'\1:aݶtdv Z<ǒ4c(4Uۂi)(45̈́fU 4,"N堔ջt| H."@/&ӨD"IJ-<"c y;/0K^]J0\M9 X4ӵHFG 皥KW\h%& -3N$4O2 [lV Ģ\i{f`5 ]#PXιs3 eb2 e݉U-wGBd̕3p Xu^^9OlHLPs d
KV=l#(Q`< #gņyb?6455}Qe4->ʇ;1o 5͢WTTꎂrMҟfq| P1}Ue/BZJT j^}Nva%0߅p
gs ?<s4yQ<1Z]NܛXYZhZضv<
|,d G%br| Rs"nUI҈ gâi <>?DQ
DXIF' $gvb5=Mn; ,m=Hvt褚 C`"yoٲLeNv&sv$L}mz@Y2\. o2J03B[9M6
6f$Ӗ(`BNs*Y fHhm8YeF-
0.6'}/)0 eMsރ0vttBn+#7eP+0M
7wcqzeV_8\ ݢ]E)A:Zz@ Mi)-$zx, <-n2 ya%RKh\i҇cB@z)N&Y@Wc wI$foލqgn5Ф;7vdAIVC2zTb2 %")8mO `qȢ7]y0bz2F*LX(WV*-R NB nUn,;9;;7.Lq*<0Oe.LŀhL)
S5AS@_P-5VWq)UK e?z8;Zb;m +}&+xU?%0$'_
Q,+X0j("JA
jPjPjPjPjPjPjPjPjPjPjPjPG i5 IENDB`PK +=(E settings.xmlZ[s6~0}hC&aG>Kna7ybȒGס1) 6ae\lt> ꑳo Mr^.!j3S0
\glCTR5g;BiAEBGtӭݺL_n
K)Fyxqθ[RtH(((##Mk3cQ֭3ތ ˵09K- ޱ0ިV f{f#.ͯV>^Վ/z/bWr0y>*Q8pvH(4u\T< ; |D,]讏O>S
,iGEHSJq7/Dru3wS(H : @B1|umݩZj$}z#C)h*rPݐ@%Krt4\yLQ< CRo
f)#, }]ݘ2R[?5Cf }SJC1 cXob`w9ޫ?<)cn
9-srp@Y"~WqpjBh brJ 'h*JS
h5
{: Q*#åPn1JR6M۞
kƂenu&hW#ީ? 9ڈH|%d8q< xg ^MӡZ ~b̻ ps.8.5$7H _TZx| m(uLdR@{LPq
?laƪd JtSf/#HP,9 CN "T&JTy t٩N. 8FrP 4OhԞe(} p~ qRm#tsM k>]fψS Ԝj @D)oX~qНD%|zC&;A?E5G.uCUߎf|4ùدwPo' : Fnb:ŨnGtk B:M-W߃OÂHC9
0?J'ǶGD4Vey~< 0s Sx[G0q- jilA
@N7^ؠZZkV 0nm}<匤WmNyRZٽŅ]{B>'=v3bc}%:_
i:wܲzg>n'ޙk`ҝg~Z 5 =tO[<ԆSՋ%
|Ga%|r@X-*UJ_oPK $kvrI' J]h}9֜u.Hcs0d{MzozJM3b_>[C3N M^WkjKͲe8: E*$eA6{:H = im
n"&^8̉7* L`r2
U)К3pV ,w"9"{NW6 McO&j }Y~Vئ |JP'7K,iI\*S0
LDeY ro(H08;+6_ w:ɢpcv'qW~ PK3 z PK +=(E content.xml]ے۶Spi1)6%0 ?3X}~; W
gѶTA/lOӴ*P v6]̵=6
q̓?jehMJ6!@xZVP:?\}d7j䅟4( VBZ?Sm A5*͊zfÕ <-e,avtagS1qDD#&}]X#^ )mSjy[g: }($w+EʏY a~ CVAPRw^R0i.s 2 tuu^6 =i8 qO`yn]|4u*UԪ'q5 ˧u uD
Io^.VtޗY?Au6|WZI QK?Z" a/e"гlg~wLk+ ;k\*!vgH(?'D\)ۼ SO杬+(<? H$Eg݃ 9Z~^w8ӯEJ{uũOdPU*@e+5\a,+7D]snuEW~F=AA-;Q&pꢮ@~ ZAi l8+bӿU
(_]Y[J d뼈fid U+:[uAT̏]mCsRtЭ`YmqP /!IJ%5:3wlބӿ 1Rll6
CSҋe tA]Wm rq8g I2G,|hA`8Zuƥ/ ɠ/s' u
by@_K&!&]<s3x; qC?_L"\N~̟E yE$ ًf{f< a\ =ґ~svK3 9m`ZjۄXs=Ho| 2@~@>s/hqֵ#}ItNd`T9tәxcX ǖY źKg
nKKܲg OuVG~"71+k/ bquՋsZ\K4v%P ;s[?!X[NqZQ^M1ِ78&RVrPcYܚz] zw6yIKuN@h'ԯc-+uR {4=[ T|}+!4#Ĥ*P%7ЧVE"z~!ʰ؋C !E"d=BƋ*2_FDeiz0D\ueNO?UMnUϛ,lA} Fi~Ϩlb4,_DeYBU;21%X t E:"ā>jbK_ (=uӒ]H vY +ZIԡ:'ٖߥGlw7
y}?Tb . 4?uʏl[xU3e Hv!WӝF":pnsfD$;BYq-c &yU7G4\!`ۖXX7*rbj-@TDq ͱ%3Ob
cʴYF!]m;ȿdLaR d ԜUjhԖDx
/G.ㄗ9Px.^LxCC]`u5SDKaƁ5"6ZP
B`z 9DZKsdǡT=QG&晴gR<Q=}D:^ ^ˏsUډ3WiezV
#VL w],v,6 =eRzӁg+0=F>I.'J1sO;{.p !be'\ _&UΞNeh k
|TaY@}1vC, 0j8]{Sӧ8 DNx)P7 G G8s=6 Gt]=*VڧV%!#gB`Cw1eĞA>Z?_`1S,E;)gKgt(2bݡW&c'ZѵQcx q$ls4dzybf4n8|!+?-T7>o0]o\drx'`;/@_
µp/3
\I% ּ8?b [4jѩIbfO-8TI b?ϧapT w` 8=3O<] Ops+<.(38|^ *DFܟȸM.=:s}H"*/X$^km9O*G XvQ(O},J!k(_W՛0X%'\u&2NPH?7eq ߃C GmlT[鶩y{` ↸6O.Ý{ FK`z; Qma,EqJM.蛘&OH3+N>j泏v{
X0gu. > w:bu
db'w:)=^,c/=Wg6OFUOH6R<> g#!ncF e*[hi~٩uu}nR7PKۛ h PK +=(Eϣ[ [ - Pictures/10000000000000200000002000309F1C.pngPNG
IHDR D PLTE 3 f 3 33 f3 3 3 3 f 3f ff f f f 3 f ̙ 3 f 3 f 33 3f 3 3 3 3 33333f33333333 f33f3ff3f3f3f3 333f33̙33 333f3333 333f3333 f3 ff f f f f 3f33ff3f3f3f3f ff3fffffffffff f3ffff̙ff f3ffffff f3ffffff 3 f 333f3333 f3ffffff 3f̙ ̙3̙f̙̙̙̙ 3f 3 f ̙ 333f3̙333 f3fff̙fff 3f̙̙ 3f̙ 3f̙ 3 f 333f3333 f3ffffff 3f̙ 3f 3f O IDATxc' F*U0R U<4 IENDB`PK +=(E
styles.xml[r8S4["Igj2SSg&aO.$LHB>v$JL9v8Cn/IodEv9.ey |x3
b["ڦ,SP +< C le")+*Zeդ^̈^t
vg+vNFlc.]Yٱ :uD7EBVD"ͩ\$j,.Dg
?
2EXl.ѩ q.-inۺv5G*{ۙ7Me7QMt̿MmW2b${i|!e'g7z\1&ոH۔a;4y+wʓRHh{ G*QN|r!UȪЅ]B26*MCR+Zq+>yɎwmpC]S4ȍ''C 1}4BU,6`nr&9h-+{,Y
0S#զH#xA.Wqnp𪺦WY^j=]~qC `߷;)d2\B+MkLTRYc+MܓЭENQ 3a47ȷvZX_]{c&KG([TEz I!Ox.Z6 lAUݪZѤ`VYP*RE^-\Gn FyI%TGr8Ε KB܅0g@T JhY ͺR{TXSriSQ]+o7a7Z
?Ԓ~{;O
ѸaSw':"u,tt\ncwy[/:dWc `aLN NOd MRn;m8CHg
I!Z"
_JިCO;A)c >k9M 4rpqK6h [)}"EM1nn L`4ϧIm%V1_0uN!' Ņ%l&m0" M?>*gڱ@Z@[ MV'l3':O sD5sGl%קxP$t s N+[4044~@
͞&b,54}0
~^<~i=4N PC3NS
<dkBHhB9fkrX7:67}g՚b:Vᆶ8tHbސ}x]1)_0 Cw<0`V6_XŹL5Uv$,MɕZn_L^-LAMtkTu__ (RTZC #*6et?TJR kZD!w V|C ٿd &G&vm(ݷvevGM,ds!1iU\*䨱pVyvL?;4{qifd 41YF /Ҿ
|=$;y(Njw߿4ID g&_\ :UhY5Lx8ۃw#o˥o9iKL8[?|i]ͻ=1Gn|1M>
yF̯:J401,CFWgލ᩻x|7"m= 8ҴafqU_qra ~tTrC ul:RKa_G9F' UOfjI,EG
+_-!ɣhh__Kb ([5q!4N$ی{a
LD*B5#PAI8߯ -2|jY4E5\vVF!9(FH^\6QD4w*Gn3pX>"b#S[Z⯶e>tQgVRZ(m a~v?4RۏD5}0QtC#0T)1j(QJ),qJ?PimΧ9\]PKѦ;
; PK +=(E Configurations2/statusbar/PK +=(E Configurations2/images/Bitmaps/PK +=(E Configurations2/floater/PK +=(E Configurations2/toolbar/PK +=(E Configurations2/toolpanel/PK +=(E Configurations2/menubar/PK +=(E Configurations2/popupmenu/PK +=(E Configurations2/progressbar/PK +=(E ' Configurations2/accelerator/current.xml PK PK +=(E META-INF/manifest.xmlTn +"liz F S$RLSU`c'Xm'xY}maWzr
M(:L7b9*$Q9H:;@_t&l=+FX(xlm +&jJ
K' Ou6p4:11T&AWl0N C, $52D ~jwٸ{)GHb1d ],<[is .fZ
5X\ 1ſq
S|%}OPK|) Y PK +=(E.+ + mimetypePK +=(Eh9py? J| b/Ȇ3u285 '֫iD T rMIn5 Ѥ{uo_PUi +X'efP{4/Pk.缔s0սHzKԞ \GJ&k69>m,\6.; bbIH{-'#I)/sҭpz=\{Ӂ(k*D.
hb-I
M栮 5w-$\3u mu)g0_7<6IY.˾k?u-ǷX,.^=ٚ)s0 0$ǿ>2]1e cu*팦d{mS3 :Je('XgAe~`~1oύ0\ j |(u<Òo:!,vk0>ջu0Ӻ ISOwn:=e]}鰳 vbFJٗtZvnIO_0s^I!KH4,,%'CdžwSpP#HY7!rlddd9M0S[5$#!Cⱇr9 Ҿ :s[;FpާƤ+'( %wkJ%o'L# =G#HܓjPW,!YӎD(. {s6jrO:>Zvůw[z0
B.qyֻJdbjO͈ {coPW4ѝ?#s薤GR_XZ :'!Ci[祜 {ijʧI^*yґhC)VdnX"dzZ|+qg=ٲyR-Z}!yZ;b+OM$זpp ;; %>ԯY~Ulx2qHt (jq_y~H=56?vd@}50go2?gclx(Ovܹs&q Xov?/^&;i5 H *7 k(y+ɀLS ׄ
oWS~tYdmb#uS}q>W0Zu0uЕ
fGOHJwdvҵȢk~K e)UBNv
ծ `
1XK9sdjʅBĖ0 #^Cբd_u'Y `%0|MILSwOK
'fԚ4Mj XAX =z 5 $ X @b
5 k H 5 $ X @b
5 k H 5 $ X @b
H ȃS[[@ @ ]z@ k@ 4 cA X @b
5 $ k H ͕+W43349
$ @b
@*%%%ڲeu[rڿl٢ VafW VÐi@AxGuʕIg}Ћ
B* N3={T UCb
X3٣͛7/r `1%%%ڳgO¶ @b
@&O5< $o߮ ;vH
`۷ k ":*))! xꩧyf J* Gc&X* Կ~0 |蛚'ˠ X} X! Z uq; P
5 $ X PLX m:R*!K( y,sO|}zUEY%!qwGUPM8֭=sw7ܣiSUbHݠ_}mguvϡ~q[@; $@!O }Y/t'yp$1m}-}QVsC8{Zԝ'[#9Xn=Ѯ_|83ɏz42}~`/tnN"A}zn@_}\ &nG1)&UVG ? 9j AXi&a%1_v=kwu$@ӶXR-Iwݩhґj{ ]Y }:% N=m5Fe -$zwn}:? )_St6Ưgc D]( >=|eGmL5q7RtBz}q[$UoSNOc Gh|ֈ6<ѮMOB_.k}JhKdRd5ͤ Hs6uDq:wHR]o4vKЗewYKO}>]Nt) w?XB:7Voj=1 qKwפ?tK%G7>8]8-#/42xIE|{
{A<>?֭se9+rnE{ST7ob7/Nv
%7,IWaQn$p ihO6.M듺)}Ĕ&CfiÂv=&ro|ŧjv$S4O_o|߯Xv,F- X3nA Hɿ ioked\ohϓQC5{2*ÏE{=sغQyx_}jJ[#?߱{zX?O p k9 9jTvޯ>]vG[y$a.>ݺ5 l ~z-AO^d?uھsa^nqw 㮄y_G)Cfb=smNu(K\iC-ݺ,ݚ*ݻ{D`zy;ktc4 DH ۗ*Ihmc
5Fl[wV'Y̚`BoX߄{ʤ/~
Oܵxّ$ nugu$1JmM/ })E wZ(]>}jn7$!Øtw`ޥM#C#s/oԝtu=L\8YK ̾J+hvvV'NPMMBl6&&&ӟT}}}!P 22L*@
b2M@ m߾=r y ,
k5N X~$ X @b
5 $ k H $ X @b
5 $ k H $ yb (?_e. 63 H;n=z+ UXgJt Uy 2 #pb #\=dۣ$);k P|!CO(cuG !o98Ju #ނ/gɹ 3{դ@bblrU_֤%[ȣցMLԐc<5Te)sr2i}d@C^cP'd줯RUGL ]SRvE3gޮR~|<-=b
6{5HW2`BS~ }PIgK*lK+^ G~jy4] @l$! n{̃c.z?i 6@b0#Vl. >4 cpm{#H*KxkD
:;^ӨO6UuPx[& Q!hR} 13W9 `M3L*@
b2M@p X|r^5]jPH ] ȿ
:>*al IR
`c P t*B 5 $ X @b]lz{{cA۫9=2 C;w$ 9rDahÆ
Ą6l 0~IΝ;e6nܨY]t)r
ХK}577P$jƍ{ȑZcuҥFc5\k2)7Zc59Ϳ.Τꌤmr~gg5٩~/7߭KwRgZ,33muf-vm=\!/V̌6o~+LZu ܜJJJDbU\P9 /(b$9#.s @!$EOOAp 9 Y8|0A F.jjjօ& 9 Y8p A(r,^k ^,^V<k
ٰan߾M @.X$9x"A088H@= s `ud5Z6 _X MMM W^% u^/A d5< \ kŵm +̱Na())! d:G̱u \\'OxT|faֲojw-zKzV1~$WU]? ˕4.--վ}P!W P(K}NJVkpuf[Ԥ͛7kff&a}X,1:G= A@%a m ̕hϞ= k,Uoo/A LG -dk,
(N۷oSO=rkdcw ( ^͛7X#;w$kOg 96nF
ϋmM} ,M"c^T 9Y{8tazמ9y^Qu0 u-o5mlvm,];ks6633a,X7z)mY{a2kdҥKtQ
?^^9K2^<Ҧ,n{N][=~dv7r|icg$=1C'Luo4/&#דe9 ߙ,Y={V{ƍucu>XS 2lgV]~]n[>l٢R4X7JJJo߾Ab%`?ېv7mۧQKOϸ~6st!&-~ȩBpC u6nnZnmڣ7S|okz)ǜm6δE#*u ߞLؼ D3_ K]ROd{ SfffoY7n{uYIҋ/HN%i[GH $3Z彝Y@RژV 9rD> @W\ю ;# ȣZc ?U|֮j;{s488H
A=P~0Ƃ2h,|ӿK/>pϻ-zmԯM3~SO;|:㒞 5UY}ؤ:=,?&O.L].<ד4V]~Uɧ3u^_ғrCQSOK
ՇӮ{c4U:+^9\Fͤr 34p]ϿY^ R{T.
b~IH+Dܘԋ{my ׯ_orJMM6oLN%4u]yۀtq)s+rF˼cZvqTޜ}[-7[+@[籾&U辱Mo9&}u!]8ըpk8W-[3<'SL
Ϡ[dT2_ltt2,ڭr(<&]xQnROOK 룏>ZăG!? j:P uttgӓ's8]Ӗ *}vؐsL!u9$Mo~סW; SO;+g]w]ϏI>7֨WڤNPxfU ^X/L2~܄W<'^( X\]$ɛ\.v;Mw :폞cuP XmM%sWz, ;vhǎ :y4<< MLLhxx8{*nwJHxv ]Xe. 'ﯝviSKvq]TݮTGe^qH9թs̽,~YVe rR۷O틭;|Y9 ivJzPdgvvv]njƪ1 C]iވε( mv}l'@b[~OLLٳWX2u-mcALڒ$
߯^z^k Ucrݺu@7~ni7yJvP ZXce9:qA "Fb={ F k (n,^9JKK-_V+]} ~W)A ֘Z}whc
yFWI Xq}i{98qb?loomۦ ;vs?_Zt:::h E}hϰP YwݟkWW}}}# $kOmm-A@AܺO8\".SR|X5 Hd![Xs977grPE= $kŋ VݥKidz.33s4= $k,A@A%VtuY7=tu
?B| "/¯|:f<<<\CgggNӓ Xo táh/')t9MǑ8GzCw81G䘢:>e5eӴbcbOxãi%-c>+zNXqFIқoׯ+~<$9"XUz'
ѩsb2h ֕*=_6sޭT=!h0sܪP풤qhLv5,rLA{=U z+^t^ Cv=c{w Wi>MyAC kD^vڸqۛ0rͫ$9?XIên߾ {O X7ֳ
T#ɓ'533"f R[%Ivu#i˓$
z}DSiKHX~N{L-zz8(/nߋ&zu.8M{#=֮nŏrks={.MI*))Qoo XϯN&~U#hppPMMM*))cO<'Nszۧm۶sz饗tŔ\9C۷o$߿_۶mӁ{@ ^n.wܞf$ջ58Vqqݐy;2o#Uؤ&+: nߋ9<~(c=VRPXNlk Ծ}y՞={d梏|~E-uJKK
y}IIɢqI uV!uW0TwB-m
&J=VK$W\K϶wek >u* lIݖx"ؾӝRݍr[$h*~dZhjjROO>3]xQ j5c)UZfvfggurmLBs8O (ٔaFGmR'+rEaz^._E<;U|Ku5 ֢UYL: "z^'q nzQ 2Φ ǚ99Z/ = @b 477 (b,^#K |TuA ,:Z ٚu yP ]z 5sN $֥K X#[MMM HA $Vyy9A kd H $Ç X#[̱ k`vv +TaGmm- ` *!͉'nݺ&0 . :Du X#[̱ k @b: X#[ hΝ2M@ `ͨ PMWX ( skH]m)CstE E:G Hf $ zLMM ! Mry;F"6O(Ҧ}Ǵqrz "Iu4dj45ja1_R?osߥ2ObV? @M{ {wC 9 j:}I^TǡcXv푝gBpHCs#r|:>e5eӴ
Cc# j>gݟ2jHbRJKK O!h0ֻN\%iJFF?ꨒ45j6icdeۧU35ՐG* L{:/k>S=2_%a,f 4QcÈwAM$^)̱ lr\cU
z}DS+UdWy}P7BBmo3n#:7b9=f wkeBR̥=K=(M:7\cJRx;cB I |W:x-2ڧ*yBqݐ$nn
Nj /t^Zw;l6I-sC?ڨS!K=XrTp[Kq;c=j:}Gb:n7AXF2 GIa o=TK# `YzMcs}m.u D7*
z 0Tgl^l6NI.G6mu\6ky}PΫn=mi-VV!Hp2U_#ݼtg)UBu= 0 5hXκݞV Vww6eu7çcWO]r(~]S[!ZNVλEy ON_9 jk3jSF
Vu588H UTkԵas4QUc#K ڱcA(x>3><}jڣ7?/=7>F(s(#Y6r95C} ".^H
ZH%w $Wҋ]ڔEs%{HȮ39<ȺlaA V;? YaկOhR X99իW D ׀mH]M{֪
zR4嘤j^;Ҧi8,? zG/'=~Hz~~wC II=;_AO[V8i)&bT1;$״Go Fr=zC ^-.40~ڑ>cΗ[TPJ;1ѥ QgcI,\
'?y ݾ}[K/M օJKU] XVZZGu A(`7o@=Ƃq}֡ pizmk Kz>SԏMN $)%;~Ԛzt }O*l9yXڟc~|]5$U/ WP҅SA<۲ ?;O{#k.g0> ?O裏;Ю]zcIW4( [2M5u=9ڷo A(`V˓REߊ$1ǺJ]Gl!i5R^$iZt4Ƹ>5EnTIcx,ӾU]nז~7-UE˩3"=֖zC=kE?@ߥ5j;^輘FHRt,= co[ ~?|w߭ ;v9X KPSS; ^}===9]g7[5`;}8ғeͩ% Zڿ }c^ݔN9OUN뾛 WĆLtTFoLJ=j&8W-Ϥ8 [v/|*sQbs5VInCԥ̒g:OA
kxc1Ou؎9O_ɓ'{ߓO.]4eM|p
>, zՕkjj@,<= m5v
TWÆc
u(>̥u$6iWκ
I ui|o1:^\0ٚf~ C
5X'{}%_$IzG^ም4I.9t^- ouP X+yv%̑Ϸ/)Pُ~Ւ4;;O>9 H0MSҫ" މ>?05
,^j.ٳ.u C&
t{ߙ u8Ȯ TxY:::zwܡm$e]e_;ߪOO7]~]eee `aNunfggUZKTAE!]ZlOX;5:Xy u
$' X#[MMM crXFi_ X %HnݺEG UOOoN0 ~ +djmmSO=E0Cs488HP\. Bfffz#F.JB'I:{
{
kffX#;w$Xusss /Sm 557;= A XfÚ $ֹz*A?ʕ+
`9Hb,`zs
0` ·T+P 2IuzYĬivJzPdgÆ
} !4jvvV[l͛SO{ї_~a ٥Kta}g˗u{Ecۭ[A5s}A:5 9VUXː_\/Xk ,m6Qĉ5CsTZZJ "V^^N uc
$Agg'A A F.n7A CAb#) Ν;WX#ãb/¯|rɭ9.qK!#r>9(:G̱ B V`hL) RU]N2%%[·Tw$5Oj]⁓X稹 Eի$\##j{)I2 GjeImkz$
jj d4ҭϋ'z[29T[,N^H|` ]x E$ |N{\'ݪgrX;s? {bͽ.InMNlt*avx8H>uڻ-=
sQG XiyGbZ 4"IRݑIZ3[m`;U:+kklkT'M͕|{\CRc\Kڻh2ZUeh: eIke2.t*~ɺcd]j! PEivJz 0d&Vpi ukq 9rxN8䑣UNJ܅|NަGg2< ۷ E e
]< keTtzs3775OQ^X;ׇO\7֭[x =ֹ*//' @K>ń:G333 (by
]<,Uvގ'ea1'C>_cs\C u >L "v BVIu4*!Uuڽd\k5SRWˑ 8p El۶m$Êڞ*wt,
yp8䈖aLwqy~e yV e !y y| 9 N9 Uwk54e]3,
ڡW%"eHJ)$`lX9 @q[tuȮfg}$ɑҌ>+]ցMzw[sGt(Zv7xGLS٤nqGgƿ**8TաJ/|mrU_֤%[x*IJY>M
1aD:(6m- 577&zB pP`c~\ʘ HUEd(sG4 }q}$*냺`l{S _s[#ө'z|3w1UFc)cr< Rp|ݚt+TBtt2v *lRCڻ-sC mhR7x/^62X稩 Elǎ ɲ;9HiT}wgu@RV-;X)YzMcs}m. D7*+m/jj4 Fb^l6CRctͥC}*u4 uCRcXh?BU9}- ct.(2?um4L*!;yOe= IDATRq\/ןk Pg@4j2Ԡ<%."B 9Z|]m
-ytU* dVW^-jAQ
#cU~Bۥk9\ @UṉQii)A ؾ}B'X@X>\ @`uͩ@o rQ^^N u
o +iff 9VQ PMM
R]}>S!#6C
u}]Xހc
pi ukcӿ"! 3ǺH 7 MMM F|M $Vgg'A փ)ݽ{-?wSW4קM F͛ ^}SOF~7ӿW)IU I]?&}#q^g 1:;zV X|C}F;kjjU`UUehWj:K]Cuk!ѾWGy8!;=\p_r_)InJ~OS& .v=zzz=˽D9hծƨY W_[o깄'.r۽{O? #uGۡrIYM)^ Qoo/A@
Y G CRNK7l?^7:a4:k9">#ML/bLbm ~m=U|{- Em
U~ܟu9b5
^Y=ߩC7uo?M :_ӿ\'<9$ֈknn ֺr,Cx?Чp,|>^ ϑ%Ƨ3uGG7OM{Ŷg~ߒB38e'P%5 ☑$r9 ]Eumy2mY~GBD6 =9ڱcAX!]hk< WUo+s;
Fuf p1g o^;ԣ>זC;G}6\CԵcisҿlc/?P M{:j$|\?o#`d=c?رO֝
* ;X^Yг`DRFXto.3Zp/BKZ߫_ƣAOozez( sMѳc$=ihsL[䜧=Jo xl^1/gh9)J$
[/H
㑑$cp,RzBKy|kco;O; T[[KA=PnOt5C=?O#ϫ1٧3.^&d[T~:>V]Fsprw!wJv,>^ͩ3 ;RN~tߏZ7p ߖxvUF}8_oBP?>, 55c~|]5W<~t<EHNl˂zs+sȶ˹
:kiUܛ
L4zn)ZC4cۆh k>2~蹰߃;W}
$֫)+--ay,f*}<5E-Vnl[/Mlµ9hSiAd3 s=wbu wc@.U vgT\ #;ܙX揉 91sח` `%SqZ,# XM\
٬٬ |A9 +ǏphZ]]lgvvVkkkzp8t: -..V|Mpu^z }SS ꅿt)_|No .~]ү$}n*u~۶ouR>]z>HN]Hv2 9Ƿu7`sJ//S9}w7oBwuZ 7&=`H3'KhmFۺ.q̄T"6={OFx%.j\ߋm8?rU
y0-G۳/=''
W_#_?WcT_GG u7`lؾ}ɿ#_P(T_[_zuNJ?ZXw $; A#W+|_?-}6G*~vW3Y~
xO*Ӹ_)&sIo ֺ7~a9 KP si?WԯuR3~z$|m[79'7evc47giLb }=[zAKzПT~X#m/mиo~ס?&=}ޓկb˶M_Y}Ŷn<(/רط!9Wз q(
I?y;s!}gݎpbg_ӟMvoݤ f߳X~N 0Mu]ۯOnem۷oG cǸǺK+++aP5~fv1v\z\quؠ?'w2IΌuw^yV gk1cX+,vBm^0c= ~ A .A iz[[[# .` .gYއW =tgo{ _=c;j=~/>__}hY0=<ǺK`~,߯2V[h4??&[s>_ZE={` `R. A},S2$H&b"m
x"pc
XDsssZYY "/^
ϜŶ/jqqQKKKdMLLz{7 ^*Κݾ} E8 LjeeEt%2fgg @b۷ `---iqq{,#(&9f O r | ][v $dmmM/_n:&AbBVWWa ׯf ^&})} 3djJ$@b+p[Z]]V6G U+,-E0z ޱVk4}|4:e% LO&6(
I?& PP ز3gܹszgu- 9rDlV.]O?j/ m_~YlVwvcw˗oC(Ǐ ף>??u-;hnnNijhh@q, 0u |A&lVnO?MHEcVZ[[۷UG %X`L$P ζ
$֠
@Vё}mech 4kw.\W^y@ &''O pmbƺ rG HA>`uuU۲X_ {z9cͷw /a` _& ~Y]]% 711A <6s݊{ޘ~~uj=yq8?ߋjyYX2;;K gϞٺ._ﮓWQ/BABA:2yN}eښ/$;0A @_ g*LjddDahbbBI=W+F_tK}nR 73&_:_H#ߪfcEU_u=#zGIw5 Lkkk=]$ۺpႎ ?C#5x)'tH_?_ޖs> Ӥl]Iʊ.\'Oj:._5
vq xp=ϟ?/á |PlVr8 r8 zWǩC?x9AwuY9sF>^|E]|K3O$g>/^}R|)xA1=W:IqvJCI>ZѨFFFt!MLL(L{L&}Ȗn4iw| K/Iݻ.~˿u}w.gշm=Wyu3G ;"ГDVL;GJ}O?ښl1P8 ;SАN>??ӧo>#{Wz3}Qo«3߿2'%) oۖݗkxxX?Of577gU_wm=BcF9 ug{ڇg Yڠ5dzhha2I}ɤ~iqqQ-=vuFFF3pkb`qqQkkk mn$nuuUssszg7fpkv ic>K dHuR/kKH عH433C 2 5:B `9]" q O @/}U~ 8E\
% ktamm 5: F XS### H xw XS Hѩ3g $[4M $"A kt Hѩ! $X 5p P(D$Pt@CB@-o ڟ1gi%1ftA u Hх $,A ktjxx 5Z5;;l6[߾}[sss vA{ }Q=z+_$ww} .s;WZn?'@غͳ0wuA>K -<Ǻm عH;pY
U644g F <.>{ Z | ۿnv---6wh~Ct >">|Fnn3AvYv쳃:cxvO[=c= H UyEҏߔYio}[`ږ. -PgR+rfS'I~}Ҿ=w]Խ^ [4gn m? E-kU} z^;z
W_ξKl)şX^
PKۇJmQ`= LR~@qK1'U
P x[*EuTc ڔnQձ>:_ܵ}16c,Tyd|rLxB N3W_?pe+N-k}> Q$u/49k;SuVTuRx2M;Je tT3F[4P_Zg3:.[.NUARz'٨Ra3u;|L
N{ܔ{PpR'WܠkgR7 8+v]7ch^ 2ƶ |`)W< N5i
&sЏ?6({] mӔ>rrhƼXL~ UIrǧ8sm&{sc{ m8n
IKZVξx36?ǵ2+uIo*dq֜IkGxWန(\
Ǝ9t7g9&ϊžVSDֲ
X3WHc7- @{o*S}Yk5yJu04J
\{g}|Tǁtt ^~|NÞO44.'|Ckf}qiz.82/$i&S'V6\kd>yv}RY^M{:TdRjGÊDSrGHHy@4%eWųW$m@TnKZV9cw-|_RxϢY )vvg꾗LBr=k7cO@d~EjҼ6<
w{m'
H em1vrS`@g2pSIȈ' m?;)a_HV˓ӲqL͉& z}gC>{T)M]q7vyܷo MΨ}.#z)GTu'˭ط:{96=.ée>3.K=d=j 29غ WQOnݫt^|pG?²xyG iQp~ O+|HVwLkާ}E4m?'|tLy\&*:sW)56B(^O3U[R7S^⇛6nțs3Mm?*:}wG [ }1Mǘyf{W"yWӾ*4ZJ$|4AY:d|nVn1 s>j۽&MٿcDžB}6>Fot~=GI!
NJvrR7ޑ4m>Oz1.7C=#'ڣ༯x A֡mC ]3l 0KWy $Niw@Ӊ;r:Tθ ϝ@^74x/Qy& I&Wp~*y Q^;M:y"⇄<۱}ǔ^NtGoTZQ93:( [(^Ǭ&[P@+;>ˣ^y g<=LI/ ݬ>xJW5NA 5ԑ>c>[ʳm *b>@6>}4AY7`|e6Q_7|6ĤPIiWZ>g_M6?W}q'
J
IX#{>.
GPHq79 Ov^0 IDATmmM31r4m ^|+]m?}^vs?7e 1ΗTٯ>g[Dað#ۢS|ԉIՙ4Wۡ1'c ;ƶcfA k>1 V=Ѭ t k FK_^{l Z{^Ǿ}{} "-Ĉ1|F<اb`k8e! $ ]]ոc\;o#X k 7$OSGB_s >ѷ~73ú|2[p tzA[ok l)GPH1 vv8T(Ď;œV^ ')] j1c
Ex k'Q [k`'
hf,i `1c
@7H k @}># @b
__hjj@ X g}+W k @~ J Q* juuU |A ( $ Vٟ~ߔ3 k @^ `x7
Շ ~BЖ'tuhii`p
??ko^ ;P(D$x|B[+*
]'?F_
lf ȿBׯ_??Ow;t u { ;I`Y]]Շ ~o|}t!tҥ& $ ' _'|RReFyrrRF 5 mR
F +r~ҟLS~3uݬ\ַ^JOoQ'I ~mUme_v?
- :)qJ|'=7|byCF B(]U]r{*pj++uN(9zJyK'UAR7 a i*T:o_kU?~4}}K; ĺeMҴϖ[Gl3X_h_3g'.J⡛dn7enZiʽD^MOU~?]N
թOyjJ^s^y]=}^T5۞QӖԍ1)d5'zl+$enj&e_^5Q_ t>=G]ӏ @b
ssy\{)\,W}S!w\B XwH
P0vT Q
iʖ2_.R}Hʳjcڎc2i9CRLhd7SVu_L:m&,^ Mȥ]~mOI+5{5adf[]ۉb>PLn{ԏKӏ ;ᇔI~!iO7y:a 5d>yv}RY^M z-))I Rw І9H>aE)9?͟WrO9uza"fg>UBRSGm2{ `wjRpaE T]iƯk u=ےcoq._u>G2*w̲b_S a/Ϯ7h!S/p{ݿ\Ѥ~i{W~e3噽)dlsT>/riq&8lR3yM =n╺alၷUO Gj~QG
.a?j/9wO? s(8+ TyH93*^GچXj*8iM'byCʝ@^76짔tVʝ?UTLWLN(T鼢B]Eߣom/~ ؔbJ6`{+ Dx0[Hߢ/ ۼk:b۟ q ߈ # pA Z c{К :GCЎ 4iT AMWW$R
?^:{ECCC ` p)x4;;% $hW, kCimmMCCCϴo>L D<ǺSZ[[$ivv [1y1˪nI> XwҥKMs%IZ\\~:st舤xI:7~/E
z嗵J $֨X\\\eKKK @FGGǏСC:T-ż9V+Q^:f+ɳc|\9 rxc[^xHG Xo߾h4ѡC411/% kTxb[yBΜ9 |P/._ܣO9RA'[1{
4~U:ym}k'ZJ_X'
{ n7ytDϿ VҒ^y=2 C/}Igџ>} HQpfjnnN+++ic q9u˗/_u]pkzI={oR. Ͻ&}[N_UoHJ]?Q}=_aQ$Q6]>ۭ??gdd/ $˗uY]zUBA~_ի:{._Lv !?;?~4CCC:{:{l Ꙩr>~n8zB<-X
^ix
Ó(/X䓞uۭsܹsr
߷W^y~ǟ[ q[mZYY+y|N߱S5^~eE 訾4yqU9.\[1yI! :.ǫO(I1\]}ZwnqץO~TIr̝.- ǔnP;Ｃ9MNN?) $ 8Eۧ ]I1ȭ\eOZ]]U2ӧ544Da 5 8+ vib͗u/ ݍĺK/A ktjff 5:eA ktjee 5:555E ~@ k F XS:A ktjxx 5:522B Xo7| 5:o> ;Ǐ WP ` =I mtm\
ޥׯ HeQ 9
BDҏ Et8r52gxxxS>}k_\
`s:~ǸǺKCCC}Yo^SxI&W4:z@lm[w` Kiqp vQ\~Su?~Mej_k
5S6m*/;sսx8v[֍nMī-=> { Xw
@yy# y"iy
M贼f˚qm _ӂ"JmQ ;NI
blu;Y1CbE" вfY-g8U3R>ӽѬTլ2[ NI2M)ZW]R3
䵖u%-Tu 6ZzuzO~\T)T[oM-Y[>hu36Srͪ6GjmtVqn<:c: -lgGEb# <%x -d'HDeJ*HXyc'X[zJP0Qz>(Ì+0Uu+I
dtʹR<3UoNcJ}Ѿi9P|tB+1f5Nj[d.-ĺfl#ETµ`zTU+%{J3-qZ펃tDui#>M#H'b?!Tү[Nڋzg{*"goVio}[پ]rWv!E̚ytP")"?-=tyOWEYzuw}v#Ϩ[Vۺkj~l-h ٣8XlX} HS?鱼vy{'u? ն>c3PAvom-C|y0 *ګ8kYå&+ ;,<ҵ^շQ NS4+#&SJ,hl j^h;Z{OZFp& 5l6sqЉr2d#q"ޞfgg7ԲOU} Q$)B3YG<]9n?Lݰy+ L榼~S榕rMS~
ggg?Z>خ7lV2 ;Zp;5ִXMr:KS(t`H53Yvbp5y>-.WўwL^7*(dk{}5+Zޘ;o5{Vuvo.)AqXҽFP?pɓf-C J3o>M'@i=֥vR[o:Ki" Ԥj:®FѨY;m'\ݟ(i Ntf-4+QG.A'c#J P6kc/E B!"Ǥȝ{0ǺgӚB|pOR̫LygS+|?qGIf*.wvh|V9ޜK/f y)MfU/4?&leޛgn=G.͜e{
;srE TkO ziUא49O Sм!4pGWtmXN˻~75xD + N:h#
fa{ؼdU_
p So_>c/qG*JA1~+Uм!gfߥ;
ujTNxmՠ=~k+_|]TUnrw~`6Iooٯ}c#n|!e_H,v2Ouެu_2TֳW^孃-)Dr%5*OgC+'eSŃJ +#rNݳ^دȉÊ,tT<4w=SƉJ^TsM 4.6c弢+])G7F (:&qG n/Nl}MwXhJ3)CZ֔JP @ ?|и(֭/t^(UusyƬ CJ:__{cmEe>8>cscJ$X#>㫕6oȨ7&oLd}e]v~Q9[
ڳ}WL Xw_3lY}/צw[m;%e+ ]}wtbW>۬{徂}ƀzؾ v_{NR;`'T4k]As qkw- H zme*]&xjVْ۪=
NT `[ZK7GϷƚqJetҏj/6
-)>S
;CWxVFFFcglN ؙewmބmV[An>vNq }r?zO-/߬^ghJc̸Rqqy93<6g
ʎmu7o_z=h?S}f\~_:qHKQwOiG|TȬR5[$)}Ÿ^TǪԏͦku=L)|۞Pi0D ʳrJmkl{]SQkdXD ODieFpRDu43dаͺYP
N'䞚4f ݍJ*H(o.榡Һ 2 V
^ƭX
d#z\f:tYE
IDATJG
rrOT [5u&b\MceNH5_qjΠ )\£Y=>)f &Y^z% `=f̣첹Fo|dR*ldzz8+h%*O)I5-'yQ=|d;aHĀUuY !'eS2 d *A[V͒W~ҭz4|
d_jq6YW\YwO6.' ټ]'a fff er|sxĘ0p4JS%%DDdJMowz
W^KNt*77Y\_bvحLyF6U|T`/ӲM8,˶N1Ӗt;mbi~=?5wiyc˺>b>z ~=N@?=m[} f_b=ObNDNՏ3nJYo*-[eeAMʯlWjPY^9fP <;*WmӋt h>M'r:5*ˈWDG /=nBN-FmӏkK?]^nFUR
;ݕn 0>j QkA{`/`SSS `7)g@|v;Cஎ 3]ZYY # wCY3 09c͗u0 Zgڞ[-0S)reoݪgwY~hZ Z؎p۱bR ic
l{ĺKkkk r謸? %lX< F'6[3Ptٖ(N=s[,m]fp;c7ox6K+$_' MUlcdD lm,?)H?څxh d\f*D^vYpƯ:巗`eqcKYLXfu +/Rܿ>6irEo
{Ҏ>mPlsSrzm0;qXok tgfrŊ3e Bw3Xyv.5R8 %l
Mcs7Zo 3~-Aȳfeeܚ^$'SbN&u֝HSQc%e+wuoކ=i6QڱzJc2SԀJM'䞚7fIضa_فcz{! [l$.Óz8e%]6%sYYKT+ÎSS}ZާрܺBu_QY
M'r:We(%w& _J5O-z"iMr6:$tZ/ߴ
:R;ˈwXFq]dC۰6F؋dIk2 Ib$Udza_ٖc%3э.<ǺKsss:}4@q@MDjmi4P2%knRYLjfJDi$goc v+`&V۰NZnTllݪ.宙J%;Q`Ðʳ%)lVv `,4}xL76
۩6""A dWrgrsvk)% m4)UIWם mF$[f.#a65)*dm6umaTo"l2̂V
6+Okl6C+٪ɼm& b?=]k/Fm^OyYY˕ )&MGT;ջv2: >$m
Cv궍sA Pɮ4HtZe:$IHZӆtz*6VYFe%)%1)]PTF}T
M+tZ-nD$*x9#IbFJagR߭$ *]PI3)'ZʂO
b4oK=nBN93X-~]e(%w& _J+Qz}**7V.iube͆KD@΄$G Y$ONߩQj N| q~1IrH(?8p<4hnh9
BDҏ_`
@Y>
qCRl3=Q6{̫JF][xؚ6r:|.MLL_' }NgJL~n*[3 v(f
3 ڷo_~ C@7lg˺4<l%>gJgL'^enZI}Թ~ru'\]3Jf5V[aÐʳx%_>QArV1FP6gf UQoM߿~[Q6mmLy;
<-ĥT[ %#8ب_ļX5 Vmʧ@Bɔ+2&4_ EʌwkܹsU駟&0 c.[)% MXqXLzk .\: W*,on8S**/܇Uu+SM)m'R!픻a<6mڼY_h;cjfrXbYDDdJM:_ґqRknǹ08ϖ '( M>8
*6`rp6+V4*t i _I2t%4[$ٺЂ$,cVw?oZ wizŮ曝{
Qr7NŚǶ6ofo>M'd)uYxzIǭ\&$G*nm,[[Ԥ>kF)bA~_Exu0/_/!ݻwl|=g ΤFTo~c=| (#:n6 Uv(MM ""Q&yP9T*+UɈHIGC|5\
mݑrSf@6@cvBy$Kw${sS' M^ɟAMO-dM=s~~͞ OCCAxX{I KEOn5v_9tjkkUVVF0 9ky6+ ynݻjL%-y|>ĽR½ Fbofލi
^ Ke! 穱 5?9A %yz իeM< UVXW ?& `Q % St90jsYIIu~0 >7{}'ueQ[д-ˣt6Xy:a˭+љ8]D{dܚpsqXkWռ|# ϤUJZB : 1Wp
3f~%q|~YX:} 9iOOboS٠Mvf8;'2A@7.s^0YBt[N۷o$]_; $ֳo˖-aOѭ}E5T yTӟ*ʦJlk7'AQX]ilW
:ZȬ sjO2rT˕pfG:QQ[1,jX>'ՙ֥oRYzL *m
s ҧ{dMe,4I.:, |XBUUU:|Jx @bfd()^|ѠsD+:nT_R8JVe:< M>m,Y4k}K_`ܳ!V^kbZիW $ իW ),rV%#Y,WjC)zK_nN&5A ͺ ږ RZOsiSE6}ɽ
ZL-~DWlQY^RqD;P${ qjp:4挎%YяW߭q,{Nkpx- z>A)wT L{W: j`Jph>wk D{ƒLfU
*}mnV"ˠGGicJ%`i:zv7}¿+QQodeT?(q^98y%1U'
?_Ewg}mڴi۷o; `y혮: sj )b'ϧuPzW *:tA %:O|( X#c
K_'ϧcǎͫ1Zm:' KժŲ0=l٢7n Zii?sFeÁy X jyxYz XH= @b< @b:cx~7
@b444 (-3>HUDmcɳ9ў CkyͩMgs'g$}\t] @b 466 Rޤg̙d>U&ö}ĹQ7I_Jƫ{**4^)\x * a7
믽T kԨ]=/@k(^E}UW+5e{_ܠ^Gttbu-8d:& C@@`Dbߓ>&X/ v] i&{*՜M\ ej;^8T?`6j7VP6$Q
Ws}' \i*ȱ kd
Eu5_UaS_~^Z&as뵡HRVt'\JL;7ٖa_
fjiOܧΔۯh>xRB$X%\WgȎ#tY>uƼr
u} 0qMN}GhvYں-^M$
u=Qճ]&ۙtݕhhCu>{z^\(}HWiE G4|螾OP*TVƷq̙Uwp͆@.wI$Up,5q.H ROO
^߭PKk#UΠWU` nZ*6P.KUY_$xl5V kQQAb=WN:E rxܪ
mF6mhz6=f* )utiy|}!cu Tx^ƻ' j]ڔ,\կo~g|Yрb3gl>iHM@}9鎍UsX: ʭ-]
OS#~uT3MRcQs Œzy IDATr]a)f{sīG@͕?[RVۭRehܚz P&
x[Wşt19eUjSQi5OWd۴?D5n;5hJj>V$
=u\7te^I?(VlBJ+z{;?L(BiceW!gg*xsXX.PB9AfOb(u>$#RjmKnUhmIR|LޠB% *Ʒ] !v]lS= _Ыj B3O~YS?!gen}? *fEnTD7*uր<*-Y$[2QUbt#.KCRP ! )g: *-rY,rYu:S'(AUn;TeIkQs`D2mm
떼viO6&dbM~M(ڿ?XI WsncZ5TO TXV35C9?go*y*++# Xi˖- H TT<]z %oEL_pRV.L_=@@ӱ#jwk9}ӓywڶ1>Ma }Ko.X ,y_G&SyMR_IM3ߗë)lk Ӵ1<
pKuζT,Ӛy" 2Y]:w_Qߝʧ1)(c P#9 F)xsB0rߏ= U 7W'юĩd%9=//P_ %3{mWqR͉۸ew6 0w:s/5~[8^tNg< :t `ݾ}[UUU =Ʉ dzvCHbRmjHVO]˸)ͩmNb*m5 z48HS"3Q}O,(Ljx cUGTx.[ /i }U j2')mT*⻠\;џ;4/pX,$O͚5k4::J 0l٢7nHt}ݾ}[t)544$ `X4<)^uL5ffsD;l38wZs o HSN-ر ^{ް5-GΙ_.WxXJڼ[ouy@;|X^iRyB㳗d$wUkSrb|iWJҚ/$)~C7=`T8S? k'W2 Nlǧ(qELJs0G%U@b KúLQ8vK.<θtZ> ?< >wK~ c 4{E\K,kkBŢPl:uQOQ[$}cH{S/]iOXe7C 0aZg%Z?Vu6* kW> kaED m5VP
31GmPOOrbtgZh&C9q#cLGnIգ,EQb1^K%8/ Xzzt41e!Xkݔ..Ў&6&_.W'or
ֺRwUCzCG%)6asgo9v{r^9"~vTk[J=amSl` >V}O.EҶlP?bΘqn9jHշvIr@':cC Kν1չ֥ p,ļXJ6~O_Z/Ҷ9vqw>M,ɾZ:ŜXW*peepHJqZ͟Ol#xs6o,Q
Q@z ]
Qd
`ar+߈ԥ<բJ)&G
l%Z7vxbZӴEXoWM!QqߑRgSzGӵ]Y[Z˵8ʱZ8){aUrL= T%o
Zj+ kՁ c'zwfmX߶CRK?Mȋ%5I ◻VʡD 3PS%}/mj~ڂ/d\mMk\A=يW՚PK,kkB,>O 588 `X4<loƏ HD3= @kF^[Fͫpڜt68b)Ɠ~@w=Ǣ(mMsF_æ jPۧ"@]? Ě`N }+$Y_"HFo_{Ӛ0WruOԵƷIYnJN6 }ge
E VlF6f/'7ZݤP p^}+۾V~_iRFJMoP;>X|{6m2}nC ӱO'J 6jn?3Z5c2dܯjkQXV}'~l @bM0
TT{d-V eFrt'hT,{G^[POli[x`{6mK
3vC/?/g>5 J{Y/kW*ի 5?VS a~}g
}Y,}> 'S? } M- ɸ1EuuU#EϧǓu=ñHxܪM*><3pF]7UFΌvy~oNm(/gdHֳ- 50~]=E+"Ik-C]OTHNe5ohDqeEkel}jP*}FkjVI>HnwY@Bgۦ Sxle@]J{a7f htr,{ >$a}_UAѐ9~MEt/-n J/wi6C2=v"r Xs,-P.s?1E˱u_ƫ6ZZmKCԵzmpdRғ:~ɹgTw\z"ŗ%m2}.߾*M/o@wS jL@ Q|tHzg 7>?Tg2@Od2E5zYK&s,$k[^VM..x\ÿ3o!e[x%Mz=r X *
$ﱶ0rëʋ](YԷz4$F[uWdݦܖmp{5Rת^cQigM_>j5lRqȩe!-Cu!T;V]7Hy*)V
MAirwbRǴP4{cM[~UΡcΚڜC
y$JG5jՀLqSxrT %5I5T ~^ yuWb}xx@ XЬVL}VwS]wUeX>PQ 0kXcOXPYF' UV @N r`*8 $
K,KzP`4W<~_#'D `_ {9xم IENDB` hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/doc-files/logo.png 0000664 0000000 0000000 00000013661 12403265743 0026504 0 ustar 00root root 0000000 0000000 PNG
IHDR R # 0ʨ pHYs
OiCCPPhotoshop ICC profile xڝSgTS=BKKoR RB&*! J!QEEȠQ,
!{kּ> H3Q5 B .@
$p d!s# ~<<+" x M0 B\t8K @zB @F&S `cb P- `' { [! eD h; VE X0 fK9 - 0IWfH 0Q) { `##x FW<+* x<$9E[-qWW. (I+6aa@.y24 x6_-"bbϫp@ t~,/;m%h^ uf@ Wp~<5 j>{-]cK'Xt o(hw?G% fIq ^D$.Tʳ? D*A, `6B$BB
d r`)B(Ͱ *`/@ 4Qhp.U=pa( Aa!ڈbX#!H$ ɈQ"K5H1RT UH =r9\F; 2G1Q= C7F dt1r=6Ыhڏ>C03l0.B8, c˱" VcϱwE 6wB a AHXLXNH $4 7 Q'"K&b21XH,#/{C7$C2'ITFnR#,4H#dk9, +ȅ3![
b@qS(RjJ4e2AURݨT5ZBRQ4u9̓IKhhitݕ NWGw
Ljg(gwLӋT071oUX**|
J&*/Tު UUT^S}FU3S ԖUPSSg;goT?~YYLOCQ_ cx,!k
u5&|v* =9C3J3WRf?qtN (~))4L1e\kXHQG6EYAJ'\'GgSSݧ
M=:.kDwn^Loy }/TmG X $ <5qo< /QC]@Caaᄑ.ȽJtq]zۯ6iܟ4)Y3sCQ? 0k߬~OCOg#/c/Wװwa>>r><72Y_7ȷOo_C#dz %gA[z|!?:eAAA!h쐭!ΑiP~aa~ 'W?pX15wCsDDDޛg1O9-J5*>.j<74?.fYXXIlK 9.*6nl {/]py.,:@LN8A*%w%
y g"/6шC\* NH*Mz쑼5y$3,幄'L
Lݛ:v m2=:1qB!Mggfvˬen/ kY-
BTZ(*geWf͉9+̳ې7ᒶKW- X潬j9(xoʿܔĹdff-[n
ڴ
VE/(ۻCɾUUMfeI?m]Nmq# =TR+G w-
6
U#pDy
:v{ v g /jBFS[b[O>zG 499?rCd&ˮ/~јѡm| x31^Vww O| (hSЧc3- cHRM z% u0 ` : o_F IDATxܙiXTWVQUPK0|D[A4QZ;JL\%ۘ'цČL ,{0⣉ I|TTVUPZ˭pc;c0Թ}wjjjrssw܉~&ǯzk?tN?b Rg'e"u|_6lPPPPS7!mO/ &p\ [W4{Ks~1rS]\\nu0 /$ONKK7== /@!C8Ej}2kF
6c :Z5Td0Anw/Z0"灐(tAp4̀c0𤚏?Dhhh^^!^_T0`dzț/ϝE*Bh $xEkAj"}hE9 CĪmI'Owؽvêsigu~W7 s2&ZXx:եNE 3TXu w y?=X악펯5d+"dZF^E5ԝz` ƛD,*}wXIn ]dqGwWΎ' pa6YG.nהs*d#WZLCǐ ?VYGbv\fY*~ `Yh4J(v; fzOr| ht8 bl6 E !q}Yf;n8 f4an`Q_+8'uG9J5Jz-2~^YL{~رA, al66 vbL&e9$ ϟ/744d28^p8l6^t ϟ *i:|6<9l\}l\1w fyv~/
^7\fc^[뫪vFIHH InS 4M;NRI
bY6...22vhZ (鑨(ݎ8 8 i:8$EQLHHP<ϷHwq X";8(y\S,wџ#94.8D
Xd<U 9C@.Nch dil6!Os9d ,˲%~ot:R0 EQ\0!aV*t:\~fg'Zjo*'K{s9DQT5s1)>#"0AQ / e0b - < BBBA^eff< 4n8\Vj5MVrj@R6-@0LooNIIq8 qqqf9>>`04RHCa>,(vʐ-!W;S&Tt3wR,2eQÍƮG& aR9uT HKK hLQFA]vr ?>***,nw`9**
^ܬF j%RA[:EEyeJ*LsݯT^{HxwyBћ, Ӷxڵk }Qccs粳[ZZ Iڵk-[744,]tQ@]|9''ٳ۶m$id ,L'Ce٢
Vvo<!L IIɏ-E递"""zj4^:))i< ;6}1U-Y ɘ++CEsIECHEi3A.sEiB`[nweg'Ro j8NClÇg'1c9_oX>rSF{ "c_d "aÛ8 [J-J W\Y|%Kn0 a= ~=66vZ5rrr `ƍ^} !lW˔Z=xxR QҦ;3'wMm/g>zhqqҥKwQPPp
G!$$$TSSCtnnnii߁?i
_OLȖQVYnJ"M=U>kXK#kii)EEEcǎݵkpղ wo&7U>j60G#) 'gL帠!çN.ٳ{3>}z C0 lۭjEV\Y[[RIY655kfR07݈LJ+U^=LFR_Θ>㷋?>v{{1c
Š Р (%QYYĉzcMom qj\3}e(m D*2B2c'>58Jj["##:߸q`01bqϞ= aHup`Eɮ;Pc jf+j+o<V P֮[ Y֔۷˗/uNJJ;w@dJMM<,XpAgyr
>Bȹt^nDBXJ!IJ\oG rfwۏ-&0sԩ i'IEAVZ%Ȋ+}Q+**LW_}g+lmm۴iSaaիϟ?_YYyqjk ?~8##|͚5*
{87% Ąq I:s "m-{9 /~(M4eSNIh3//СCF1##!0ɓ'ܹpD Wcǡ IENDB` hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/doc-files/styles.css 0000664 0000000 0000000 00000002574 12403265743 0027074 0 ustar 00root root 0000000 0000000 .header ul li, .footer ul li {
list-style: disc;
font-size: 1em;
}
table.nice a,
table.nice a:link,
table.nice a:visited {
border: none;
}
img {
border: 0;
margin-top: .5em;
}
table.nice {
margin: 1em auto;
border-collapse: collapse;
}
caption {
color: #9ba9b4;
font-size: .94em;
letter-spacing: .1em;
margin: 1em 0 0 0;
padding: 0;
caption-side: top;
text-align: center;
}
table.nice tr.odd td {
background: #f0f0f5;
}
table.nice tr.odd .column1 {
background: #f0f0f5;
font-weight: bold;
}
table.nice tr .column1 {
background: #f9fcfe;
font-weight: bold;
}
table.nice td {
color: #526678;
border: 1px solid #cfe4f8;
padding: .3em 1em;
text-align: center;
}
table.nice th {
border: 1px solid #cfe4f8;
font-weight: normal;
color: #526678;
text-align: left;
padding: .3em 1em;
}
table.nice thead th {
background: #e8e8f0;
text-align: center;
font: bold 1.2em/ 2em Arial, Helvetica, sans-serif;
color: #66a3d3
}
table.nice tfoot th {
text-align: center;
background: #f4f9fe;
}
table.nice tfoot th strong {
font: bold 1.2em Arial, Helvetica, sans-serif;
margin: .5em .5em .5em 0;
color: #66a3d3;
}
table.nice tfoot th em {
color: #f03b58;
font-weight: bold;
font-size: 1.1em;
font-style: normal;
}
table.nice thead th.empty {
border-top: none;
border-left: none;
background: white;
}
.red {
color: red;
}
.nobr {
white-space: nowrap;
} hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/hash/ 0000775 0000000 0000000 00000000000 12403265743 0024105 5 ustar 00root root 0000000 0000000 hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/hash/MurmurHash3.java 0000664 0000000 0000000 00000001575 12403265743 0027136 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc.hash;
/**
* Hash routines for primitive types. The implementation is based on the finalization step
* from Austin Appleby's MurmurHash3.
*
* @see "http://sites.google.com/site/murmurhash/"
*/
public final class MurmurHash3
{
private MurmurHash3()
{
// no instances.
}
/**
* Hashes a 4-byte sequence (Java int).
*/
public static int hash(int k)
{
k ^= k >>> 16;
k *= 0x85ebca6b;
k ^= k >>> 13;
k *= 0xc2b2ae35;
k ^= k >>> 16;
return k;
}
/**
* Hashes an 8-byte sequence (Java long).
*/
public static long hash(long k)
{
k ^= k >>> 33;
k *= 0xff51afd7ed558ccdL;
k ^= k >>> 33;
k *= 0xc4ceb9fe1a85ec53L;
k ^= k >>> 33;
return k;
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/hash/package.html 0000664 0000000 0000000 00000000640 12403265743 0026366 0 ustar 00root root 0000000 0000000
High Performance Primitive Collections (HPPC): hash functions
Various hash functions primarily for use in associative containers.
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/mutables/ 0000775 0000000 0000000 00000000000 12403265743 0024776 5 ustar 00root root 0000000 0000000 hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/mutables/ByteHolder.java 0000664 0000000 0000000 00000000712 12403265743 0027702 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc.mutables;
/**
* byte holder.
*/
public final class ByteHolder
{
public byte value;
public ByteHolder()
{
}
public ByteHolder(byte value)
{
this.value = value;
}
public int hashCode()
{
return value;
}
public boolean equals(Object other)
{
return (other instanceof ByteHolder) && value == ((ByteHolder) other).value;
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/mutables/CharHolder.java 0000664 0000000 0000000 00000000702 12403265743 0027653 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc.mutables;
/**
* char holder.
*/
public final class CharHolder
{
public char value;
public CharHolder()
{
}
public CharHolder(char value)
{
this.value = value;
}
public int hashCode()
{
return value;
}
public boolean equals(Object other)
{
return (other instanceof CharHolder) && value == ((CharHolder) other).value;
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/mutables/DoubleHolder.java 0000664 0000000 0000000 00000001173 12403265743 0030213 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc.mutables;
/**
* double holder.
*/
public final class DoubleHolder
{
public double value;
public DoubleHolder()
{
}
public DoubleHolder(double value)
{
this.value = value;
}
public int hashCode()
{
final long bits = Double.doubleToLongBits(value);
return (int) (bits ^ (bits >>> 32));
}
public boolean equals(Object other)
{
return (other instanceof DoubleHolder) &&
Double.doubleToLongBits(value) ==
Double.doubleToLongBits(((DoubleHolder) other).value);
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/mutables/FloatHolder.java 0000664 0000000 0000000 00000001056 12403265743 0030046 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc.mutables;
/**
* float holder.
*/
public final class FloatHolder
{
public float value;
public FloatHolder()
{
}
public FloatHolder(float value)
{
this.value = value;
}
public int hashCode()
{
return Float.floatToIntBits(value);
}
public boolean equals(Object other)
{
return (other instanceof FloatHolder) &&
Float.floatToIntBits(value) ==
Float.floatToIntBits(((FloatHolder) other).value);
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/mutables/IntHolder.java 0000664 0000000 0000000 00000000666 12403265743 0027541 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc.mutables;
/**
* int holder.
*/
public final class IntHolder
{
public int value;
public IntHolder()
{
}
public IntHolder(int value)
{
this.value = value;
}
public int hashCode()
{
return value;
}
public boolean equals(Object other)
{
return (other instanceof IntHolder) && value == ((IntHolder) other).value;
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/mutables/LongHolder.java 0000664 0000000 0000000 00000000726 12403265743 0027703 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc.mutables;
/**
* long holder.
*/
public final class LongHolder
{
public long value;
public LongHolder()
{
}
public LongHolder(long value)
{
this.value = value;
}
public int hashCode()
{
return (int)(value ^ (value >>> 32));
}
public boolean equals(Object other)
{
return (other instanceof LongHolder) && value == ((LongHolder) other).value;
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/mutables/ShortHolder.java 0000664 0000000 0000000 00000000706 12403265743 0030101 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc.mutables;
/**
* short holder.
*/
public final class ShortHolder
{
public short value;
public ShortHolder()
{
}
public ShortHolder(short value)
{
this.value = value;
}
public int hashCode()
{
return value;
}
public boolean equals(Object other)
{
return (other instanceof ShortHolder) && value == ((ShortHolder) other).value;
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/mutables/package.html 0000664 0000000 0000000 00000000623 12403265743 0027260 0 ustar 00root root 0000000 0000000
High Performance Primitive Collections (HPPC): mutables
Object data holders for primitive types (mutable internals).
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/overview.html 0000664 0000000 0000000 00000022345 12403265743 0025724 0 ustar 00root root 0000000 0000000
High Performance Primitive Collections (HPPC)
High Performance Primitive Collections (HPPC) library provides
typical data structures (lists, stacks, maps)
template-generated for all Java primitive types
(byte, int, etc.) to conserve
memory and boost performance.
Why HPPC?
The Java Collections package is in many ways excellent, but it cannot
be used for primitive types and autoboxing introduced in Java 1.5
kills the runtime performance (increased memory use, garbage collector overhead).
This library has different design goals than Java Collections (and many other
collection packages). For example, the internals of each class are open
and subject to free hacking and tuning up to one's wishes.
Why not other primitive collection libraries?
There are a few projects implementing collections over primitive types:
fastutil,
PCJ,
GNU Trove,
Apache Mahout (ported COLT collections),
Apache Primitive Collections.
Some of these are LGPL-ed, a license type many commercial companies
tend to avoid at all costs; other projects above are no longer
maintained or complete. There is also a tendency to write tightly encapsulated
code (private internals), implementing the API of standard Java packages and
striving for fast error-recovery. Although these are good programming
practices, they are not always practical (in many computationally intense applications
access to the collection class' internals is a bliss). HPPC has a slightly
different set of goals. If you need Java collections compliance, try
fastutil, it is very, very good.
Assumptions and goals of HPPC
We assume that:
- The programmer knows what he's doing and may wish to access internal
storage of a given collection's class directly (not using predefined
iterators, for example).
- Vast majority of scenarios use single-threaded access. There is little
point in repeated verification of concurrent modifications, for example.
- The programs (algorithms) that use primitive collections are unit-tested
and regression-tested during development, so their behavior in production
systems does not have to be restrictively verified (we can assume the code
using the collection class won't violate the given set of assertions).
From these assumptions stem the following design drivers:
- Data types in the HPPC are as simple as possible and expose
internal storage for any optimisations one may wish to do from within the
end-application code.
- Verification of parameter and state validity is done optionally
using assertions. This means that contracts are only checked if requested at
runtime (using Java 1.4+
-ea switch). When the algorithm is tested and verified,
it can run with no additional overhead from contract checks.
- We tried to avoid complex interface hierarchies, although certain
interfaces are defined for clarity. The programmer should still choose
a proper data structure at design-time and he should know what he's doing.
- HPPC provides utilities for the most common tasks like filtering, iterating
or joining collections, but these utilities are usually more expensive than implementing
a low-level direct access to the data storage (which may be done if needed).
- There is no special support for data serialization.
- The implementation is not thread safe and does not attempt to provide
fast-failing concurrency problems detection.
Design and implementation assumptions
- We want HPPC class templates to be implemented using regular Java (with generics)
so that typical programming tools can be used for development, testing, etc.
- We want HPPC class templates to be usable as generic-collection classes (for boxed
numeric types or any other
Object types), but at the same time we want
specialized classes automatically-generated for primitive-types
(to limit memory consumption and boost performance due to JIT optimisations).
Interfaces and their relation to Java Collections API
HPPC is not strictly modeled after Java Collections API, although we did
try to make the APIs look similar enough for comfortable use.
One particular thing largerly missing in HPPC are view projections
(sublists or views over the collection of keys or values). Certain classes provide such views
(like {@linkplain com.carrotsearch.hppc.ObjectObjectOpenHashMap
ObjectObjectOpenHashMap}), but for the most part, specific methods are
provided that accept ranges or closure-like filters. If performance is still unsatisfactory,
the internals of each class are available for direct manipulation.
Rough relationships between Java Collections classes and HPPC classes are
presented in the table below.
Relationships between HPPC and Java Collections.
|
Java Collections |
HPPC (primitives) |
HPPC (generics) |
| bit sets |
java.util.BitSet |
BitSet |
n/a |
| array-backed lists |
java.util.ArrayList, java.util.Vector |
[type]ArrayList |
{@linkplain com.carrotsearch.hppc.ObjectArrayList
ObjectArrayList<T>} |
| stacks |
java.util.Stack |
[type]Stack |
{@linkplain com.carrotsearch.hppc.ObjectStack
ObjectStack<T>} |
| deques |
java.util.ArrayDeque |
[type]ArrayDeque |
{@linkplain com.carrotsearch.hppc.ObjectArrayDeque
ObjectArrayDeque<T>} |
| hash maps (dictionaries) |
java.util.HashMap |
[keyType][valueType]OpenHashMap |
{@linkplain com.carrotsearch.hppc.ObjectObjectOpenHashMap
ObjectObjectOpenHashMap<K, V>}
[keyType]ObjectOpenHashMap<V>
Object[valueType]OpenHashMap<K>
|
The method-level API of the corresponding types is also similar, but distinct
differences exist (consult the JavaDoc of each class).
Interfaces and container inheritance
HPPC's interfaces are modeled to encapsulate
the common functionality enforced from all the classes that
implement a given interface. The interface hierarchy is loosely inspired by STL.
An overview of interfaces and their relationship to data structures implemented
in HPPC is depicted graphically in {@link com.carrotsearch.hppc.ObjectContainer}.
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/predicates/ 0000775 0000000 0000000 00000000000 12403265743 0025305 5 ustar 00root root 0000000 0000000 hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/predicates/GuavaPredicateAdapter.java 0000664 0000000 0000000 00000001036 12403265743 0032335 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc.predicates;
import com.google.common.base.Predicate;
/**
* An adapter between Guava's {@link Predicate} and HPPC's {@link ObjectPredicate}.
*/
public class GuavaPredicateAdapter implements ObjectPredicate
{
private final Predicate predicate;
public GuavaPredicateAdapter(com.google.common.base.Predicate predicate)
{
this.predicate = predicate;
}
public boolean apply(KType value)
{
return predicate.apply(value);
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/predicates/package.html 0000664 0000000 0000000 00000000766 12403265743 0027577 0 ustar 00root root 0000000 0000000
High Performance Primitive Collections (HPPC): predicates
Predicates that return a boolean true/ false for
a given value. Useful in pseudo-closures applied to values of containers.
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/procedures/ 0000775 0000000 0000000 00000000000 12403265743 0025335 5 ustar 00root root 0000000 0000000 hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/procedures/GuavaProcedureAdapter.java 0000664 0000000 0000000 00000001024 12403265743 0032412 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc.procedures;
import com.google.common.base.Predicate;
/**
* An adapter between Guava's {@link Predicate} and HPPC's {@link ObjectProcedure}.
*/
public class GuavaProcedureAdapter implements ObjectProcedure
{
private final Predicate predicate;
public GuavaProcedureAdapter(com.google.common.base.Predicate predicate)
{
this.predicate = predicate;
}
public void apply(KType value)
{
predicate.apply(value);
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/procedures/package.html 0000664 0000000 0000000 00000000662 12403265743 0027622 0 ustar 00root root 0000000 0000000
High Performance Primitive Collections (HPPC): procedures
Procedures apply to keys and/or values in a container.
Useful in pseudo-closures.
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/sorting/ 0000775 0000000 0000000 00000000000 12403265743 0024647 5 ustar 00root root 0000000 0000000 hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/sorting/IndirectComparator.java 0000664 0000000 0000000 00000011625 12403265743 0031310 0 ustar 00root root 0000000 0000000
package com.carrotsearch.hppc.sorting;
import java.util.Comparator;
/**
* Compare objects at two given indices and return the result of their comparison
* consistent with {@link Comparator}'s contract.
*
* Beware of the return (int - int) idiom, it is usually broken if
* arbitrary numbers can appear on input. Use regular comparison operations - they are
* very fast anyway.
*/
public interface IndirectComparator
{
/**
* See class documentation.
*/
public int compare(int indexA, int indexB);
/**
* A natural-order comparator for integers.
*/
public static class AscendingIntComparator implements IndirectComparator
{
private final int [] array;
public AscendingIntComparator(int [] array)
{
this.array = array;
}
public int compare(int indexA, int indexB)
{
final int a = array[indexA];
final int b = array[indexB];
if (a < b) return -1;
if (a > b) return 1;
return 0;
}
}
/**
* A reverse-order comparator for integers.
*/
public static class DescendingIntComparator extends AscendingIntComparator
{
public DescendingIntComparator(int [] array)
{
super(array);
}
public final int compare(int indexA, int indexB)
{
return -super.compare(indexA, indexB);
}
}
/**
* A natural-order comparator for integers.
*/
public static class AscendingShortComparator implements IndirectComparator
{
private final short [] array;
public AscendingShortComparator(short [] array)
{
this.array = array;
}
public int compare(int indexA, int indexB)
{
final short a = array[indexA];
final short b = array[indexB];
if (a < b) return -1;
if (a > b) return 1;
return 0;
}
}
/**
* A reverse-order comparator for shorts.
*/
public static class DescendingShortComparator extends AscendingShortComparator
{
public DescendingShortComparator(short [] array)
{
super(array);
}
public final int compare(int indexA, int indexB)
{
return -super.compare(indexA, indexB);
}
}
/**
* A natural-order comparator for doubles.
*/
public static class AscendingDoubleComparator implements IndirectComparator
{
private final double [] array;
public AscendingDoubleComparator(double [] array)
{
this.array = array;
}
public int compare(int indexA, int indexB)
{
final double a = array[indexA];
final double b = array[indexB];
if (a < b) return -1;
if (a > b) return 1;
return 0;
}
}
/**
* A reverse-order comparator for doubles.
*/
public static class DescendingDoubleComparator extends AscendingDoubleComparator
{
public DescendingDoubleComparator(double [] array)
{
super(array);
}
public final int compare(int indexA, int indexB)
{
return -super.compare(indexA, indexB);
}
}
/**
* A natural-order comparator for floats.
*/
public static class AscendingFloatComparator implements IndirectComparator
{
private final float [] array;
public AscendingFloatComparator(float [] array)
{
this.array = array;
}
public int compare(int indexA, int indexB)
{
final float a = array[indexA];
final float b = array[indexB];
if (a < b) return -1;
if (a > b) return 1;
return 0;
}
}
/**
* A reverse-order comparator for floats.
*/
public static class DescendingFloatComparator extends AscendingFloatComparator
{
public DescendingFloatComparator(float [] array)
{
super(array);
}
public final int compare(int indexA, int indexB)
{
return -super.compare(indexA, indexB);
}
}
/**
* A delegating comparator for object types.
*/
public final static class DelegatingComparator implements IndirectComparator
{
private final T [] array;
private final Comparator delegate;
public DelegatingComparator(T [] array, Comparator delegate)
{
this.array = array;
this.delegate = delegate;
}
public final int compare(int indexA, int indexB)
{
return delegate.compare(array[indexA], array[indexB]);
}
@Override
public String toString()
{
return this.getClass().getSimpleName() + " -> " + delegate;
}
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/sorting/IndirectSort.java 0000664 0000000 0000000 00000010610 12403265743 0030121 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc.sorting;
import java.util.Comparator;
/**
* Sorting routines that return an array of sorted indices implied by a given comparator
* rather than move elements of whatever the comparator is using for comparisons.
*
* A practical use case for this class is when the index of an array is meaningful and one
* wants to acquire the order of values in that array. None of the methods in Java
* Collections would provide such functionality directly and creating a collection of
* boxed {@link Integer} objects for indices seems to be too costly.
*/
public final class IndirectSort
{
/**
* Minimum window length to apply insertion sort in merge sort.
*/
static int MIN_LENGTH_FOR_INSERTION_SORT = 30;
/**
* No instantiation.
*/
private IndirectSort()
{
// No instantiation.
}
/**
* Returns the order of elements between indices start and
* length, as indicated by the given comparator.
*
* This routine uses merge sort. It is guaranteed to be stable.
*
*/
public static int [] mergesort(int start, int length, IndirectComparator comparator)
{
final int [] src = createOrderArray(start, length);
if (length > 1)
{
final int [] dst = (int []) src.clone();
topDownMergeSort(src, dst, 0, length, comparator);
return dst;
}
return src;
}
/**
* Returns the order of elements between indices start and
* length, as indicated by the given comparator. This method
* is equivalent to calling {@link #mergesort(int, int, IndirectComparator)} with
* {@link IndirectComparator.DelegatingComparator}.
*
* This routine uses merge sort. It is guaranteed to be stable.
*
*/
public static int [] mergesort(T [] input, int start, int length,
Comparator comparator)
{
return mergesort(start, length, new IndirectComparator.DelegatingComparator(
input, comparator));
}
/**
* Perform a recursive, descending merge sort.
*
* @param fromIndex inclusive
* @param toIndex exclusive
*/
private static void topDownMergeSort(int [] src, int [] dst, int fromIndex, int toIndex,
IndirectComparator comp)
{
if (toIndex - fromIndex <= MIN_LENGTH_FOR_INSERTION_SORT)
{
insertionSort(fromIndex, toIndex - fromIndex, dst, comp);
return;
}
final int mid = (fromIndex + toIndex) >>> 1;
topDownMergeSort(dst, src, fromIndex, mid, comp);
topDownMergeSort(dst, src, mid, toIndex, comp);
/*
* Both splits in of src are now sorted.
*/
if (comp.compare(src[mid - 1], src[mid]) <= 0)
{
/*
* If the lowest element in upper slice is larger than the highest element in
* the lower slice, simply copy over, the data is fully sorted.
*/
System.arraycopy(src, fromIndex, dst, fromIndex, toIndex - fromIndex);
}
else
{
/*
* Run a manual merge.
*/
for (int i = fromIndex, j = mid, k = fromIndex; k < toIndex; k++)
{
if (j == toIndex || (i < mid && comp.compare(src[i], src[j]) <= 0))
{
dst[k] = src[i++];
}
else
{
dst[k] = src[j++];
}
}
}
}
/**
* Internal insertion sort for ints.
*/
private static void insertionSort(final int off, final int len, int [] order,
IndirectComparator intComparator)
{
for (int i = off + 1; i < off + len; i++)
{
final int v = order[i];
int j = i, t;
while (j > off && intComparator.compare(t = order[j - 1], v) > 0)
{
order[j--] = t;
}
order[j] = v;
}
}
/**
* Creates the initial order array.
*/
private static int [] createOrderArray(final int start, final int length)
{
final int [] order = new int [length];
for (int i = 0; i < length; i++)
{
order[i] = start + i;
}
return order;
}
}
hppc-0.6.1/hppc-core/src/main/java/com/carrotsearch/hppc/sorting/package.html 0000664 0000000 0000000 00000000605 12403265743 0027131 0 ustar 00root root 0000000 0000000
High Performance Primitive Collections (HPPC): sorting
Indirect sorting and various sorting utilities.
hppc-0.6.1/hppc-core/src/main/javadoc/ 0000775 0000000 0000000 00000000000 12403265743 0017460 5 ustar 00root root 0000000 0000000 hppc-0.6.1/hppc-core/src/main/javadoc/logo.png 0000664 0000000 0000000 00000013661 12403265743 0021135 0 ustar 00root root 0000000 0000000 PNG
IHDR R # 0ʨ pHYs
OiCCPPhotoshop ICC profile xڝSgTS=BKKoR RB&*! J!QEEȠQ,
!{kּ> H3Q5 B .@
$p d!s# ~<<+" x M0 B\t8K @zB @F&S `cb P- `' { [! eD h; VE X0 fK9 - 0IWfH 0Q) { `##x FW<+* x<$9E[-qWW. (I+6aa@.y24 x6_-"bbϫp@ t~,/;m%h^ uf@ Wp~<5 j>{-]cK'Xt o(hw?G% fIq ^D$.Tʳ? D*A, `6B$BB
d r`)B(Ͱ *`/@ 4Qhp.U=pa( Aa!ڈbX#!H$ ɈQ"K5H1RT UH =r9\F; 2G1Q= C7F dt1r=6Ыhڏ>C03l0.B8, c˱" VcϱwE 6wB a AHXLXNH $4 7 Q'"K&b21XH,#/{C7$C2'ITFnR#,4H#dk9, +ȅ3![
b@qS(RjJ4e2AURݨT5ZBRQ4u9̓IKhhitݕ NWGw
Ljg(gwLӋT071oUX**|
J&*/Tު UUT^S}FU3S ԖUPSSg;goT?~YYLOCQ_ cx,!k
u5&|v* =9C3J3WRf?qtN (~))4L1e\kXHQG6EYAJ'\'GgSSݧ
M=:.kDwn^Loy }/TmG X $ <5qo< /QC]@Caaᄑ.ȽJtq]zۯ6iܟ4)Y3sCQ? 0k߬~OCOg#/c/Wװwa>>r><72Y_7ȷOo_C#dz %gA[z|!?:eAAA!h쐭!ΑiP~aa~ 'W?pX15wCsDDDޛg1O9-J5*>.j<74?.fYXXIlK 9.*6nl {/]py.,:@LN8A*%w%
y g"/6шC\* NH*Mz쑼5y$3,幄'L
Lݛ:v m2=:1qB!Mggfvˬen/ kY-
BTZ(*geWf͉9+̳ې7ᒶKW- X潬j9(xoʿܔĹdff-[n
ڴ
VE/(ۻCɾUUMfeI?m]Nmq# =TR+G w-
6
U#pDy
:v{ v g /jBFS[b[O>zG 499?rCd&ˮ/~јѡm| x31^Vww O| (hSЧc3- cHRM z% u0 ` : o_F IDATxܙiXTWVQUPK0|D[A4QZ;JL\%ۘ'цČL ,{0⣉ I|TTVUPZ˭pc;c0Թ}wjjjrssw܉~&ǯzk?tN?b Rg'e"u|_6lPPPPS7!mO/ &p\ [W4{Ks~1rS]\\nu0 /$ONKK7== /@!C8Ej}2kF
6c :Z5Td0Anw/Z0"灐(tAp4̀c0𤚏?Dhhh^^!^_T0`dzț/ϝE*Bh $xEkAj"}hE9 CĪmI'Owؽvêsigu~W7 s2&ZXx:եNE 3TXu w y?=X악펯5d+"dZF^E5ԝz` ƛD,*}wXIn ]dqGwWΎ' pa6YG.nהs*d#WZLCǐ ?VYGbv\fY*~ `Yh4J(v; fzOr| ht8 bl6 E !q}Yf;n8 f4an`Q_+8'uG9J5Jz-2~^YL{~رA, al66 vbL&e9$ ϟ/744d28^p8l6^t ϟ *i:|6<9l\}l\1w fyv~/
^7\fc^[뫪vFIHH InS 4M;NRI
bY6...22vhZ (鑨(ݎ8 8 i:8$EQLHHP<ϷHwq X";8(y\S,wџ#94.8D
Xd<U 9C@.Nch dil6!Os9d ,˲%~ot:R0 EQ\0!aV*t:\~fg'Zjo*'K{s9DQT5s1)>#"0AQ / e0b - < BBBA^eff< 4n8\Vj5MVrj@R6-@0LooNIIq8 qqqf9>>`04RHCa>,(vʐ-!W;S&Tt3wR,2eQÍƮG& aR9uT HKK hLQFA]vr ?>***,nw`9**
^ܬF j%RA[:EEyeJ*LsݯT^{HxwyBћ, Ӷxڵk }Qccs粳[ZZ Iڵk-[744,]tQ@]|9''ٳ۶m$id ,L'Ce٢
Vvo<!L IIɏ-E递"""zj4^:))i< ;6}1U-Y ɘ++CEsIECHEi3A.sEiB`[nweg'Ro j8NClÇg'1c9_oX>rSF{ "c_d "aÛ8 [J-J W\Y|%Kn0 a= ~=66vZ5rrr `ƍ^} !lW˔Z=xxR QҦ;3'wMm/g>zhqqҥKwQPPp
G!$$$TSSCtnnnii߁?i
_OLȖQVYnJ"M=U>kXK#kii)EEEcǎݵkpղ wo&7U>j60G#) 'gL帠!çN.ٳ{3>}z C0 lۭjEV\Y[[RIY655kfR07݈LJ+U^=LFR_Θ>㷋?>v{{1c
Š Р (%QYYĉzcMom qj\3}e(m D*2B2c'>58Jj["##:߸q`01bqϞ= aHup`Eɮ;Pc jf+j+o<V P֮[ Y֔۷˗/uNJJ;w@dJMM<,XpAgyr
>Bȹt^nDBXJ!IJ\oG rfwۏ-&0sԩ i'IEAVZ%Ȋ+}Q+**LW_}g+lmm۴iSaaիϟ?_YYyqjk ?~8##|͚5*
{87% Ąq I:s "m-{9 /~(M4eSNIh3//СCF1##!0ɓ'ܹpD Wcǡ IENDB` hppc-0.6.1/hppc-core/src/main/javadoc/stylesheet.css 0000664 0000000 0000000 00000005531 12403265743 0022367 0 ustar 00root root 0000000 0000000 /* Javadoc style sheet */
@import url("com/carrotsearch/hppc/doc-files/styles.css");
/* Define colors, fonts and other style attributes here to override the defaults */
/* Page background color */
body { font-family: Trebuchet MS, Arial;
background-color: white;
font-size: 10pt;
}
td { font-family: Trebuchet MS,Arial;
font-size: 10pt;
}
table {
border-collapse: collapse;
}
a.logo {
float: right;
padding-left: 10px;
position: relative;
width: 82px;
height: 35px;
background: url('com/carrotsearch/hppc/doc-files/logo.png');
background-repeat: no-repeat;
background-position: right top;
}
.FrameTitleFont #header {
display: none;
}
table .TableHeadingColor td,
table .TableHeadingColor th,
table .TableSubHeadingColor td,
table .TableSubHeadingColor th,
table .TableRowColor td,
table .TableRowColor th
{
border: 1px solid #cccccc;
}
/* Table colors */
.TableHeadingColor { background: #e8e8e8 }
.TableSubHeadingColor { background: #e8e8e8 }
.TableRowColor { background: #FFFFFF }
/* Font used in left-hand frame lists */
.FrameTitleFont { font-size: normal;}
.FrameHeadingFont { font-size: normal;}
.FrameItemFont { font-size: normal;}
/* Example of smaller, sans-serif font in frames */
/* .FrameItemFont { font-size: 10pt; font-family: Helvetica, Arial, sans-serif } */
/* Navigation bar fonts and colors */
.NavBarCell1 { background-color:#F4F4F4;}
.NavBarCell1Rev { background-color:silver;}
.NavBarFont1 { color:#000000;}
.NavBarFont1Rev { color:#FFFFFF;}
.NavBarCell2 { background-color:#FFFFFF;}
.NavBarCell3 { background-color:#FFFFFF;}
A {
color: #003399;
}
A:active {
color: #003399;
}
A:visited {
color: #888888;
}
P, OL, UL, LI, DL, DT, DD, BLOCKQUOTE {
color: #000000;
}
TD, TH, SPAN {
color: #000000;
}
BLOCKQUOTE {
margin-right: 0px;
}
TT {
font-size: 90%;
font-family: "Courier New", Courier, monospace;
color: #000000;
}
PRE {
font-size: 90%;
padding: 5px;
border-style: solid;
border-width: 1px;
border-color: #CCCCCC;
background-color: #F4F4F4;
}
UL, OL, LI {
list-style: disc;
}
HR {
width: 100%;
height: 1px;
background-color: #CCCCCC;
border-width: 0px;
padding: 0px;
color: #CCCCCC;
}
.variablelist {
padding-top: 10;
padding-bottom:10;
margin:0;
}
.itemizedlist, UL {
padding-top: 0;
padding-bottom:0;
margin:0;
}
.term {
font-weight:bold;
}
a.download-small, a.view-small {
background-position: 0 4px;
background-repeat: no-repeat;
padding-bottom: 2px;
padding-left: 72px;
}
a.download-small {
background-image: url(button-download-small.png);
}
a.view-small {
background-image: url(button-view-small.png);
}
h1, h2 {
margin-bottom: 0.2em;
margin-top: 1em;
}
p {
margin-top: 0;
}
a.source-link {
float:right;
position:relative;
top:-1em;
}
hppc-0.6.1/hppc-core/src/main/templates/ 0000775 0000000 0000000 00000000000 12403265743 0020047 5 ustar 00root root 0000000 0000000 hppc-0.6.1/hppc-core/src/main/templates/com/ 0000775 0000000 0000000 00000000000 12403265743 0020625 5 ustar 00root root 0000000 0000000 hppc-0.6.1/hppc-core/src/main/templates/com/carrotsearch/ 0000775 0000000 0000000 00000000000 12403265743 0023305 5 ustar 00root root 0000000 0000000 hppc-0.6.1/hppc-core/src/main/templates/com/carrotsearch/hppc/ 0000775 0000000 0000000 00000000000 12403265743 0024237 5 ustar 00root root 0000000 0000000 hppc-0.6.1/hppc-core/src/main/templates/com/carrotsearch/hppc/AbstractKTypeCollection.java 0000664 0000000 0000000 00000006372 12403265743 0031646 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc;
import java.util.Arrays;
import com.carrotsearch.hppc.cursors.KTypeCursor;
import com.carrotsearch.hppc.predicates.KTypePredicate;
/**
* Common superclass for collections.
*/
/*! ${TemplateOptions.generatedAnnotation} !*/
abstract class AbstractKTypeCollection implements KTypeCollection
{
/**
* Default implementation uses a predicate for removal.
*/
/* #if ($TemplateOptions.KTypeGeneric) */
@SuppressWarnings("unchecked")
/* #end */
@Override
public int removeAll(final KTypeLookupContainer c)
{
// We know c holds sub-types of KType and we're not modifying c, so go unchecked.
final KTypeContainer c2 = (KTypeContainer) c;
return this.removeAll(new KTypePredicate()
{
public boolean apply(KType k)
{
return c2.contains(k);
}
});
}
/**
* Default implementation uses a predicate for retaining.
*/
/* #if ($TemplateOptions.KTypeGeneric) */
@SuppressWarnings("unchecked")
/* #end */
@Override
public int retainAll(final KTypeLookupContainer c)
{
// We know c holds sub-types of KType and we're not modifying c, so go unchecked.
final KTypeContainer c2 = (KTypeContainer) c;
return this.removeAll(new KTypePredicate()
{
public boolean apply(KType k)
{
return !c2.contains(k);
}
});
}
/**
* Default implementation redirects to {@link #removeAll(KTypePredicate)}
* and negates the predicate.
*/
@Override
public int retainAll(final KTypePredicate predicate)
{
return removeAll(new KTypePredicate()
{
public boolean apply(KType value)
{
return !predicate.apply(value);
};
});
}
/**
* Default implementation of copying to an array.
*/
@Override
/*!#if ($TemplateOptions.KTypePrimitive)
public KType [] toArray()
#else !*/
@SuppressWarnings("unchecked")
public KType [] toArray(Class clazz)
/*! #end !*/
{
final int size = size();
final KType [] array =
/*!#if ($TemplateOptions.KTypePrimitive)
new KType [size];
#else !*/
(KType []) java.lang.reflect.Array.newInstance(clazz, size);
/*!#end !*/
int i = 0;
for (KTypeCursor c : this)
{
array[i++] = c.value;
}
return array;
}
/* #if ($TemplateOptions.KTypeGeneric) */
@Override
public Object[] toArray()
{
final Object [] array = new Object [size()];
int i = 0;
for (KTypeCursor c : this)
{
array[i++] = c.value;
}
return array;
}
/* #end */
/**
* Convert the contents of this container to a human-friendly string.
*/
@Override
public String toString()
{
return Arrays.toString(this.toArray());
}
}
hppc-0.6.1/hppc-core/src/main/templates/com/carrotsearch/hppc/HashContainerUtils.java 0000664 0000000 0000000 00000003500 12403265743 0030647 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc;
import java.util.concurrent.Callable;
import com.carrotsearch.hppc.hash.MurmurHash3;
final class HashContainerUtils
{
/**
* Maximum capacity for an array that is of power-of-two size and still
* allocable in Java (not a negative int).
*/
final static int MAX_CAPACITY = 0x80000000 >>> 1;
/**
* Minimum capacity for a hash container.
*/
final static int MIN_CAPACITY = 4;
/**
* Default capacity for a hash container.
*/
final static int DEFAULT_CAPACITY = 16;
/**
* Default load factor.
*/
final static float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* Computer static perturbations table.
*/
final static int [] PERTURBATIONS = new Callable() {
public int[] call() {
int [] result = new int [32];
for (int i = 0; i < result.length; i++) {
result[i] = MurmurHash3.hash(17 + i);
}
return result;
}
}.call();
/**
* Round the capacity to the next allowed value.
*/
static int roundCapacity(int requestedCapacity)
{
if (requestedCapacity > MAX_CAPACITY)
return MAX_CAPACITY;
return Math.max(MIN_CAPACITY, BitUtil.nextHighestPowerOfTwo(requestedCapacity));
}
/**
* Return the next possible capacity, counting from the current buffers'
* size.
*/
static int nextCapacity(int current)
{
assert current > 0 && Long.bitCount(current) == 1 : "Capacity must be a power of two.";
if (current < MIN_CAPACITY / 2)
{
current = MIN_CAPACITY / 2;
}
current <<= 1;
if (current < 0)
{
throw new RuntimeException("Maximum capacity exceeded.");
}
return current;
}
}
hppc-0.6.1/hppc-core/src/main/templates/com/carrotsearch/hppc/Intrinsics.java 0000664 0000000 0000000 00000005044 12403265743 0027232 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc;
/**
* Intrinsic methods that are fully functional for the generic ({@link Object}) versions
* of collection classes, but are replaced with low-level corresponding structures for
* primitive types.
*
* This class should not appear in the final distribution (all methods are replaced
* in templates.
*/
final class Intrinsics
{
private Intrinsics()
{
// no instances.
}
/**
* Create and return an array of template objects (Objects in the generic
* version, corresponding key-primitive type in the generated version).
*
* @param arraySize The size of the array to return.
*/
@SuppressWarnings("unchecked")
public static T newKTypeArray(int arraySize)
{
return (T) new Object [arraySize];
}
/**
* Create and return an array of template objects (Objects in the generic
* version, corresponding value-primitive type in the generated version).
*
* @param arraySize The size of the array to return.
*/
@SuppressWarnings("unchecked")
public static T newVTypeArray(int arraySize)
{
return (T) new Object [arraySize];
}
/**
* Returns the default value for keys (null or 0
* for primitive types).
*
* @see "http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6302954"
*/
public static T defaultKTypeValue()
{
return (T) null;
}
/**
* Returns the default value for values (null or 0
* for primitive types).
*
* @see "http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6302954"
*/
public static T defaultVTypeValue()
{
return (T) null;
}
/**
* Compare two keys for equivalence. Null references return true.
* Primitive types are compared using ==, except for floating-point types
* where they're compared by their actual representation bits as returned from
* {@link Double#doubleToLongBits(double)} and {@link Float#floatToIntBits(float)}.
*/
public static boolean equalsKType(Object e1, Object e2)
{
return e1 == null ? e2 == null : e1.equals(e2);
}
/**
* Compare two keys for equivalence. Null references return true.
* Primitive types are compared using ==.
*/
public static boolean equalsVType(Object e1, Object e2)
{
return e1 == null ? e2 == null : e1.equals(e2);
}
}
hppc-0.6.1/hppc-core/src/main/templates/com/carrotsearch/hppc/KTypeArrayDeque.java 0000664 0000000 0000000 00000070336 12403265743 0030132 0 ustar 00root root 0000000 0000000 package com.carrotsearch.hppc;
import java.util.*;
import com.carrotsearch.hppc.cursors.KTypeCursor;
import com.carrotsearch.hppc.predicates.KTypePredicate;
import com.carrotsearch.hppc.procedures.KTypeProcedure;
import static com.carrotsearch.hppc.Internals.*;
/**
* An array-backed deque (doubly linked queue) of KTypes. A single array is used to store and
* manipulate all elements. Reallocations are governed by a {@link ArraySizingStrategy}
* and may be expensive if they move around really large chunks of memory.
*
#if ($TemplateOptions.KTypeGeneric)
* A brief comparison of the API against the Java Collections framework:
*
* Java Collections ArrayDeque and HPPC {@link ObjectArrayDeque}, related methods.
*
*
* | {@linkplain ArrayDeque java.util.ArrayDeque} |
* {@link ObjectArrayDeque} |
*
*
*
* | addFirst | addFirst |
* | addLast | addLast |
* | removeFirst | removeLast |
* | getFirst | getFirst |
* | getLast | getLast |
* | removeFirstOccurrence,
* removeLastOccurrence
* | removeFirstOccurrence,
* removeLastOccurrence
* |
* | size | size |
* | Object[] toArray() | KType[] toArray() |
* | iterator | {@linkplain #iterator cursor over values} |
* | other methods inherited from Stack, Queue | not implemented |
*
*
#else
* See {@link ObjectArrayDeque} class for API similarities and differences against Java
* Collections.
#end
*/
/*! ${TemplateOptions.generatedAnnotation} !*/
public class KTypeArrayDeque
extends AbstractKTypeCollection implements KTypeDeque, Cloneable
{
/**
* Default capacity if no other capacity is given in the constructor.
*/
public final static int DEFAULT_CAPACITY = 5;
/**
* Internal array for storing elements.
*
#if ($TemplateOptions.KTypeGeneric)
* Important!
* The actual value in this field is always an instance of Object[].
* Be warned that javac emits additional casts when buffer
* is directly accessed; these casts
* may result in exceptions at runtime. A workaround is to cast directly to
* Object[] before accessing the buffer's elements (although it is highly
* recommended to use a {@link #iterator()} instead.
*
#end
*/
public KType [] buffer;
/**
* The index of the element at the head of the deque or an
* arbitrary number equal to tail if the deque is empty.
*/
public int head;
/**
* The index at which the next element would be added to the tail
* of the deque.
*/
public int tail;
/**
* Buffer resizing strategy.
*/
protected final ArraySizingStrategy resizer;
/**
* Create with default sizing strategy and initial capacity for storing
* {@value #DEFAULT_CAPACITY} elements.
*
* @see BoundedProportionalArraySizingStrategy
*/
public KTypeArrayDeque()
{
this(DEFAULT_CAPACITY);
}
/**
* Create with default sizing strategy and the given initial capacity.
*
* @see BoundedProportionalArraySizingStrategy
*/
public KTypeArrayDeque(int initialCapacity)
{
this(initialCapacity, new BoundedProportionalArraySizingStrategy());
}
/**
* Create with a custom buffer resizing strategy.
*/
public KTypeArrayDeque(int initialCapacity, ArraySizingStrategy resizer)
{
assert initialCapacity >= 0 : "initialCapacity must be >= 0: " + initialCapacity;
assert resizer != null;
this.resizer = resizer;
initialCapacity = resizer.round(initialCapacity);
buffer = Intrinsics.newKTypeArray(initialCapacity);
}
/**
* Creates a new deque from elements of another container, appending them
* at the end of this deque.
*/
public KTypeArrayDeque(KTypeContainer container)
{
this(container.size());
addLast(container);
}
/**
* {@inheritDoc}
*/
@Override
public void addFirst(KType e1)
{
int h = oneLeft(head, buffer.length);
if (h == tail)
{
ensureBufferSpace(1);
h = oneLeft(head, buffer.length);
}
buffer[head = h] = e1;
}
/**
* Vararg-signature method for adding elements at the front of this deque.
*
*
This method is handy, but costly if used in tight loops (anonymous
* array passing)
*/
public void addFirst(KType... elements)
{
ensureBufferSpace(elements.length);
// For now, naive loop.
for (int i = 0; i < elements.length; i++)
addFirst(elements[i]);
}
/**
* Inserts all elements from the given container to the front of this deque.
*
* @return Returns the number of elements actually added as a result of this
* call.
*/
public int addFirst(KTypeContainer container)
{
int size = container.size();
ensureBufferSpace(size);
for (KTypeCursor cursor : container)
{
addFirst(cursor.value);
}
return size;
}
/**
* Inserts all elements from the given iterable to the front of this deque.
*
* @return Returns the number of elements actually added as a result of this call.
*/
public int addFirst(Iterable> iterable)
{
int size = 0;
for (KTypeCursor cursor : iterable)
{
addFirst(cursor.value);
size++;
}
return size;
}
/**
* {@inheritDoc}
*/
@Override
public void addLast(KType e1)
{
int t = oneRight(tail, buffer.length);
if (head == t)
{
ensureBufferSpace(1);
t = oneRight(tail, buffer.length);
}
buffer[tail] = e1;
tail = t;
}
/**
* Vararg-signature method for adding elements at the end of this deque.
*
* This method is handy, but costly if used in tight loops (anonymous
* array passing)
*/
public void addLast(KType... elements)
{
ensureBufferSpace(1);
// For now, naive loop.
for (int i = 0; i < elements.length; i++)
addLast(elements[i]);
}
/**
* Inserts all elements from the given container to the end of this deque.
*
* @return Returns the number of elements actually added as a result of this
* call.
*/
public int addLast(KTypeContainer container)
{
int size = container.size();
ensureBufferSpace(size);
for (KTypeCursor cursor : container)
{
addLast(cursor.value);
}
return size;
}
/**
* Inserts all elements from the given iterable to the end of this deque.
*
* @return Returns the number of elements actually added as a result of this call.
*/
public int addLast(Iterable> iterable)
{
int size = 0;
for (KTypeCursor cursor : iterable)
{
addLast(cursor.value);
size++;
}
return size;
}
/**
* {@inheritDoc}
*/
@Override
public KType removeFirst()
{
assert size() > 0 : "The deque is empty.";
final KType result = buffer[head];
buffer[head] = Intrinsics.defaultKTypeValue();
head = oneRight(head, buffer.length);
return result;
}
/**
* {@inheritDoc}
*/
@Override
public KType removeLast()
{
assert size() > 0 : "The deque is empty.";
tail = oneLeft(tail, buffer.length);
final KType result = buffer[tail];
buffer[tail] = Intrinsics.defaultKTypeValue();
return result;
}
/**
* {@inheritDoc}
*/
@Override
public KType getFirst()
{
assert size() > 0 : "The deque is empty.";
return buffer[head];
}
/**
* {@inheritDoc}
*/
@Override
public KType getLast()
{
assert size() > 0 : "The deque is empty.";
return buffer[oneLeft(tail, buffer.length)];
}
/**
* {@inheritDoc}
*/
@Override
public int removeFirstOccurrence(KType e1)
{
final int index = bufferIndexOf(e1);
if (index >= 0) removeAtBufferIndex(index);
return index;
}
/**
* Return the index of the first (counting from head) element equal to
* e1. The index points to the {@link #buffer} array.
*
* @param e1 The element to look for.
* @return Returns the index of the first element equal to e1
* or -1 if not found.
*/
public int bufferIndexOf(KType e1)
{
final int last = tail;
final int bufLen = buffer.length;
for (int i = head; i != last; i = oneRight(i, bufLen))
{
if (Intrinsics.equalsKType(e1, buffer[i]))
return i;
}
return -1;
}
/**
* {@inheritDoc}
*/
@Override
public int removeLastOccurrence(KType e1)
{
final int index = lastBufferIndexOf(e1);
if (index >= 0) removeAtBufferIndex(index);
return index;
}
/**
* Return the index of the last (counting from tail) element equal to
* e1. The index points to the {@link #buffer} array.
*
* @param e1 The element to look for.
* @return Returns the index of the first element equal to e1
* or -1 if not found.
*/
public int lastBufferIndexOf(KType e1)
{
final int bufLen = buffer.length;
final int last = oneLeft(head, bufLen);
for (int i = oneLeft(tail, bufLen); i != last; i = oneLeft(i, bufLen))
{
if (Intrinsics.equalsKType(e1, buffer[i]))
return i;
}
return -1;
}
/**
* {@inheritDoc}
*/
@Override
public int removeAllOccurrences(KType e1)
{
int removed = 0;
final int last = tail;
final int bufLen = buffer.length;
int from, to;
for (from = to = head; from != last; from = oneRight(from, bufLen))
{
if (Intrinsics.equalsKType(e1, buffer[from]))
{
buffer[from] = Intrinsics.defaultKTypeValue();
removed++;
continue;
}
if (to != from)
{
buffer[to] = buffer[from];
buffer[from] = Intrinsics.defaultKTypeValue();
}
to = oneRight(to, bufLen);
}
tail = to;
return removed;
}
/**
* Removes the element at index in the internal
* {#link {@link #buffer}} array, returning its value.
*
* @param index Index of the element to remove. The index must be located between
* {@link #head} and {@link #tail} in modulo {@link #buffer} arithmetic.
*/
public void removeAtBufferIndex(int index)
{
assert (head <= tail
? index >= head && index < tail
: index >= head || index < tail) : "Index out of range (head="
+ head + ", tail=" + tail + ", index=" + index + ").";
// Cache fields in locals (hopefully moved to registers).
final KType [] b = this.buffer;
final int bufLen = b.length;
final int lastIndex = bufLen - 1;
final int head = this.head;
final int tail = this.tail;
final int leftChunk = Math.abs(index - head) % bufLen;
final int rightChunk = Math.abs(tail - index) % bufLen;
if (leftChunk < rightChunk)
{
if (index >= head)
{
System.arraycopy(b, head, b, head + 1, leftChunk);
}
else
{
System.arraycopy(b, 0, b, 1, index);
b[0] = b[lastIndex];
System.arraycopy(b, head, b, head + 1, lastIndex - head);
}
b[head] = Intrinsics.defaultKTypeValue();
this.head = oneRight(head, bufLen);
}
else
{
if (index < tail)
{
System.arraycopy(b, index + 1, b, index, rightChunk);
}
else
{
System.arraycopy(b, index + 1, b, index, lastIndex - index);
b[lastIndex] = b[0];
System.arraycopy(b, 1, b, 0, tail);
}
b[tail] = Intrinsics.defaultKTypeValue();
this.tail = oneLeft(tail, bufLen);
}
}
/**
* {@inheritDoc}
*/
@Override
public boolean isEmpty()
{
return size() == 0;
}
/**
* {@inheritDoc}
*/
@Override
public int size()
{
if (head <= tail)
return tail - head;
else
return (tail - head + buffer.length);
}
/**
* {@inheritDoc}
*
* The internal array buffers are not released as a result of this call.
*
* @see #release()
*/
@Override
public void clear()
{
if (head < tail)
{
Arrays.fill(buffer, head, tail, Intrinsics.defaultKTypeValue());
}
else
{
Arrays.fill(buffer, 0, tail, Intrinsics.defaultKTypeValue());
Arrays.fill(buffer, head, buffer.length, Intrinsics.defaultKTypeValue());
}
this.head = tail = 0;
}
/**
* Release internal buffers of this deque and reallocate the smallest buffer possible.
*/
public void release()
{
this.head = tail = 0;
buffer = Intrinsics.newKTypeArray(resizer.round(DEFAULT_CAPACITY));
}
/**
* Ensures the internal buffer has enough free slots to store
* expectedAdditions. Increases internal buffer size if needed.
*/
protected void ensureBufferSpace(int expectedAdditions)
{
final int bufferLen = (buffer == null ? 0 : buffer.length);
final int elementsCount = size();
// +1 because there is always one empty slot in a deque.
if (elementsCount >= bufferLen - expectedAdditions - 1)
{
final int newSize = resizer.grow(bufferLen, elementsCount, expectedAdditions + 1);
assert newSize >= (elementsCount + expectedAdditions + 1) : "Resizer failed to" +
" return sensible new size: " + newSize + " <= "
+ (elementsCount + expectedAdditions);
final KType [] newBuffer = Intrinsics.newKTypeArray(newSize);
if (bufferLen > 0)
{
toArray(newBuffer);
tail = elementsCount;
head = 0;
}
this.buffer = newBuffer;
}
}
/**
* {@inheritDoc}
*/
@Override
/*! #if ($TemplateOptions.KTypePrimitive)
public KType [] toArray()
#else !*/
public Object [] toArray()
/*! #end !*/
{
final int size = size();
return toArray(Intrinsics.newKTypeArray(size));
}
/**
* Copies elements of this deque to an array. The content of the target
* array is filled from index 0 (head of the queue) to index size() - 1
* (tail of the queue).
*
* @param target The target array must be large enough to hold all elements.
* @return Returns the target argument for chaining.
*/
public KType [] toArray(KType [] target)
{
assert target.length >= size() : "Target array must be >= " + size();
if (head < tail)
{
// The contents is not wrapped around. Just copy.
System.arraycopy(buffer, head, target, 0, size());
}
else if (head > tail)
{
// The contents is split. Merge elements from the following indexes:
// [head...buffer.length - 1][0, tail - 1]
final int rightCount = buffer.length - head;
System.arraycopy(buffer, head, target, 0, rightCount);
System.arraycopy(buffer, 0, target, rightCount, tail);
}
return target;
}
/**
* Clone this object. The returned clone will reuse the same hash function
* and array resizing strategy.
*/
@Override
public KTypeArrayDeque clone()
{
try
{
/* #if ($TemplateOptions.KTypeGeneric) */
@SuppressWarnings("unchecked")
/* #end */
KTypeArrayDeque cloned = (KTypeArrayDeque) super.clone();
cloned.buffer = buffer.clone();
return cloned;
}
catch (CloneNotSupportedException e)
{
throw new RuntimeException(e);
}
}
/**
* Move one index to the left, wrapping around buffer.
*/
protected static int oneLeft(int index, int modulus)
{
if (index >= 1) return index - 1;
return modulus - 1;
}
/**
* Move one index to the right, wrapping around buffer.
*/
protected static int oneRight(int index, int modulus)
{
if (index + 1 == modulus) return 0;
return index + 1;
}
/**
* An iterator implementation for {@link ObjectArrayDeque#iterator}.
*/
private final class ValueIterator extends AbstractIterator>
{
private final KTypeCursor cursor;
private int remaining;
public ValueIterator()
{
cursor = new KTypeCursor();
cursor.index = oneLeft(head, buffer.length);
this.remaining = size();
}
@Override
protected KTypeCursor fetch()
{
if (remaining == 0)
return done();
remaining--;
cursor.value = buffer[cursor.index = oneRight(cursor.index, buffer.length)];
return cursor;
}
}
/**
* An iterator implementation for {@link ObjectArrayDeque#descendingIterator()}.
*/
private final class DescendingValueIterator extends AbstractIterator>
{
private final KTypeCursor cursor;
private int remaining;
public DescendingValueIterator()
{
cursor = new KTypeCursor();
cursor.index = tail;
this.remaining = size();
}
@Override
protected KTypeCursor fetch()
{
if (remaining == 0)
return done();
remaining--;
cursor.value = buffer[cursor.index = oneLeft(cursor.index, buffer.length)];
return cursor;
}
}
/**
* Returns a cursor over the values of this deque (in head to tail order). The
* iterator is implemented as a cursor and it returns the same cursor instance
* on every call to {@link Iterator#next()} (to avoid boxing of primitive types). To
* read the current value (or index in the deque's buffer) use the cursor's public
* fields. An example is shown below.
*
*
* for (IntValueCursor c : intDeque)
* {
* System.out.println("buffer index="
* + c.index + " value=" + c.value);
* }
*
*/
public Iterator> iterator()
{
return new ValueIterator();
}
/**
* Returns a cursor over the values of this deque (in tail to head order). The
* iterator is implemented as a cursor and it returns the same cursor instance
* on every call to {@link Iterator#next()} (to avoid boxing of primitive types). To
* read the current value (or index in the deque's buffer) use the cursor's public
* fields. An example is shown below.
*
*
* for (Iterator i = intDeque.descendingIterator(); i.hasNext(); )
* {
* final IntCursor c = i.next();
* System.out.println("buffer index="
* + c.index + " value=" + c.value);
* }
*
*/
public Iterator> descendingIterator()
{
return new DescendingValueIterator();
}
/**
* {@inheritDoc}
*/
@Override
public > T forEach(T procedure)
{
forEach(procedure, head, tail);
return procedure;
}
/**
* Applies procedure to a slice of the deque,
* fromIndex, inclusive, to toIndex,
* exclusive.
*/
private void forEach(KTypeProcedure procedure, int fromIndex, final int toIndex)
{
final KType [] buffer = this.buffer;
for (int i = fromIndex; i != toIndex; i = oneRight(i, buffer.length))
{
procedure.apply(buffer[i]);
}
}
/**
* {@inheritDoc}
*/
@Override
public > T forEach(T predicate)
{
int fromIndex = head;
int toIndex = tail;
final KType [] buffer = this.buffer;
for (int i = fromIndex; i != toIndex; i = oneRight(i, buffer.length))
{
if (!predicate.apply(buffer[i]))
break;
}
return predicate;
}
/**
* Applies procedure to all elements of this deque, tail to head.
*/
@Override
public > T descendingForEach(T procedure)
{
descendingForEach(procedure, head, tail);
return procedure;
}
/**
* Applies procedure to a slice of the deque,
* toIndex, exclusive, down to fromIndex, inclusive.
*/
private void descendingForEach(KTypeProcedure procedure,
int fromIndex, final int toIndex)
{
if (fromIndex == toIndex)
return;
final KType [] buffer = this.buffer;
int i = toIndex;
do
{
i = oneLeft(i, buffer.length);
procedure.apply(buffer[i]);
} while (i != fromIndex);
}
/**
* {@inheritDoc}
*/
@Override
public > T descendingForEach(T predicate)
{
descendingForEach(predicate, head, tail);
return predicate;
}
/**
* Applies predicate to a slice of the deque,
* toIndex, exclusive, down to fromIndex, inclusive
* or until the predicate returns false.
*/
private void descendingForEach(KTypePredicate predicate,
int fromIndex, final int toIndex)
{
if (fromIndex == toIndex)
return;
final KType [] buffer = this.buffer;
int i = toIndex;
do
{
i = oneLeft(i, buffer.length);
if (!predicate.apply(buffer[i]))
break;
} while (i != fromIndex);
}
/**
* {@inheritDoc}
*/
@Override
public int removeAll(KTypePredicate predicate)
{
int removed = 0;
final int last = tail;
final int bufLen = buffer.length;
int from, to;
from = to = head;
try
{
for (from = to = head; from != last; from = oneRight(from, bufLen))
{
if (predicate.apply(buffer[from]))
{
buffer[from] = Intrinsics.defaultKTypeValue();
removed++;
continue;
}
if (to != from)
{
buffer[to] = buffer[from];
buffer[from] = Intrinsics.defaultKTypeValue();
}
to = oneRight(to, bufLen);
}
}
finally
{
// Keep the deque in consistent state even if the predicate throws an exception.
for (; from != last; from = oneRight(from, bufLen))
{
if (to != from)
{
buffer[to] = buffer[from];
buffer[from] = Intrinsics.defaultKTypeValue();
}
to = oneRight(to, bufLen);
}
tail = to;
}
return removed;
}
/**
* {@inheritDoc}
*/
@Override
public boolean contains(KType e)
{
int fromIndex = head;
int toIndex = tail;
final KType [] buffer = this.buffer;
for (int i = fromIndex; i != toIndex; i = oneRight(i, buffer.length))
{
if (Intrinsics.equalsKType(e, buffer[i]))
return true;
}
return false;
}
/**
* {@inheritDoc}
*/
@Override
public int hashCode()
{
int h = 1;
int fromIndex = head;
int toIndex = tail;
final KType [] buffer = this.buffer;
for (int i = fromIndex; i != toIndex; i = oneRight(i, buffer.length))
{
h = 31 * h + rehash(this.buffer[i]);
}
return h;
}
/**
* {@inheritDoc}
*/
@Override
/* #if ($TemplateOptions.KTypeGeneric) */
@SuppressWarnings("unchecked")
/* #end */
public boolean equals(Object obj)
{
if (obj != null)
{
if (obj instanceof KTypeDeque)
{
KTypeDeque