/** Sets the size of this bit vector to 0. * <P>Note that this method does not try to reallocate that backing array. * If you want to force that behaviour, call {@link #trim()} afterwards. */ @Override public void clear() { Arrays.fill(bits, 0, word(length - 1) + 1, 0); length = 0; }
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; }
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 void set(final long index) { if (CHECKS) ensureRestrictedIndex(index); bits[word(index)] |= mask(index); }
/** Sets the size of this bit vector to 0. * <P>Note that this method does not try to reallocate that backing array. * If you want to force that behaviour, call {@link #trim()} afterwards. */ public void clear() { LongArrays.fill( bits, 0, word( length - 1 ) + 1, 0 ); length = 0; }
/** Sets the size of this bit vector to 0. * <P>Note that this method does not try to reallocate that backing array. * If you want to force that behaviour, call {@link #trim()} afterwards. */ public void clear() { LongArrays.fill( bits, 0, word( length - 1 ) + 1, 0 ); length = 0; }
@Override public boolean getBoolean(final long index) { if (CHECKS) ensureRestrictedIndex(index); return (bits[word(index)] & mask(index)) != 0; }
@Override public void clear(final long index) { if (CHECKS) ensureRestrictedIndex(index); bits[word(index)] &= ~mask(index); }
@Override public boolean set(final long index, final boolean value) { if (CHECKS) ensureRestrictedIndex(index); final int word = word(index); final long mask = mask(index); final boolean oldValue = (bits[word] & mask) != 0; if (value != oldValue) bits[word] ^= mask; return oldValue; }
public long previousZero( final long index ) { if ( index == 0 ) return -1; final long[] bits = this.bits; final int from = word( index - 1 ); long maskedFirstWord = bits[ from ] | -1L << bit( index ); if ( from == word( length - 1 ) ) maskedFirstWord |= -1L << length % Long.SIZE; if ( maskedFirstWord != 0xFFFFFFFFFFFFFFFFL ) return from * BITS_PER_WORD + Fast.mostSignificantBit( ~maskedFirstWord ); for ( int i = from; i-- != 0; ) if ( bits[ i ] != 0xFFFFFFFFFFFFFFFFL ) return i * BITS_PER_WORD + Fast.mostSignificantBit( ~bits[ i ] ); return -1; }
public long previousZero( final long index ) { if ( index == 0 ) return -1; final long[] bits = this.bits; final int from = word( index - 1 ); long maskedFirstWord = bits[ from ] | -1L << bit( index ); if ( from == word( length - 1 ) ) maskedFirstWord |= -1L << length % Long.SIZE; if ( maskedFirstWord != 0xFFFFFFFFFFFFFFFFL ) return from * BITS_PER_WORD + Fast.mostSignificantBit( ~maskedFirstWord ); for ( int i = from; i-- != 0; ) if ( bits[ i ] != 0xFFFFFFFFFFFFFFFFL ) return i * BITS_PER_WORD + Fast.mostSignificantBit( ~bits[ i ] ); return -1; }
public long getLong( long from, long to ) { if ( CHECKS ) BitVectors.ensureFromTo( length, from, to ); final long l = Long.SIZE - ( to - from ); final int startWord = word( from ); final int startBit = bit( from ); if ( l == Long.SIZE ) return 0; if ( startBit <= l ) return bits[ startWord ] << l - startBit >>> l; return bits[ startWord ] >>> startBit | bits[ startWord + 1 ] << Long.SIZE + l - startBit >>> l; }
public boolean set( final long index, final boolean value ) { if ( CHECKS ) ensureRestrictedIndex( index ); final int word = word( index ); final long mask = mask( index ); final boolean oldValue = ( bits[ word ] & mask ) != 0; if ( value ) bits[ word ] |= mask; else bits[ word ] &= ~mask; return oldValue != value; }
@Override public long getLong(final long from, final long to) { if (CHECKS) BitVectors.ensureFromTo(length, from, to); final long l = Long.SIZE - (to - from); final int startWord = word(from); final int startBit = bit(from); if (l == Long.SIZE) return 0; if (startBit <= l) return bits[startWord] << l - startBit >>> l; return bits[startWord] >>> startBit | bits[startWord + 1] << Long.SIZE + l - startBit >>> l; }
@Override public long previousOne(final long index) { if (index == 0) return -1; final long[] bits = this.bits; final int from = word(index - 1); final long mask = 1L << index - 1; final long maskedFirstWord = bits[from] & (mask | mask - 1); if (maskedFirstWord != 0) return from * (long)BITS_PER_WORD + Fast.mostSignificantBit(maskedFirstWord); for (int i = from; i-- != 0;) if (bits[i] != 0) return i * (long)BITS_PER_WORD + Fast.mostSignificantBit(bits[i]); return -1; }
public boolean set( final long index, final boolean value ) { if ( CHECKS ) ensureRestrictedIndex( index ); final int word = word( index ); final long mask = mask( index ); final boolean oldValue = ( bits[ word ] & mask ) != 0; if ( value ) bits[ word ] |= mask; else bits[ word ] &= ~mask; return oldValue != value; }
public long getLong( long from, long to ) { if ( CHECKS ) BitVectors.ensureFromTo( length, from, to ); final long l = Long.SIZE - ( to - from ); final int startWord = word( from ); final int startBit = bit( from ); if ( l == Long.SIZE ) return 0; if ( startBit <= l ) return bits[ startWord ] << l - startBit >>> l; return bits[ startWord ] >>> startBit | bits[ startWord + 1 ] << Long.SIZE + l - startBit >>> l; }
public long previousOne( final long index ) { if ( index == 0 ) return -1; final long[] bits = this.bits; final int from = word( index - 1 ); final long mask = 1L << bit( index - 1 ); final long maskedFirstWord = bits[ from ] & ( mask | mask - 1 ); if ( maskedFirstWord != 0 ) return from * BITS_PER_WORD + Fast.mostSignificantBit( maskedFirstWord ); for ( int i = from; i-- != 0; ) if ( bits[ i ] != 0 ) return i * BITS_PER_WORD + Fast.mostSignificantBit( bits[ i ] ); return -1; }
public long nextOne( final long index ) { if ( index >= length ) return -1; final long[] bits = this.bits; final long words = numWords( length ); final int from = word( index ); final long maskedFirstWord = bits[ from ] & -( 1L << bit( index ) ); if ( maskedFirstWord != 0 ) return from * BITS_PER_WORD + Fast.leastSignificantBit( maskedFirstWord ); for ( int i = from + 1; i < words; i++ ) if ( bits[ i ] != 0 ) return i * BITS_PER_WORD + Fast.leastSignificantBit( bits[ i ] ); return -1; }
public long nextOne( final long index ) { if ( index >= length ) return -1; final long[] bits = this.bits; final long words = numWords( length ); final int from = word( index ); final long maskedFirstWord = bits[ from ] & -( 1L << bit( index ) ); if ( maskedFirstWord != 0 ) return from * BITS_PER_WORD + Fast.leastSignificantBit( maskedFirstWord ); for ( int i = from + 1; i < words; i++ ) if ( bits[ i ] != 0 ) return i * BITS_PER_WORD + Fast.leastSignificantBit( bits[ i ] ); return -1; }