public LongArrayBitVector replace(final LongArrayBitVector bv) { ensureCapacity(bv.length); final long[] bits = this.bits; final long[] bvBits = bv.bits; final int bvFirstFreeWord = word(bv.length - 1) + 1; for(int i = bvFirstFreeWord; i-- != 0;) bits[i] = bvBits[i]; final int thisFirstFreeWord = word(length - 1) + 1; if (bvFirstFreeWord < thisFirstFreeWord) Arrays.fill(this.bits, bvFirstFreeWord, thisFirstFreeWord, 0); this.length = bv.length; return this; }
/** Reads quickly a bit vector from a {@link DataInputStream}. * * <p>This method is similar in purpose to {@link #readFast(DataInputStream)}, but it allows reuse of the bit vector. * * @param dis a data input stream. * @param bv a long-array bit vector. * @return <code>bv</code>, filled with the next bit vector in the stream, as saved by {@link #writeFast(BitVector, DataOutputStream)}. * @see #writeFast(BitVector, DataOutputStream) * @see #readFast(DataInputStream) */ public static LongArrayBitVector readFast( DataInputStream dis, final LongArrayBitVector bv ) throws IOException { final long length = dis.readLong(); bv.ensureCapacity( length ); final int l = LongArrayBitVector.numWords( length ); for( int i = 0; i < l; i++ ) bv.bits[ i ] = dis.readLong(); bv.length( length ); return bv; }
public LongArrayBitVector append( long value, int width ) { if ( width == 0 ) return this; if ( CHECKS && width < Long.SIZE && ( value & -1L << width ) != 0 ) throw new IllegalArgumentException( "The specified value (" + value + ") is larger than the maximum value for the given width (" + width + ")" ); final long length = this.length; final int startWord = word( length ); final int startBit = bit( length ); ensureCapacity( length + width ); if ( startBit + width <= Long.SIZE ) bits[ startWord ] |= value << startBit; else { bits[ startWord ] |= value << startBit; bits[ startWord + 1 ] = value >>> BITS_PER_WORD - startBit; } this.length += width; return this; }
public LongArrayBitVector append( long value, int width ) { if ( width == 0 ) return this; if ( CHECKS && width < Long.SIZE && ( value & -1L << width ) != 0 ) throw new IllegalArgumentException( "The specified value (" + value + ") is larger than the maximum value for the given width (" + width + ")" ); final long length = this.length; final int startWord = word( length ); final int startBit = bit( length ); ensureCapacity( length + width ); if ( startBit + width <= Long.SIZE ) bits[ startWord ] |= value << startBit; else { bits[ startWord ] |= value << startBit; bits[ startWord + 1 ] = value >>> BITS_PER_WORD - startBit; } this.length += width; return this; }
/** Reads quickly a bit vector from a {@link DataInputStream}. * * <p>This method is similar in purpose to {@link #readFast(DataInput)}, but it allows reuse of the bit vector. * * @param dis a data input stream. * @param bv a long-array bit vector. * @return <code>bv</code>, filled with the next bit vector in the stream, as saved by {@link #writeFast(BitVector, DataOutput)}. * @see #writeFast(BitVector, DataOutput) * @see #readFast(DataInput) */ public static LongArrayBitVector readFast(DataInput dis, final LongArrayBitVector bv) throws IOException { final long length = dis.readLong(); bv.ensureCapacity(length); final int l = LongArrayBitVector.numWords(length); for(int i = 0; i < l; i++) bv.bits[i] = dis.readLong(); bv.length(length); return bv; }
/** Reads quickly a bit vector from a {@link DataInputStream}. * * <p>This method is similar in purpose to {@link #readFast(DataInputStream)}, but it allows reuse of the bit vector. * * @param dis a data input stream. * @param bv a long-array bit vector. * @return <code>bv</code>, filled with the next bit vector in the stream, as saved by {@link #writeFast(BitVector, DataOutputStream)}. * @see #writeFast(BitVector, DataOutputStream) * @see #readFast(DataInputStream) */ public static LongArrayBitVector readFast( DataInputStream dis, final LongArrayBitVector bv ) throws IOException { final long length = dis.readLong(); bv.ensureCapacity( length ); final int l = LongArrayBitVector.numWords( length ); for( int i = 0; i < l; i++ ) bv.bits[ i ] = dis.readLong(); bv.length( length ); return bv; }
public void dump(final String file) throws IOException { final ByteBuffer buffer = ByteBuffer.allocateDirect(offsetAndSeed.length * 8 + 40).order(ByteOrder.nativeOrder()); final FileOutputStream fos = new FileOutputStream(file); final FileChannel channel = fos.getChannel(); buffer.clear(); buffer.putLong(size64()); buffer.putLong(width); buffer.putLong(chunkShift); buffer.putLong(globalSeed); buffer.putLong(offsetAndSeed.length); for(final long l : offsetAndSeed) buffer.putLong(l); buffer.flip(); channel.write(buffer); buffer.clear(); final LongArrayBitVector v = LongArrayBitVector.getInstance().ensureCapacity(data.size64() * width); for(final long d: data) v.append(d, width); final long[] array = v.bits(); buffer.putLong(array.length); for(final long l: array) { if (!buffer.hasRemaining()) { buffer.flip(); channel.write(buffer); buffer.clear(); } buffer.putLong(l); } buffer.flip(); channel.write(buffer); fos.close(); }
@Override public LongArrayBitVector append(final long value, final int width) { if (width == 0) return this; if (CHECKS) if( width < Long.SIZE && (value & -1L << width) != 0) throw new IllegalArgumentException("The specified value (" + value + ") is larger than the maximum value for the given width (" + width + ")"); final long length = this.length; final int startWord = word(length); final int startBit = bit(length); ensureCapacity(length + width); if (startBit + width <= Long.SIZE) bits[startWord] |= value << startBit; else { bits[startWord] |= value << startBit; bits[startWord + 1] = value >>> BITS_PER_WORD - startBit; } this.length += width; return this; }
public LongArrayBitVector replace( final LongArrayBitVector bv ) { ensureCapacity( bv.length ); final long[] bits = this.bits; final long[] bvBits = bv.bits; final int bvFirstFreeWord = word( bv.length - 1 ) + 1; for( int i = bvFirstFreeWord; i-- != 0; ) bits[ i ] = bvBits[ i ]; final int thisFirstFreeWord = word( length - 1 ) + 1; if ( bvFirstFreeWord < thisFirstFreeWord ) LongArrays.fill( this.bits, bvFirstFreeWord, thisFirstFreeWord, 0 ); this.length = bv.length; return this; }
public LongArrayBitVector replace( final LongArrayBitVector bv ) { ensureCapacity( bv.length ); final long[] bits = this.bits; final long[] bvBits = bv.bits; final int bvFirstFreeWord = word( bv.length - 1 ) + 1; for( int i = bvFirstFreeWord; i-- != 0; ) bits[ i ] = bvBits[ i ]; final int thisFirstFreeWord = word( length - 1 ) + 1; if ( bvFirstFreeWord < thisFirstFreeWord ) LongArrays.fill( this.bits, bvFirstFreeWord, thisFirstFreeWord, 0 ); this.length = bv.length; return this; }
@Override public LongArrayBitVector replace(final BitVector bv) { final long bvLength = bv.length(); ensureCapacity(bvLength); final long[] bits = this.bits; final long fullBits = bvLength - bvLength % Long.SIZE; for(long i = 0; i < fullBits; i += Long.SIZE) bits[(int)(i / Long.SIZE)] = bv.getLong(i, i + Long.SIZE); final int bvFirstFreeWord = word(bvLength - 1) + 1; final int thisFirstFreeWord = word(length - 1) + 1; if (bvLength % Long.SIZE != 0) bits[(int)(fullBits / Long.SIZE)] = bv.getLong(fullBits, bvLength); if (bvFirstFreeWord < thisFirstFreeWord) Arrays.fill(this.bits, bvFirstFreeWord, thisFirstFreeWord, 0); this.length = bvLength; return this; }
@Override public LongArrayBitVector replace( final BitVector bv ) { final long bvLength = bv.length(); ensureCapacity( bvLength ); final long[] bits = this.bits; final long fullBits = bvLength - bvLength % Long.SIZE; for( long i = 0; i < fullBits; i += Long.SIZE ) bits[ (int)( i / Long.SIZE ) ] = bv.getLong( i, i + Long.SIZE ); final int bvFirstFreeWord = word( bvLength - 1 ) + 1; final int thisFirstFreeWord = word( length - 1 ) + 1; if ( bvLength % Long.SIZE != 0 ) bits[ (int)( fullBits / Long.SIZE ) ] = bv.getLong( fullBits, bvLength ); if ( bvFirstFreeWord < thisFirstFreeWord ) LongArrays.fill( this.bits, bvFirstFreeWord, thisFirstFreeWord, 0 ); this.length = bvLength; return this; }
@Override public LongArrayBitVector replace( final BitVector bv ) { final long bvLength = bv.length(); ensureCapacity( bvLength ); final long[] bits = this.bits; final long fullBits = bvLength - bvLength % Long.SIZE; for( long i = 0; i < fullBits; i += Long.SIZE ) bits[ (int)( i / Long.SIZE ) ] = bv.getLong( i, i + Long.SIZE ); final int bvFirstFreeWord = word( bvLength - 1 ) + 1; final int thisFirstFreeWord = word( length - 1 ) + 1; if ( bvLength % Long.SIZE != 0 ) bits[ (int)( fullBits / Long.SIZE ) ] = bv.getLong( fullBits, bvLength ); if ( bvFirstFreeWord < thisFirstFreeWord ) LongArrays.fill( this.bits, bvFirstFreeWord, thisFirstFreeWord, 0 ); this.length = bvLength; return this; }
newNode.repr.ensureCapacity(reprSize); newNode.skips.ensureCapacity(skipSize);