BitVector (Uzaygezen-core 0.2 API)

All Superinterfaces:

Comparable<BitVector>

All Known Implementing Classes:

BitSetBackedBitVector, LongArrayBitVector, LongBitVector
```
public interface BitVector
extends Comparable<BitVector>
```
Represents a fixed-size bit set. Two bit vectors are equal iff they have the same size and they represent the same bit pattern. In general a bit vector can talk to any other bit vector as long as they have the same size; with the exception of equals(java.lang.Object), hashCode(), copyFromSection(BitVector, int), copySectionFrom(int, com.google.uzaygezen.core.BitVector) and grayCodeRank(com.google.uzaygezen.core.BitVector, com.google.uzaygezen.core.BitVector), all other methods accepting a BitVector parameter fail if the bit vector parameter has a different size.

Author:

Mehmet Akin, Daniel Aioanei

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`and(BitVector o)`
`void`	`andNot(BitVector o)`
`boolean`	`areAllLowestBitsClear(int bitCount)`
`int`	`cardinality()`
`void`	`clear()` Makes BitVector contain all zeros.
`void`	`clear(int bitIndex)`
`void`	`clear(int fromIndex, int toIndex)`
`BitVector`	`clone()`
`int`	`compareTo(BitVector o)` Compares the unsigned numbers having the pattern in this and the other bit vectors, respectively, as the little endian representation.
`void`	`copyFrom(BigInteger s)`
`void`	`copyFrom(BitSet from)` Makes this BitVector equal to the given bit set.
`void`	`copyFrom(BitVector from)` Makes this BitVector equal to the other bit vector.
`void`	`copyFrom(long data)` Initialises this bit vector with the little endian representation of a `long`.
`void`	`copyFrom(long[] array)` Makes this bit vector have the same bit pattern as the little-endian long array, size permitting.
`void`	`copyFromBigEndian(byte[] array)` Makes this bit vector have the same bit pattern as the little-endian long array, size permitting.
`void`	`copyFromSection(BitVector src, int fromIndex)` Copies `size()` bits from `src`, starting with `fromIndex`.
`void`	`copySectionFrom(int offset, BitVector src)` Copies all `src.size()` bits from src into this bit vector, starting with position `offset`.
`boolean`	`equals(Object o)` Two bit vectors are deemed iff they have the same size and they represent the same bit pattern.
`void`	`flip(int bitIndex)`
`void`	`flip(int fromIndex, int toIndex)`
`boolean`	`get(int bitIndex)`
`void`	`grayCode()` Encodes the content of bitVector as Gray code.
`void`	`grayCodeInverse()` Decodes the content of bitVector from Gray code to natural binary code.
`void`	`grayCodeRank(BitVector mu, BitVector w)` If one puts all the numbers which have the gray code inverse fixed in all bit positions which are zero in `mu`, and they are equal in those bit positions to the corresponding bits in `w`, and sorts all those numbers increasingly, then there will be exactly one such number that has the gray code inverse exactly equal to `w`.
`void`	`grayCodeRankInverse(BitVector mu, BitVector known, BitVector r)` Giving the name `i` to the bit set represented by `this`, this method computes the inverse function for `grayCodeRank(com.google.uzaygezen.core.BitVector, com.google.uzaygezen.core.BitVector)`.
`int`	`hashCode()`
`boolean`	`increment()` If at least one bit is `false` then the value is incremented by one and `true` is returned; otherwise `false` is returned.
`boolean`	`intersects(BitVector set)`
`boolean`	`isEmpty()`
`int`	`length()`
`int`	`lowestDifferentBit()` Computes the length of the contiguous range of equal bits, starting from bit zero, with the mention that all zeroes and all ones produce zero instead of `size()`;
`int`	`nextClearBit(int fromIndex)` Returns the index of the first bit that is set to `true` that occurs on or after the specified starting index.
`int`	`nextSetBit(int fromIndex)` Returns the index of the first bit that is set to `true` that occurs on or after the specified starting index.
`void`	`or(BitVector o)` Bitwise or with given `BitVector`
`void`	`rotate(int count)` Rotates by `count` bits to the right.
`void`	`set(int bitIndex)`
`void`	`set(int bitIndex, boolean value)`
`void`	`set(int fromIndex, int toIndex)`
`void`	`set(int fromIndex, int toIndex, boolean value)`
`int`	`size()`
`void`	`smallerEvenAndGrayCode()` If empty, the are no changes.
`byte[]`	`toBigEndianByteArray()`
`BigInteger`	`toBigInteger()` While {`toLong()` can return a negative long, {`toBigInteger()` always produces a nonnegative value.
`BitSet`	`toBitSet()` Returns a non-shared bit set representing the same set of bits.
`long`	`toExactLong()` Like `toLong()`, but fails if the number doesn't fit in 64 bits.
`long`	`toLong()`
`long[]`	`toLongArray()` See `BitSet#toLongArray` in Java 7.
`void`	`xor(BitVector o)`

- Method Detail
  - isEmpty
```
boolean isEmpty()
```
  - set
```
void set(int bitIndex)
```
  - set
```
void set(int bitIndex,
       boolean value)
```
  - set
```
void set(int fromIndex,
       int toIndex)
```
  - set
```
void set(int fromIndex,
       int toIndex,
       boolean value)
```
  - get
```
boolean get(int bitIndex)
```
  - copyFromSection
```
void copyFromSection(BitVector src,
                   int fromIndex)
```
    Copies size() bits from src, starting with fromIndex.
    
    Throws:
    
    IllegalArgumentException - if src.size() < fromIndex + size()
  - copySectionFrom
```
void copySectionFrom(int offset,
                   BitVector src)
```
    Copies all src.size() bits from src into this bit vector, starting with position offset.
    
    Throws:
    
    IllegalArgumentException - if offset + src.size() > size()
  - length
```
int length()
```
  - size
```
int size()
```
  - clear
```
void clear()
```
    Makes BitVector contain all zeros.
  - clear
```
void clear(int bitIndex)
```
  - clear
```
void clear(int fromIndex,
         int toIndex)
```
  - cardinality
```
int cardinality()
```
    Returns:
    number of 1's in BitVector.
  - flip
```
void flip(int bitIndex)
```
  - flip
```
void flip(int fromIndex,
        int toIndex)
```
  - intersects
```
boolean intersects(BitVector set)
```
  - nextSetBit
```
int nextSetBit(int fromIndex)
```
    Returns the index of the first bit that is set to true that occurs on or after the specified starting index. If no such bit exists then -1 is returned.
  - nextClearBit
```
int nextClearBit(int fromIndex)
```
    Returns the index of the first bit that is set to true that occurs on or after the specified starting index. If no such bit exists then -1 is returned. Note that the behaviour is different from the one exhibited by BitSet.nextClearBit(int).
  - increment
```
boolean increment()
```
    If at least one bit is false then the value is incremented by one and true is returned; otherwise false is returned.
  - andNot
```
void andNot(BitVector o)
```
  - and
```
void and(BitVector o)
```
  - or
```
void or(BitVector o)
```
    Bitwise or with given BitVector
    
    Parameters:
    o - A BitVector, sizes must be equal.
  - xor
```
void xor(BitVector o)
```
  - rotate
```
void rotate(int count)
```
    Rotates by count bits to the right.
    
    Parameters:
    count - can be negative
  - grayCode
```
void grayCode()
```
    Encodes the content of bitVector as Gray code.
  - grayCodeInverse
```
void grayCodeInverse()
```
    Decodes the content of bitVector from Gray code to natural binary code.
  - smallerEvenAndGrayCode
```
void smallerEvenAndGrayCode()
```
    If empty, the are no changes. If even but not empty, it subtracts two and computes the gray code. Otherwise it subtracts one and computes the gray code.
  - lowestDifferentBit
```
int lowestDifferentBit()
```
    Computes the length of the contiguous range of equal bits, starting from bit zero, with the mention that all zeroes and all ones produce zero instead of size();
    
    Returns:
    number of same lowest bits; the value returned always satisfies the condition result == 0 || (0 < result & result < size)
  - areAllLowestBitsClear
```
boolean areAllLowestBitsClear(int bitCount)
```
    Returns:
    true if the lowest bitCount bits are clear; false otherwise. If called with the parameter bitCount = 0 it will always return true.
  - grayCodeRank
```
void grayCodeRank(BitVector mu,
                BitVector w)
```
    If one puts all the numbers which have the gray code inverse fixed in all bit positions which are zero in mu, and they are equal in those bit positions to the corresponding bits in w, and sorts all those numbers increasingly, then there will be exactly one such number that has the gray code inverse exactly equal to w. This method computes the rank of that number in the sorted list.
    
    Parameters:
    mu - pattern of free bits
    w - some gray code inverse. Note that every non-negative number is the gray code inverse of exactly one number, so w can be any number.
    
    Throws:
    
    IllegalArgumentException - if mu.size() != w.size() || size() != mu.cardinality()
  - grayCodeRankInverse
```
void grayCodeRankInverse(BitVector mu,
                       BitVector known,
                       BitVector r)
```
    Giving the name i to the bit set represented by this, this method computes the inverse function for grayCodeRank(com.google.uzaygezen.core.BitVector, com.google.uzaygezen.core.BitVector). By knowing the non-free bits of i's gray code known and the rank of this (as a gray code inverse), both with respect to a pattern mu, this method computes the complete number i. If the gray code of i needs to be found out as well, then grayCode() can be called with this method's output (i.e., this) as input.
    
    Parameters:
    mu - pattern of free bits
    known - the known bits from i's gray code
    r - gray code rank of this with respect to mu
  - copyFrom
```
void copyFrom(BitVector from)
```
    Makes this BitVector equal to the other bit vector. The two bit vectors must have the same size.
    
    See Also:
    for copying bits between bit vectors of different sizes
  - copyFrom
```
void copyFrom(BitSet from)
```
    Makes this BitVector equal to the given bit set.
    
    Throws:
    
    IllegalArgumentException - iff from.length() > size()
  - clone
```
BitVector clone()
```
  - toBitSet
```
BitSet toBitSet()
```
    Returns a non-shared bit set representing the same set of bits.
  - toLong
```
long toLong()
```
    Returns:
    lowest 64 bit of BitVector as a long. Higher bits are ignored. The result is negative iff bit 63 is set.
  - toExactLong
```
long toExactLong()
```
    Like toLong(), but fails if the number doesn't fit in 64 bits. Even bit vectors of size greater than 64 can succeed, if they happen not to have any bits set at position 64 and beyond.
  - copyFrom
```
void copyFrom(long data)
```
    Initialises this bit vector with the little endian representation of a long.
  - toLongArray
```
long[] toLongArray()
```
    See BitSet#toLongArray in Java 7. The main difference is that we do not stop at the highest set bit.
  - toBigEndianByteArray
```
byte[] toBigEndianByteArray()
```
  - toBigInteger
```
BigInteger toBigInteger()
```
    While {toLong() can return a negative long, {toBigInteger() always produces a nonnegative value.
  - copyFrom
```
void copyFrom(long[] array)
```
    Makes this bit vector have the same bit pattern as the little-endian long array, size permitting.
    
    Parameters:
    array - must have length (size() + 63) / 64
  - copyFromBigEndian
```
void copyFromBigEndian(byte[] array)
```
    Makes this bit vector have the same bit pattern as the little-endian long array, size permitting.
    
    Parameters:
    array - must have length (size() + 7) / 8
  - copyFrom
```
void copyFrom(BigInteger s)
```
  - hashCode
```
int hashCode()
```
    Overrides:
    
    hashCode in class Object
    
    Returns:
    size() + 31 * toBitSet().hashCode()
  - equals
```
boolean equals(Object o)
```
    Two bit vectors are deemed iff they have the same size and they represent the same bit pattern.
    
    Overrides:
    
    equals in class Object
  - compareTo
```
int compareTo(BitVector o)
```
    Compares the unsigned numbers having the pattern in this and the other bit vectors, respectively, as the little endian representation. The result has the same sign as toBigInteger().compareTo(o.toBigInteger()).
    
    Specified by:
    
    compareTo in interface Comparable<BitVector>
    
    Throws:
    
    IllegalArgumentException - when size() != o.size()

Interface BitVector

Method Summary

Method Detail

isEmpty

set

set

set

set

get

copyFromSection

copySectionFrom

length

size

clear

clear

clear

cardinality

flip

flip

intersects

nextSetBit

nextClearBit

increment

andNot

and

or

xor

rotate

grayCode

grayCodeInverse

smallerEvenAndGrayCode

lowestDifferentBit

areAllLowestBitsClear

grayCodeRank

grayCodeRankInverse

copyFrom

copyFrom

clone

toBitSet

toLong

toExactLong

copyFrom

toLongArray

toBigEndianByteArray

toBigInteger

copyFrom

copyFromBigEndian

copyFrom

hashCode

equals

compareTo