EWAHCompressedBitmap (JavaEWAH 0.8.4 API)

java.lang.Object
- com.googlecode.javaewah.EWAHCompressedBitmap

All Implemented Interfaces:

BitmapStorage, LogicalElement<EWAHCompressedBitmap>, Externalizable, Serializable, Cloneable, Iterable<Integer>
```
public final class EWAHCompressedBitmap
extends Object
implements Cloneable, Externalizable, Iterable<Integer>, BitmapStorage, LogicalElement<EWAHCompressedBitmap>
```
This implements the patent-free(1) EWAH scheme. Roughly speaking, it is a 64-bit variant of the BBC compression scheme used by Oracle for its bitmap indexes.

The objective of this compression type is to provide some compression, while reducing as much as possible the CPU cycle usage.

Once constructed, the bitmap is essentially immutable (unless you call the "set" or "add" methods). Thus, it can be safely used in multi-threaded programs.

This implementation being 64-bit, it assumes a 64-bit CPU together with a 64-bit Java Virtual Machine. This same code on a 32-bit machine may not be as fast. There is also a 32-bit version of this code in the class javaewah32.EWAHCompressedBitmap32.

Here is a code sample to illustrate usage:
```
 EWAHCompressedBitmap ewahBitmap1 = EWAHCompressedBitmap.bitmapOf(0, 2, 55, 64,
         1 << 30);
 EWAHCompressedBitmap ewahBitmap2 = EWAHCompressedBitmap.bitmapOf(1, 3, 64,
         1 << 30);
 EWAHCompressedBitmap ewahBitmap3 = EWAHCompressedBitmap
         .bitmapOf(5, 55, 1 << 30);
 EWAHCompressedBitmap ewahBitmap4 = EWAHCompressedBitmap
         .bitmapOf(4, 66, 1 << 30);
 EWAHCompressedBitmap orbitmap = ewahBitmap1.or(ewahBitmap2);
 EWAHCompressedBitmap andbitmap = ewahBitmap1.and(ewahBitmap2);
 EWAHCompressedBitmap xorbitmap = ewahBitmap1.xor(ewahBitmap2);
 andbitmap = EWAHCompressedBitmap.and(ewahBitmap1, ewahBitmap2, ewahBitmap3,
         ewahBitmap4);
 ByteArrayOutputStream bos = new ByteArrayOutputStream();
 ObjectOutputStream oo = new ObjectOutputStream(bos);
 ewahBitmap1.writeExternal(oo);
 oo.close();
 ewahBitmap1 = null;
 ewahBitmap1 = new EWAHCompressedBitmap();
 ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
 ewahBitmap1.readExternal(new ObjectInputStream(bis));
 EWAHCompressedBitmap threshold2 = EWAHCompressedBitmap.threshold(2,
         ewahBitmap1, ewahBitmap2, ewahBitmap3, ewahBitmap4);
 
```
For more details, see the following papers:
- Daniel Lemire, Owen Kaser, Kamel Aouiche, Sorting improves word-aligned bitmap indexes. Data & Knowledge Engineering 69 (1), pages 3-28, 2010. http://arxiv.org/abs/0901.3751
- Owen Kaser and Daniel Lemire, Compressed bitmap indexes: beyond unions and intersections http://arxiv.org/abs/1402.4466
A 32-bit version of the compressed format was described by Wu et al. and named WBC:
- K. Wu, E. J. Otoo, A. Shoshani, H. Nordberg, Notes on design and implementation of compressed bit vectors, Tech. Rep. LBNL/PUB-3161, Lawrence Berkeley National Laboratory, available from http://crd.lbl. gov/~kewu/ps/PUB-3161.html (2001).
Probably, the best prior art is the Oracle bitmap compression scheme (BBC):
- G. Antoshenkov, Byte-Aligned Bitmap Compression, DCC'95, 1995.
1- The authors do not know of any patent infringed by the following implementation. However, similar schemes, like WAH are covered by patents.
Since:

0.1.0

See Also:
EWAHCompressedBitmap32, Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static boolean`	`adjustContainerSizeWhenAggregating` whether we adjust after some aggregation by adding in zeroes
`static int`	`wordinbits` The Constant wordinbits represents the number of bits in a long.

Constructor Summary

Constructors
Constructor and Description
`EWAHCompressedBitmap()` Creates an empty bitmap (no bit set to true).
`EWAHCompressedBitmap(int buffersize)` Sets explicitly the buffer size (in 64-bit words).

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`add(long newdata)` Deprecated. use addWord() instead.
`void`	`add(long newdata, int bitsthatmatter)` Deprecated. use addWord() instead.
`void`	`addStreamOfEmptyWords(boolean v, long number)` For experts: You want to add many zeroes or ones? This is the method you use.
`void`	`addStreamOfLiteralWords(long[] data, int start, int number)` if you have several literal words to copy over, this might be faster.
`void`	`addStreamOfNegatedLiteralWords(long[] data, int start, int number)` Same as addStreamOfLiteralWords, but the words are negated.
`void`	`addWord(long newdata)` Adding words directly to the bitmap (for expert use).
`void`	`addWord(long newdata, int bitsthatmatter)` Adding words directly to the bitmap (for expert use).
`static EWAHCompressedBitmap`	`and(EWAHCompressedBitmap... bitmaps)` Returns a new compressed bitmap containing the bitwise AND values of the provided bitmaps.
`EWAHCompressedBitmap`	`and(EWAHCompressedBitmap a)` Returns a new compressed bitmap containing the bitwise AND values of the current bitmap with some other bitmap.
`static int`	`andCardinality(EWAHCompressedBitmap... bitmaps)` Returns the cardinality of the result of a bitwise AND of the values of the provided bitmaps.
`int`	`andCardinality(EWAHCompressedBitmap a)` Returns the cardinality of the result of a bitwise AND of the values of the current bitmap with some other bitmap.
`EWAHCompressedBitmap`	`andNot(EWAHCompressedBitmap a)` Returns a new compressed bitmap containing the bitwise AND NOT values of the current bitmap with some other bitmap.
`int`	`andNotCardinality(EWAHCompressedBitmap a)` Returns the cardinality of the result of a bitwise AND NOT of the values of the current bitmap with some other bitmap.
`void`	`andNotToContainer(EWAHCompressedBitmap a, BitmapStorage container)` Returns a new compressed bitmap containing the bitwise AND NOT values of the current bitmap with some other bitmap.
`void`	`andToContainer(EWAHCompressedBitmap a, BitmapStorage container)` Computes new compressed bitmap containing the bitwise AND values of the current bitmap with some other bitmap.
`static void`	`andWithContainer(BitmapStorage container, EWAHCompressedBitmap... bitmaps)` For internal use.
`static EWAHCompressedBitmap`	`bitmapOf(int... setbits)` Return a bitmap with the bit set to true at the given positions.
`int`	`cardinality()` reports the number of bits set to true.
`void`	`clear()` Clear any set bits and set size in bits back to 0
`IntIterator`	`clearIntIterator()` Iterator over the clear bits.
`EWAHCompressedBitmap`	`clone()`
`void`	`deserialize(DataInput in)` Deserialize.
`boolean`	`equals(Object o)` Check to see whether the two compressed bitmaps contain the same set bits.
`boolean`	`get(int i)` Query the value of a single bit.
`EWAHIterator`	`getEWAHIterator()` Gets an EWAHIterator over the data.
`IteratingRLW`	`getIteratingRLW()` Gets an IteratingRLW to iterate over the data.
`List<Integer>`	`getPositions()` Deprecated. use toList() instead.
`int`	`hashCode()` Returns a customized hash code (based on Karp-Rabin).
`boolean`	`intersects(EWAHCompressedBitmap a)` Return true if the two EWAHCompressedBitmap have both at least one true bit in the same position.
`IntIterator`	`intIterator()` Iterator over the set bits (this is what most people will want to use to browse the content if they want an iterator).
`Iterator<Integer>`	`iterator()` Iterates over the positions of the true values.
`void`	`not()` Negate (bitwise) the current bitmap.
`static EWAHCompressedBitmap`	`or(EWAHCompressedBitmap... bitmaps)` Returns a new compressed bitmap containing the bitwise OR values of the provided bitmaps.
`EWAHCompressedBitmap`	`or(EWAHCompressedBitmap a)` Returns a new compressed bitmap containing the bitwise OR values of the current bitmap with some other bitmap.
`static int`	`orCardinality(EWAHCompressedBitmap... bitmaps)` Returns the cardinality of the result of a bitwise OR of the values of the provided bitmaps.
`int`	`orCardinality(EWAHCompressedBitmap a)` Returns the cardinality of the result of a bitwise OR of the values of the current bitmap with some other bitmap.
`void`	`orToContainer(EWAHCompressedBitmap a, BitmapStorage container)` Computes the bitwise or between the current bitmap and the bitmap "a".
`static void`	`orWithContainer(BitmapStorage container, EWAHCompressedBitmap... bitmaps)` Uses an adaptive technique to compute the logical OR.
`void`	`readExternal(ObjectInput in)`
`void`	`serialize(DataOutput out)` Serialize.
`int`	`serializedSizeInBytes()` Report the size required to serialize this bitmap The current bitmap is not modified.
`boolean`	`set(int i)` Set the bit at position i to true, the bits must be set in (strictly) increasing order.
`void`	`setSizeInBits(int size)` Set the size in bits.
`boolean`	`setSizeInBits(int size, boolean defaultvalue)` Change the reported size in bits of the uncompressed bitmap represented by this compressed bitmap.
`int`	`sizeInBits()` Returns the size in bits of the uncompressed bitmap represented by this compressed bitmap.
`int`	`sizeInBytes()` Report the compressed size of the bitmap (equivalent to memory usage, after accounting for some overhead).
`void`	`swap(EWAHCompressedBitmap other)` Swap the content of the bitmap with another.
`static EWAHCompressedBitmap`	`threshold(int T, EWAHCompressedBitmap... bitmaps)` Compute a Boolean threshold function: bits are true where at least T bitmaps have a true bit.
`static void`	`thresholdWithContainer(BitmapStorage container, int T, EWAHCompressedBitmap... bitmaps)` Compute a Boolean threshold function: bits are true where at least T bitmaps have a true bit.
`int[]`	`toArray()` Populate an array of (sorted integers) corresponding to the location of the set bits.
`String`	`toDebugString()` A more detailed string describing the bitmap (useful for debugging).
`List<Integer>`	`toList()` Gets the locations of the true values as one list.
`String`	`toString()` A string describing the bitmap.
`void`	`trim()` Reduce the internal buffer to its minimal allowable size (given by this.actualsizeinwords).
`void`	`writeExternal(ObjectOutput out)`
`static EWAHCompressedBitmap`	`xor(EWAHCompressedBitmap... bitmaps)` Returns a new compressed bitmap containing the bitwise XOR values of the provided bitmaps.
`EWAHCompressedBitmap`	`xor(EWAHCompressedBitmap a)` Returns a new compressed bitmap containing the bitwise XOR values of the current bitmap with some other bitmap.
`int`	`xorCardinality(EWAHCompressedBitmap a)` Returns the cardinality of the result of a bitwise XOR of the values of the current bitmap with some other bitmap.
`void`	`xorToContainer(EWAHCompressedBitmap a, BitmapStorage container)` Computes a new compressed bitmap containing the bitwise XOR values of the current bitmap with some other bitmap.
`static void`	`xorWithContainer(BitmapStorage container, EWAHCompressedBitmap... bitmaps)` Uses an adaptive technique to compute the logical XOR.

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

- Field Detail
  - adjustContainerSizeWhenAggregating
```
public static final boolean adjustContainerSizeWhenAggregating
```
    whether we adjust after some aggregation by adding in zeroes
    
    See Also:
    Constant Field Values
  - wordinbits
```
public static final int wordinbits
```
    The Constant wordinbits represents the number of bits in a long.
    
    See Also:
    Constant Field Values
- Constructor Detail
  - EWAHCompressedBitmap
```
public EWAHCompressedBitmap()
```
    Creates an empty bitmap (no bit set to true).
  - EWAHCompressedBitmap
```
public EWAHCompressedBitmap(int buffersize)
```
    Sets explicitly the buffer size (in 64-bit words). The initial memory usage will be "buffersize * 64". For large poorly compressible bitmaps, using large values may improve performance.
    
    Parameters:
    buffersize - number of 64-bit words reserved when the object is created)
- Method Detail
  - add
```
@Deprecated
public void add(long newdata)
```
    Deprecated. use addWord() instead.
    
    Parameters:
    newdata - the word
  - add
```
@Deprecated
public void add(long newdata,
                  int bitsthatmatter)
```
    Deprecated. use addWord() instead.
    
    Parameters:
    newdata - the word
    bitsthatmatter - the number of significant bits (by default it should be 64)
  - addWord
```
public void addWord(long newdata)
```
    Adding words directly to the bitmap (for expert use). This method adds bits in words of 4*8 bits. It is not to be confused with the set method which sets individual bits. Most users will want the set method. Example: if you add word 321 to an empty bitmap, you are have added (in binary notation) 0b101000001, so you have effectively called set(0), set(6), set(8) in sequence. Since this modifies the bitmap, this method is not thread-safe. API change: prior to version 0.8.3, this method was called add.
    
    Specified by:
    
    addWord in interface BitmapStorage
    
    Parameters:
    newdata - the word
  - addWord
```
public void addWord(long newdata,
           int bitsthatmatter)
```
    Adding words directly to the bitmap (for expert use). Since this modifies the bitmap, this method is not thread-safe. API change: prior to version 0.8.3, this method was called add.
    
    Parameters:
    newdata - the word
    bitsthatmatter - the number of significant bits (by default it should be 64)
  - addStreamOfLiteralWords
```
public void addStreamOfLiteralWords(long[] data,
                           int start,
                           int number)
```
    if you have several literal words to copy over, this might be faster. Since this modifies the bitmap, this method is not thread-safe.
    
    Specified by:
    
    addStreamOfLiteralWords in interface BitmapStorage
    
    Parameters:
    data - the literal words
    start - the starting point in the array
    number - the number of literal words to add
  - addStreamOfEmptyWords
```
public void addStreamOfEmptyWords(boolean v,
                         long number)
```
    For experts: You want to add many zeroes or ones? This is the method you use. Since this modifies the bitmap, this method is not thread-safe.
    
    Specified by:
    
    addStreamOfEmptyWords in interface BitmapStorage
    
    Parameters:
    v - the boolean value
    number - the number
  - addStreamOfNegatedLiteralWords
```
public void addStreamOfNegatedLiteralWords(long[] data,
                                  int start,
                                  int number)
```
    Same as addStreamOfLiteralWords, but the words are negated. Since this modifies the bitmap, this method is not thread-safe.
    
    Specified by:
    
    addStreamOfNegatedLiteralWords in interface BitmapStorage
    
    Parameters:
    data - the literal words
    start - the starting point in the array
    number - the number of literal words to add
  - and
```
public EWAHCompressedBitmap and(EWAHCompressedBitmap a)
```
    Returns a new compressed bitmap containing the bitwise AND values of the current bitmap with some other bitmap. The running time is proportional to the sum of the compressed sizes (as reported by sizeInBytes()). If you are not planning on adding to the resulting bitmap, you may call the trim() method to reduce memory usage. The current bitmap is not modified.
    
    Specified by:
    
    and in interface LogicalElement<EWAHCompressedBitmap>
    
    Parameters:
    a - the other bitmap (it will not be modified)
    
    Returns:
    the EWAH compressed bitmap
    Since:
    
    0.4.3
  - andToContainer
```
public void andToContainer(EWAHCompressedBitmap a,
                  BitmapStorage container)
```
    Computes new compressed bitmap containing the bitwise AND values of the current bitmap with some other bitmap. The running time is proportional to the sum of the compressed sizes (as reported by sizeInBytes()). The current bitmap is not modified.
    
    Parameters:
    a - the other bitmap (it will not be modified)
    container - where we store the result
    Since:
    
    0.4.0
  - andCardinality
```
public int andCardinality(EWAHCompressedBitmap a)
```
    Returns the cardinality of the result of a bitwise AND of the values of the current bitmap with some other bitmap. Avoids allocating an intermediate bitmap to hold the result of the OR. The current bitmap is not modified.
    
    Parameters:
    a - the other bitmap (it will not be modified)
    
    Returns:
    the cardinality
    Since:
    
    0.4.0
  - andNot
```
public EWAHCompressedBitmap andNot(EWAHCompressedBitmap a)
```
    Returns a new compressed bitmap containing the bitwise AND NOT values of the current bitmap with some other bitmap. The running time is proportional to the sum of the compressed sizes (as reported by sizeInBytes()). If you are not planning on adding to the resulting bitmap, you may call the trim() method to reduce memory usage. The current bitmap is not modified.
    
    Specified by:
    
    andNot in interface LogicalElement<EWAHCompressedBitmap>
    
    Parameters:
    a - the other bitmap (it will not be modified)
    
    Returns:
    the EWAH compressed bitmap
  - andNotToContainer
```
public void andNotToContainer(EWAHCompressedBitmap a,
                     BitmapStorage container)
```
    Returns a new compressed bitmap containing the bitwise AND NOT values of the current bitmap with some other bitmap. This method is expected to be faster than doing A.and(B.clone().not()). The running time is proportional to the sum of the compressed sizes (as reported by sizeInBytes()). The current bitmap is not modified.
    
    Parameters:
    a - the other bitmap (it will not be modified)
    container - where to store the result
    Since:
    
    0.4.0
  - andNotCardinality
```
public int andNotCardinality(EWAHCompressedBitmap a)
```
    Returns the cardinality of the result of a bitwise AND NOT of the values of the current bitmap with some other bitmap. Avoids allocating an intermediate bitmap to hold the result of the OR. The current bitmap is not modified.
    
    Parameters:
    a - the other bitmap (it will not be modified)
    
    Returns:
    the cardinality
    Since:
    
    0.4.0
  - cardinality
```
public int cardinality()
```
    reports the number of bits set to true. Running time is proportional to compressed size (as reported by sizeInBytes).
    
    Returns:
    the number of bits set to true
  - clear
```
public void clear()
```
    Clear any set bits and set size in bits back to 0
  - clone
```
public EWAHCompressedBitmap clone()
```
    Overrides:
    
    clone in class Object
  - deserialize
```
public void deserialize(DataInput in)
                 throws IOException
```
    Deserialize.
    
    Parameters:
    in - the DataInput stream
    
    Throws:
    
    IOException - Signals that an I/O exception has occurred.
  - equals
```
public boolean equals(Object o)
```
    Check to see whether the two compressed bitmaps contain the same set bits.
    
    Overrides:
    
    equals in class Object
    
    See Also:
    Object.equals(java.lang.Object)
  - getEWAHIterator
```
public EWAHIterator getEWAHIterator()
```
    Gets an EWAHIterator over the data. This is a customized iterator which iterates over run length words. For experts only. The current bitmap is not modified.
    
    Returns:
    the EWAHIterator
  - getIteratingRLW
```
public IteratingRLW getIteratingRLW()
```
    Gets an IteratingRLW to iterate over the data. For experts only. The current bitmap is not modified.
    
    Returns:
    the IteratingRLW iterator corresponding to this bitmap
  - getPositions
```
@Deprecated
public List<Integer> getPositions()
```
    Deprecated. use toList() instead.
    
    Returns:
    a list
  - toList
```
public List<Integer> toList()
```
    Gets the locations of the true values as one list. (May use more memory than iterator().) The current bitmap is not modified. API change: prior to version 0.8.3, this method was called getPositions.
    
    Returns:
    the positions in a list
  - hashCode
```
public int hashCode()
```
    Returns a customized hash code (based on Karp-Rabin). Naturally, if the bitmaps are equal, they will hash to the same value. The current bitmap is not modified.
    
    Overrides:
    
    hashCode in class Object
  - intersects
```
public boolean intersects(EWAHCompressedBitmap a)
```
    Return true if the two EWAHCompressedBitmap have both at least one true bit in the same position. Equivalently, you could call "and" and check whether there is a set bit, but intersects will run faster if you don't need the result of the "and" operation. The current bitmap is not modified.
    
    Parameters:
    a - the other bitmap (it will not be modified)
    
    Returns:
    whether they intersect
    Since:
    
    0.3.2
  - intIterator
```
public IntIterator intIterator()
```
    Iterator over the set bits (this is what most people will want to use to browse the content if they want an iterator). The location of the set bits is returned, in increasing order. The current bitmap is not modified.
    
    Returns:
    the int iterator
  - clearIntIterator
```
public IntIterator clearIntIterator()
```
    Iterator over the clear bits. The location of the clear bits is returned, in increasing order. The current bitmap is not modified.
    
    Returns:
    the int iterator
  - iterator
```
public Iterator<Integer> iterator()
```
    Iterates over the positions of the true values. This is similar to intIterator(), but it uses Java generics. The current bitmap is not modified.
    
    Specified by:
    
    iterator in interface Iterable<Integer>
    
    Returns:
    the iterator
  - not
```
public void not()
```
    Negate (bitwise) the current bitmap. To get a negated copy, do EWAHCompressedBitmap x= ((EWAHCompressedBitmap) mybitmap.clone()); x.not(); The running time is proportional to the compressed size (as reported by sizeInBytes()). Because this modifies the bitmap, this method is not thread-safe.
    
    Specified by:
    
    not in interface LogicalElement<EWAHCompressedBitmap>
  - or
```
public EWAHCompressedBitmap or(EWAHCompressedBitmap a)
```
    Returns a new compressed bitmap containing the bitwise OR values of the current bitmap with some other bitmap. The running time is proportional to the sum of the compressed sizes (as reported by sizeInBytes()). If you are not planning on adding to the resulting bitmap, you may call the trim() method to reduce memory usage. The current bitmap is not modified.
    
    Specified by:
    
    or in interface LogicalElement<EWAHCompressedBitmap>
    
    Parameters:
    a - the other bitmap (it will not be modified)
    
    Returns:
    the EWAH compressed bitmap
  - orToContainer
```
public void orToContainer(EWAHCompressedBitmap a,
                 BitmapStorage container)
```
    Computes the bitwise or between the current bitmap and the bitmap "a". Stores the result in the container. The current bitmap is not modified.
    
    Parameters:
    a - the other bitmap (it will not be modified)
    container - where we store the result
    Since:
    
    0.4.0
  - orCardinality
```
public int orCardinality(EWAHCompressedBitmap a)
```
    Returns the cardinality of the result of a bitwise OR of the values of the current bitmap with some other bitmap. Avoids allocating an intermediate bitmap to hold the result of the OR. The current bitmap is not modified.
    
    Parameters:
    a - the other bitmap (it will not be modified)
    
    Returns:
    the cardinality
    Since:
    
    0.4.0
  - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException
```
    Specified by:
    
    readExternal in interface Externalizable
    
    Throws:
    
    IOException
  - serialize
```
public void serialize(DataOutput out)
               throws IOException
```
    Serialize. The current bitmap is not modified.
    
    Parameters:
    out - the DataOutput stream
    
    Throws:
    
    IOException - Signals that an I/O exception has occurred.
  - serializedSizeInBytes
```
public int serializedSizeInBytes()
```
    Report the size required to serialize this bitmap The current bitmap is not modified.
    
    Returns:
    the size in bytes
  - get
```
public boolean get(int i)
```
    Query the value of a single bit. Relying on this method when speed is needed is discouraged. The complexity is linear with the size of the bitmap. (This implementation is based on zhenjl's Go version of JavaEWAH.) The current bitmap is not modified.
    
    Parameters:
    i - the bit we are interested in
    
    Returns:
    whether the bit is set to true
  - set
```
public boolean set(int i)
```
    Set the bit at position i to true, the bits must be set in (strictly) increasing order. For example, set(15) and then set(7) will fail. You must do set(7) and then set(15). Since this modifies the bitmap, this method is not thread-safe.
    
    Parameters:
    i - the index
    
    Returns:
    true if the value was set (always true when i greater or equal to sizeInBits()).
    
    Throws:
    
    IndexOutOfBoundsException - if i is negative or greater than Integer.MAX_VALUE - 64
  - setSizeInBits
```
public void setSizeInBits(int size)
```
    Set the size in bits. This does not change the compressed bitmap.
    
    Specified by:
    
    setSizeInBits in interface BitmapStorage
    
    Parameters:
    size - number of bits
    Since:
    
    0.4.0
  - setSizeInBits
```
public boolean setSizeInBits(int size,
                    boolean defaultvalue)
```
    Change the reported size in bits of the *uncompressed* bitmap represented by this compressed bitmap. It may change the underlying compressed bitmap. It is not possible to reduce the sizeInBits, but it can be extended. The new bits are set to false or true depending on the value of defaultvalue. This method is not thread-safe.
    
    Parameters:
    size - the size in bits
    defaultvalue - the default boolean value
    
    Returns:
    true if the update was possible
  - sizeInBits
```
public int sizeInBits()
```
    Returns the size in bits of the *uncompressed* bitmap represented by this compressed bitmap. Initially, the sizeInBits is zero. It is extended automatically when you set bits to true. The current bitmap is not modified.
    
    Specified by:
    
    sizeInBits in interface LogicalElement<EWAHCompressedBitmap>
    
    Returns:
    the size in bits
  - sizeInBytes
```
public int sizeInBytes()
```
    Report the *compressed* size of the bitmap (equivalent to memory usage, after accounting for some overhead).
    
    Specified by:
    
    sizeInBytes in interface LogicalElement<EWAHCompressedBitmap>
    
    Returns:
    the size in bytes
  - threshold
```
public static EWAHCompressedBitmap threshold(int T,
                             EWAHCompressedBitmap... bitmaps)
```
    Compute a Boolean threshold function: bits are true where at least T bitmaps have a true bit.
    
    Parameters:
    T - the threshold
    bitmaps - input data
    
    Returns:
    the aggregated bitmap
    Since:
    
    0.8.1
  - thresholdWithContainer
```
public static void thresholdWithContainer(BitmapStorage container,
                          int T,
                          EWAHCompressedBitmap... bitmaps)
```
    Compute a Boolean threshold function: bits are true where at least T bitmaps have a true bit.
    
    Parameters:
    T - the threshold
    bitmaps - input data
    container - where we write the aggregated bitmap
    Since:
    
    0.8.1
  - toArray
```
public int[] toArray()
```
    Populate an array of (sorted integers) corresponding to the location of the set bits.
    
    Returns:
    the array containing the location of the set bits
  - toDebugString
```
public String toDebugString()
```
    A more detailed string describing the bitmap (useful for debugging).
    
    Returns:
    the string
  - toString
```
public String toString()
```
    A string describing the bitmap.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    the string
  - swap
```
public void swap(EWAHCompressedBitmap other)
```
    Swap the content of the bitmap with another.
    
    Parameters:
    other - bitmap to swap with
  - trim
```
public void trim()
```
    Reduce the internal buffer to its minimal allowable size (given by this.actualsizeinwords). This can free memory.
  - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
    Specified by:
    
    writeExternal in interface Externalizable
    
    Throws:
    
    IOException
  - xor
```
public EWAHCompressedBitmap xor(EWAHCompressedBitmap a)
```
    Returns a new compressed bitmap containing the bitwise XOR values of the current bitmap with some other bitmap. The running time is proportional to the sum of the compressed sizes (as reported by sizeInBytes()). If you are not planning on adding to the resulting bitmap, you may call the trim() method to reduce memory usage. The current bitmap is not modified.
    
    Specified by:
    
    xor in interface LogicalElement<EWAHCompressedBitmap>
    
    Parameters:
    a - the other bitmap (it will not be modified)
    
    Returns:
    the EWAH compressed bitmap
  - xorToContainer
```
public void xorToContainer(EWAHCompressedBitmap a,
                  BitmapStorage container)
```
    Computes a new compressed bitmap containing the bitwise XOR values of the current bitmap with some other bitmap. The running time is proportional to the sum of the compressed sizes (as reported by sizeInBytes()). The current bitmap is not modified.
    
    Parameters:
    a - the other bitmap (it will not be modified)
    container - where we store the result
    Since:
    
    0.4.0
  - xorCardinality
```
public int xorCardinality(EWAHCompressedBitmap a)
```
    Returns the cardinality of the result of a bitwise XOR of the values of the current bitmap with some other bitmap. Avoids allocating an intermediate bitmap to hold the result of the OR. The current bitmap is not modified.
    
    Parameters:
    a - the other bitmap (it will not be modified)
    
    Returns:
    the cardinality
    Since:
    
    0.4.0
  - andWithContainer
```
public static void andWithContainer(BitmapStorage container,
                    EWAHCompressedBitmap... bitmaps)
```
    For internal use. Computes the bitwise and of the provided bitmaps and stores the result in the container.
    
    Parameters:
    container - where the result is stored
    bitmaps - bitmaps to AND
    Since:
    
    0.4.3
  - and
```
public static EWAHCompressedBitmap and(EWAHCompressedBitmap... bitmaps)
```
    Returns a new compressed bitmap containing the bitwise AND values of the provided bitmaps. It may or may not be faster than doing the aggregation two-by-two (A.and(B).and(C)). If only one bitmap is provided, it is returned as is. If you are not planning on adding to the resulting bitmap, you may call the trim() method to reduce memory usage.
    
    Parameters:
    bitmaps - bitmaps to AND together
    
    Returns:
    result of the AND
    Since:
    
    0.4.3
  - andCardinality
```
public static int andCardinality(EWAHCompressedBitmap... bitmaps)
```
    Returns the cardinality of the result of a bitwise AND of the values of the provided bitmaps. Avoids allocating an intermediate bitmap to hold the result of the AND.
    
    Parameters:
    bitmaps - bitmaps to AND
    
    Returns:
    the cardinality
    Since:
    
    0.4.3
  - bitmapOf
```
public static EWAHCompressedBitmap bitmapOf(int... setbits)
```
    Return a bitmap with the bit set to true at the given positions. The positions should be given in sorted order. (This is a convenience method.)
    
    Parameters:
    setbits - list of set bit positions
    
    Returns:
    the bitmap
    Since:
    
    0.4.5
  - orWithContainer
```
public static void orWithContainer(BitmapStorage container,
                   EWAHCompressedBitmap... bitmaps)
```
    Uses an adaptive technique to compute the logical OR. Mostly for internal use.
    
    Parameters:
    container - where the aggregate is written.
    bitmaps - to be aggregated
  - xorWithContainer
```
public static void xorWithContainer(BitmapStorage container,
                    EWAHCompressedBitmap... bitmaps)
```
    Uses an adaptive technique to compute the logical XOR. Mostly for internal use.
    
    Parameters:
    container - where the aggregate is written.
    bitmaps - to be aggregated
  - or
```
public static EWAHCompressedBitmap or(EWAHCompressedBitmap... bitmaps)
```
    Returns a new compressed bitmap containing the bitwise OR values of the provided bitmaps. This is typically faster than doing the aggregation two-by-two (A.or(B).or(C).or(D)). If only one bitmap is provided, it is returned as is. If you are not planning on adding to the resulting bitmap, you may call the trim() method to reduce memory usage.
    
    Parameters:
    bitmaps - bitmaps to OR together
    
    Returns:
    result of the OR
    Since:
    
    0.4.0
  - xor
```
public static EWAHCompressedBitmap xor(EWAHCompressedBitmap... bitmaps)
```
    Returns a new compressed bitmap containing the bitwise XOR values of the provided bitmaps. This is typically faster than doing the aggregation two-by-two (A.xor(B).xor(C).xor(D)). If only one bitmap is provided, it is returned as is. If you are not planning on adding to the resulting bitmap, you may call the trim() method to reduce memory usage.
    
    Parameters:
    bitmaps - bitmaps to XOR together
    
    Returns:
    result of the XOR
  - orCardinality
```
public static int orCardinality(EWAHCompressedBitmap... bitmaps)
```
    Returns the cardinality of the result of a bitwise OR of the values of the provided bitmaps. Avoids allocating an intermediate bitmap to hold the result of the OR.
    
    Parameters:
    bitmaps - bitmaps to OR
    
    Returns:
    the cardinality
    Since:
    
    0.4.0

Class EWAHCompressedBitmap

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

adjustContainerSizeWhenAggregating

wordinbits

Constructor Detail

EWAHCompressedBitmap

EWAHCompressedBitmap

Method Detail

add

add

addWord

addWord

addStreamOfLiteralWords

addStreamOfEmptyWords

addStreamOfNegatedLiteralWords

and

andToContainer

andCardinality

andNot

andNotToContainer

andNotCardinality

cardinality

clear

clone

deserialize

equals

getEWAHIterator

getIteratingRLW

getPositions

toList

hashCode

intersects

intIterator

clearIntIterator

iterator

not

or

orToContainer

orCardinality

readExternal

serialize

serializedSizeInBytes

get

set

setSizeInBits

setSizeInBits

sizeInBits

sizeInBytes

threshold

thresholdWithContainer

toArray

toDebugString

toString

swap

trim

writeExternal

xor

xorToContainer

xorCardinality

andWithContainer

and

andCardinality

bitmapOf

orWithContainer

xorWithContainer

or

xor

orCardinality