LongBitVector (Uzaygezen-core 0.2 API)

java.lang.Object
- com.google.uzaygezen.core.LongBitVector

All Implemented Interfaces:

BitVector, Cloneable, Comparable<BitVector>
```
public final class LongBitVector
extends Object
implements BitVector, Cloneable
```
BitVector implementation for vectors of length 64 or less.

Author:

Mehmet Akin, Daniel Aioanei

Constructor Summary

Constructors
Constructor and Description

LongBitVector(int size)

Constructors
Constructor and Description
`LongBitVector(int size)`

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)`
`LongBitVector`	`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 value)` 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 `BitVector.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 obj)` 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 `BitVector.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 o)`
`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 `BitVector.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 {`BitVector.toLong()` can return a negative long, {`BitVector.toBigInteger()` always produces a nonnegative value.
`BitSet`	`toBitSet()` Returns a non-shared bit set representing the same set of bits.
`long`	`toExactLong()` Like `BitVector.toLong()`, but fails if the number doesn't fit in 64 bits.
`long`	`toLong()`
`long[]`	`toLongArray()` See `BitSet#toLongArray` in Java 7.
`String`	`toString()`
`void`	`xor(BitVector o)`

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - LongBitVector
```
public LongBitVector(int size)
```
- Method Detail
  - and
```
public void and(BitVector o)
```
    Specified by:
    
    and in interface BitVector
  - andNot
```
public void andNot(BitVector o)
```
    Specified by:
    
    andNot in interface BitVector
  - cardinality
```
public int cardinality()
```
    Specified by:
    
    cardinality in interface BitVector
    
    Returns:
    number of 1's in BitVector.
  - clear
```
public void clear()
```
    Description copied from interface: BitVector
    
    Makes BitVector contain all zeros.
    
    Specified by:
    
    clear in interface BitVector
  - clear
```
public void clear(int bitIndex)
```
    Specified by:
    
    clear in interface BitVector
  - clear
```
public void clear(int fromIndex,
         int toIndex)
```
    Specified by:
    
    clear in interface BitVector
  - copyFrom
```
public void copyFrom(BitVector from)
```
    Description copied from interface: BitVector
    
    Makes this BitVector equal to the other bit vector. The two bit vectors must have the same size.
    
    Specified by:
    
    copyFrom in interface BitVector
    
    See Also:
    for copying bits between bit vectors of different sizes
  - flip
```
public void flip(int bitIndex)
```
    Specified by:
    
    flip in interface BitVector
  - flip
```
public void flip(int fromIndex,
        int toIndex)
```
    Specified by:
    
    flip in interface BitVector
  - get
```
public boolean get(int bitIndex)
```
    Specified by:
    
    get in interface BitVector
  - grayCode
```
public void grayCode()
```
    Description copied from interface: BitVector
    
    Encodes the content of bitVector as Gray code.
    
    Specified by:
    
    grayCode in interface BitVector
  - grayCodeInverse
```
public void grayCodeInverse()
```
    Description copied from interface: BitVector
    
    Decodes the content of bitVector from Gray code to natural binary code.
    
    Specified by:
    
    grayCodeInverse in interface BitVector
  - increment
```
public boolean increment()
```
    Description copied from interface: BitVector
    
    If at least one bit is false then the value is incremented by one and true is returned; otherwise false is returned.
    
    Specified by:
    
    increment in interface BitVector
  - intersects
```
public boolean intersects(BitVector o)
```
    Specified by:
    
    intersects in interface BitVector
  - length
```
public int length()
```
    Specified by:
    
    length in interface BitVector
  - size
```
public int size()
```
    Specified by:
    
    size in interface BitVector
  - nextClearBit
```
public int nextClearBit(int fromIndex)
```
    Description copied from interface: BitVector
    
    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).
    
    Specified by:
    
    nextClearBit in interface BitVector
  - nextSetBit
```
public int nextSetBit(int fromIndex)
```
    Description copied from interface: BitVector
    
    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.
    
    Specified by:
    
    nextSetBit in interface BitVector
  - or
```
public void or(BitVector o)
```
    Description copied from interface: BitVector
    
    Bitwise or with given BitVector
    
    Specified by:
    
    or in interface BitVector
    
    Parameters:
    o - A BitVector, sizes must be equal.
  - rotate
```
public void rotate(int count)
```
    Description copied from interface: BitVector
    
    Rotates by count bits to the right.
    
    Specified by:
    
    rotate in interface BitVector
    
    Parameters:
    count - can be negative
  - set
```
public void set(int bitIndex)
```
    Specified by:
    
    set in interface BitVector
  - set
```
public void set(int bitIndex,
       boolean value)
```
    Specified by:
    
    set in interface BitVector
  - set
```
public void set(int fromIndex,
       int toIndex)
```
    Specified by:
    
    set in interface BitVector
  - set
```
public void set(int fromIndex,
       int toIndex,
       boolean value)
```
    Specified by:
    
    set in interface BitVector
  - xor
```
public void xor(BitVector o)
```
    Specified by:
    
    xor in interface BitVector
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface BitVector
  - clone
```
public LongBitVector clone()
```
    Specified by:
    
    clone in interface BitVector
    
    Overrides:
    
    clone in class Object
  - equals
```
public boolean equals(Object obj)
```
    Description copied from interface: BitVector
    
    Two bit vectors are deemed iff they have the same size and they represent the same bit pattern.
    
    Specified by:
    
    equals in interface BitVector
    
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface BitVector
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    size() + 31 * toBitSet().hashCode()
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - toBitSet
```
public BitSet toBitSet()
```
    Description copied from interface: BitVector
    
    Returns a non-shared bit set representing the same set of bits.
    
    Specified by:
    
    toBitSet in interface BitVector
  - toLong
```
public long toLong()
```
    Specified by:
    
    toLong in interface BitVector
    
    Returns:
    lowest 64 bit of BitVector as a long. Higher bits are ignored. The result is negative iff bit 63 is set.
  - toBigInteger
```
public BigInteger toBigInteger()
```
    Description copied from interface: BitVector
    
    While {BitVector.toLong() can return a negative long, {BitVector.toBigInteger() always produces a nonnegative value.
    
    Specified by:
    
    toBigInteger in interface BitVector
  - copyFrom
```
public void copyFrom(long value)
```
    Description copied from interface: BitVector
    
    Initialises this bit vector with the little endian representation of a long.
    
    Specified by:
    
    copyFrom in interface BitVector
  - compareTo
```
public int compareTo(BitVector o)
```
    Description copied from interface: BitVector
    
    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 BitVector
    
    Specified by:
    
    compareTo in interface Comparable<BitVector>
  - copyFrom
```
public void copyFrom(BitSet from)
```
    Description copied from interface: BitVector
    
    Makes this BitVector equal to the given bit set.
    
    Specified by:
    
    copyFrom in interface BitVector
  - copyFromSection
```
public void copyFromSection(BitVector src,
                   int fromIndex)
```
    Description copied from interface: BitVector
    
    Copies BitVector.size() bits from src, starting with fromIndex.
    
    Specified by:
    
    copyFromSection in interface BitVector
  - toExactLong
```
public long toExactLong()
```
    Description copied from interface: BitVector
    
    Like BitVector.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.
    
    Specified by:
    
    toExactLong in interface BitVector
  - smallerEvenAndGrayCode
```
public void smallerEvenAndGrayCode()
```
    Description copied from interface: BitVector
    
    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.
    
    Specified by:
    
    smallerEvenAndGrayCode in interface BitVector
  - grayCodeRank
```
public void grayCodeRank(BitVector mu,
                BitVector w)
```
    Description copied from interface: BitVector
    
    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.
    
    Specified by:
    
    grayCodeRank in interface BitVector
    
    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.
  - lowestDifferentBit
```
public int lowestDifferentBit()
```
    Description copied from interface: BitVector
    
    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 BitVector.size();
    
    Specified by:
    
    lowestDifferentBit in interface BitVector
    
    Returns:
    number of same lowest bits; the value returned always satisfies the condition result == 0 || (0 < result & result < size)
  - grayCodeRankInverse
```
public void grayCodeRankInverse(BitVector mu,
                       BitVector known,
                       BitVector r)
```
    Description copied from interface: BitVector
    
    Giving the name i to the bit set represented by this, this method computes the inverse function for BitVector.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 BitVector.grayCode() can be called with this method's output (i.e., this) as input.
    
    Specified by:
    
    grayCodeRankInverse in interface BitVector
    
    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
  - copySectionFrom
```
public void copySectionFrom(int offset,
                   BitVector src)
```
    Description copied from interface: BitVector
    
    Copies all src.size() bits from src into this bit vector, starting with position offset.
    
    Specified by:
    
    copySectionFrom in interface BitVector
  - toLongArray
```
public long[] toLongArray()
```
    Description copied from interface: BitVector
    
    See BitSet#toLongArray in Java 7. The main difference is that we do not stop at the highest set bit.
    
    Specified by:
    
    toLongArray in interface BitVector
  - toBigEndianByteArray
```
public byte[] toBigEndianByteArray()
```
    Specified by:
    
    toBigEndianByteArray in interface BitVector
  - copyFrom
```
public void copyFrom(long[] array)
```
    Description copied from interface: BitVector
    
    Makes this bit vector have the same bit pattern as the little-endian long array, size permitting.
    
    Specified by:
    
    copyFrom in interface BitVector
    
    Parameters:
    array - must have length (size() + 63) / 64
  - copyFromBigEndian
```
public void copyFromBigEndian(byte[] array)
```
    Description copied from interface: BitVector
    
    Makes this bit vector have the same bit pattern as the little-endian long array, size permitting.
    
    Specified by:
    
    copyFromBigEndian in interface BitVector
    
    Parameters:
    array - must have length (size() + 7) / 8
  - areAllLowestBitsClear
```
public boolean areAllLowestBitsClear(int bitCount)
```
    Specified by:
    
    areAllLowestBitsClear in interface BitVector
    
    Returns:
    true if the lowest bitCount bits are clear; false otherwise. If called with the parameter bitCount = 0 it will always return true.
  - copyFrom
```
public void copyFrom(BigInteger s)
```
    Specified by:
    
    copyFrom in interface BitVector

Class LongBitVector

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

LongBitVector

Method Detail

and

andNot

cardinality

clear

clear

clear

copyFrom

flip

flip

get

grayCode

grayCodeInverse

increment

intersects

length

size

nextClearBit

nextSetBit

or

rotate

set

set

set

set

xor

isEmpty

clone

equals

hashCode

toString

toBitSet

toLong

toBigInteger

copyFrom

compareTo

copyFrom

copyFromSection

toExactLong

smallerEvenAndGrayCode

grayCodeRank

lowestDifferentBit

grayCodeRankInverse

copySectionFrom

toLongArray

toBigEndianByteArray

copyFrom

copyFromBigEndian

areAllLowestBitsClear

copyFrom