org.roaringbitmap

Class Util

java.lang.Object

org.roaringbitmap.Util

public final class Util
extends Object

Various useful methods for roaring bitmaps.

Field Summary

Fields

Modifier and Type	Field and Description
static boolean	USE_HYBRID_BINSEARCH

Method Summary

Modifier and Type	Method and Description
static int	advanceUntil(short[] array, int pos, int length, short min) Find the smallest integer larger than pos such that array[pos]>= min.
protected static int	branchyUnsignedBinarySearch(short[] array, int begin, int end, short k)
static int	compareUnsigned(short a, short b) Compares the two specified short values, treating them as unsigned values between 0 and 2^16 - 1 inclusive.
static void	fillArrayAND(short[] container, long[] bitmap1, long[] bitmap2) Compute the bitwise AND between two long arrays and write the set bits in the container.
static void	fillArrayANDNOT(short[] container, long[] bitmap1, long[] bitmap2) Compute the bitwise ANDNOT between two long arrays and write the set bits in the container.
static void	fillArrayXOR(short[] container, long[] bitmap1, long[] bitmap2) Compute the bitwise XOR between two long arrays and write the set bits in the container.
static void	flipBitmapRange(long[] bitmap, int start, int end) flip bits at start, start+1,..., end-1
protected static short	highbits(int x)
protected static int	hybridUnsignedBinarySearch(short[] array, int begin, int end, short k)
protected static short	lowbits(int x)
protected static short	maxLowBit()
protected static int	maxLowBitAsInteger()
static void	resetBitmapRange(long[] bitmap, int start, int end) clear bits at start, start+1,..., end-1
static int	select(long w, int j) Given a word w, return the position of the jth true bit.
static void	setBitmapRange(long[] bitmap, int start, int end) set bits at start, start+1,..., end-1
protected static int	toIntUnsigned(short x)
static int	unsignedBinarySearch(short[] array, int begin, int end, short k) Look for value k in array in the range [begin,end).
static int	unsignedDifference(short[] set1, int length1, short[] set2, int length2, short[] buffer) Compute the difference between two sorted lists and write the result to the provided output array
static int	unsignedDifference(ShortIterator set1, ShortIterator set2, short[] buffer) Compute the difference between two sorted lists and write the result to the provided output array
static int	unsignedExclusiveUnion2by2(short[] set1, int length1, short[] set2, int length2, short[] buffer) Compute the exclusive union of two sorted lists and write the result to the provided output array
static int	unsignedIntersect2by2(short[] set1, int length1, short[] set2, int length2, short[] buffer) Intersect two sorted lists and write the result to the provided output array
static boolean	unsignedIntersects(short[] set1, int length1, short[] set2, int length2) Checks if two arrays intersect
protected static int	unsignedLocalIntersect2by2(short[] set1, int length1, short[] set2, int length2, short[] buffer)
protected static int	unsignedOneSidedGallopingIntersect2by2(short[] smallSet, int smallLength, short[] largeSet, int largeLength, short[] buffer)
static int	unsignedUnion2by2(short[] set1, int length1, short[] set2, int length2, short[] buffer) Unite two sorted lists and write the result to the provided output array

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

USE_HYBRID_BINSEARCH

public static boolean USE_HYBRID_BINSEARCH

Method Detail

advanceUntil

public static int advanceUntil(short[] array,
                               int pos,
                               int length,
                               short min)

Find the smallest integer larger than pos such that array[pos]>= min. If none can be found, return length. Based on code by O. Kaser.

Parameters:

array - array to search within

pos - starting position of the search

length - length of the array to search

min - minimum value

Returns:

x greater than pos such that array[pos] is at least as large as min, pos is is equal to length if it is not possible.

fillArrayAND

public static void fillArrayAND(short[] container,
                                long[] bitmap1,
                                long[] bitmap2)

Compute the bitwise AND between two long arrays and write the set bits in the container.

Parameters:

container - where we write

bitmap1 - first bitmap

bitmap2 - second bitmap

fillArrayANDNOT

public static void fillArrayANDNOT(short[] container,
                                   long[] bitmap1,
                                   long[] bitmap2)

Compute the bitwise ANDNOT between two long arrays and write the set bits in the container.

Parameters:

container - where we write

bitmap1 - first bitmap

bitmap2 - second bitmap

fillArrayXOR

public static void fillArrayXOR(short[] container,
                                long[] bitmap1,
                                long[] bitmap2)

Compute the bitwise XOR between two long arrays and write the set bits in the container.

Parameters:

container - where we write

bitmap1 - first bitmap

bitmap2 - second bitmap

highbits

protected static short highbits(int x)

lowbits

protected static short lowbits(int x)

maxLowBit

protected static short maxLowBit()

maxLowBitAsInteger

protected static int maxLowBitAsInteger()

toIntUnsigned

protected static int toIntUnsigned(short x)

unsignedBinarySearch

public static int unsignedBinarySearch(short[] array,
                                       int begin,
                                       int end,
                                       short k)

Look for value k in array in the range [begin,end). If the value is found, return its index. If not, return -(i+1) where i is the index where the value would be inserted. The array is assumed to contain sorted values where shorts are interpreted as unsigned integers.

Parameters:

array - array where we search

begin - first index (inclusive)

end - last index (exclusive)

k - value we search for

Returns:

count

hybridUnsignedBinarySearch

protected static int hybridUnsignedBinarySearch(short[] array,
                                                int begin,
                                                int end,
                                                short k)

branchyUnsignedBinarySearch

protected static int branchyUnsignedBinarySearch(short[] array,
                                                 int begin,
                                                 int end,
                                                 short k)

unsignedDifference

public static int unsignedDifference(short[] set1,
                                     int length1,
                                     short[] set2,
                                     int length2,
                                     short[] buffer)

Compute the difference between two sorted lists and write the result to the provided output array

Parameters:

set1 - first array

length1 - length of first array

set2 - second array

length2 - length of second array

buffer - output array

Returns:

cardinality of the difference

unsignedDifference

public static int unsignedDifference(ShortIterator set1,
                                     ShortIterator set2,
                                     short[] buffer)

Compute the difference between two sorted lists and write the result to the provided output array

Parameters:

set1 - first array

set2 - second array

buffer - output array

Returns:

cardinality of the difference

unsignedExclusiveUnion2by2

public static int unsignedExclusiveUnion2by2(short[] set1,
                                             int length1,
                                             short[] set2,
                                             int length2,
                                             short[] buffer)

Compute the exclusive union of two sorted lists and write the result to the provided output array

Parameters:

set1 - first array

length1 - length of first array

set2 - second array

length2 - length of second array

buffer - output array

Returns:

cardinality of the exclusive union

unsignedIntersect2by2

public static int unsignedIntersect2by2(short[] set1,
                                        int length1,
                                        short[] set2,
                                        int length2,
                                        short[] buffer)

Intersect two sorted lists and write the result to the provided output array

Parameters:

set1 - first array

length1 - length of first array

set2 - second array

length2 - length of second array

buffer - output array

Returns:

cardinality of the intersection

unsignedLocalIntersect2by2

protected static int unsignedLocalIntersect2by2(short[] set1,
                                                int length1,
                                                short[] set2,
                                                int length2,
                                                short[] buffer)

unsignedOneSidedGallopingIntersect2by2

protected static int unsignedOneSidedGallopingIntersect2by2(short[] smallSet,
                                                            int smallLength,
                                                            short[] largeSet,
                                                            int largeLength,
                                                            short[] buffer)

unsignedUnion2by2

public static int unsignedUnion2by2(short[] set1,
                                    int length1,
                                    short[] set2,
                                    int length2,
                                    short[] buffer)

Unite two sorted lists and write the result to the provided output array

Parameters:

set1 - first array

length1 - length of first array

set2 - second array

length2 - length of second array

buffer - output array

Returns:

cardinality of the union

select

public static int select(long w,
                         int j)

Given a word w, return the position of the jth true bit.

Parameters:

w - word

j - index

Returns:

position of jth true bit in w

flipBitmapRange

public static void flipBitmapRange(long[] bitmap,
                                   int start,
                                   int end)

flip bits at start, start+1,..., end-1

Parameters:

bitmap - array of words to be modified

start - first index to be modified (inclusive)

end - last index to be modified (exclusive)

resetBitmapRange

public static void resetBitmapRange(long[] bitmap,
                                    int start,
                                    int end)

clear bits at start, start+1,..., end-1

Parameters:

bitmap - array of words to be modified

start - first index to be modified (inclusive)

end - last index to be modified (exclusive)

setBitmapRange

public static void setBitmapRange(long[] bitmap,
                                  int start,
                                  int end)

set bits at start, start+1,..., end-1

Parameters:

bitmap - array of words to be modified

start - first index to be modified (inclusive)

end - last index to be modified (exclusive)

compareUnsigned

public static int compareUnsigned(short a,
                                  short b)

Compares the two specified short values, treating them as unsigned values between 0 and 2^16 - 1 inclusive.

Parameters:

a - the first unsigned short to compare

b - the second unsigned short to compare

Returns:

a negative value if a is less than b; a positive value if a is greater than b; or zero if they are equal

unsignedIntersects

public static boolean unsignedIntersects(short[] set1,
                                         int length1,
                                         short[] set2,
                                         int length2)

Checks if two arrays intersect

Parameters:

set1 - first array

length1 - length of first array

set2 - second array

length2 - length of second array

Returns:

true if they intersect