#ifndef ROARING_INCLUDE_ROARING_VERSION
#define ROARING_INCLUDE_ROARING_VERSION
#define ROARING_VERSION = 0.2.66,
enum {
ROARING_VERSION_MAJOR = 0,
ROARING_VERSION_MINOR = 2,
ROARING_VERSION_REVISION = 66
};
#endif
#ifndef INCLUDE_PORTABILITY_H_
#define INCLUDE_PORTABILITY_H_
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS 1
#endif
#if !(defined(_POSIX_C_SOURCE)) || (_POSIX_C_SOURCE < 200809L)
#define _POSIX_C_SOURCE 200809L
#endif
#if !(defined(_XOPEN_SOURCE)) || (_XOPEN_SOURCE < 700)
#define _XOPEN_SOURCE 700
#endif
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#if !(defined(__APPLE__)) && !(defined(__FreeBSD__))
#include <malloc.h>
#endif
#if defined(_MSC_VER) && !defined(__clang__) && !defined(_WIN64) && !defined(ROARING_ACK_32BIT)
#pragma message( \
"You appear to be attempting a 32-bit build under Visual Studio. We recommend a 64-bit build instead.")
#endif
#if defined(__SIZEOF_LONG_LONG__) && __SIZEOF_LONG_LONG__ != 8
#error This code assumes 64-bit long longs (by use of the GCC intrinsics). Your system is not currently supported.
#endif
#if defined(_MSC_VER)
#define __restrict__ __restrict
#endif
#ifndef DISABLE_X64
#if (!defined(USEAVX)) && (!defined(DISABLEAVX)) && (defined(__AVX2__))
#define USEAVX
#endif
#if (defined(__POPCNT__)) && (defined(__SSE4_2__))
#define USESSE4
#endif
#if defined(USEAVX) || defined(__x86_64__) || defined(_M_X64)
#define IS_X64
#ifndef _MSC_VER
#include <x86intrin.h>
#endif
#endif
#if !defined(USENEON) && !defined(DISABLENEON) && defined(__ARM_NEON)
# define USENEON
#endif
#if defined(USENEON)
# include <arm_neon.h>
#endif
#ifndef _MSC_VER
#define ROARING_INLINE_ASM
#endif
#ifdef USEAVX
#define USESSE4
#define USE_BMI
#define USEAVX2FORDECODING
#define ROARING_VECTOR_OPERATIONS_ENABLED
#endif
#endif
#ifdef _MSC_VER
#include <intrin.h>
#ifndef __clang__
static inline int __builtin_ctzll(unsigned long long input_num) {
unsigned long index;
#ifdef _WIN64
_BitScanForward64(&index, input_num);
#else
if ((uint32_t)input_num != 0) {
_BitScanForward(&index, (uint32_t)input_num);
} else {
_BitScanForward(&index, (uint32_t)(input_num >> 32));
index += 32;
}
#endif
return index;
}
static inline int __builtin_clzll(unsigned long long input_num) {
unsigned long index;
#ifdef _WIN64
_BitScanReverse64(&index, input_num);
#else
if (input_num > 0xFFFFFFFF) {
_BitScanReverse(&index, (uint32_t)(input_num >> 32));
index += 32;
} else {
_BitScanReverse(&index, (uint32_t)(input_num));
}
#endif
return 63 - index;
}
#ifdef USESSE4
static inline int __builtin_popcountll(unsigned long long input_num) {
#ifdef _WIN64
return (int)__popcnt64(input_num);
#else
return (int)(__popcnt((uint32_t)input_num) +
__popcnt((uint32_t)(input_num >> 32)));
#endif
}
#else
static inline int __builtin_popcountll(unsigned long long input_num) {
const uint64_t m1 = 0x5555555555555555; const uint64_t m2 = 0x3333333333333333; const uint64_t m4 = 0x0f0f0f0f0f0f0f0f; const uint64_t h01 = 0x0101010101010101;
input_num -= (input_num >> 1) & m1;
input_num = (input_num & m2) + ((input_num >> 2) & m2);
input_num = (input_num + (input_num >> 4)) & m4;
return (input_num * h01) >> 56;
}
#endif
#define __builtin_unreachable() __assume(0)
#endif
#endif
#ifndef __cplusplus
extern int posix_memalign(void **__memptr, size_t __alignment, size_t __size);
#endif
static inline void *roaring_bitmap_aligned_malloc(size_t alignment, size_t size) {
void *p;
#ifdef _MSC_VER
p = _aligned_malloc(size, alignment);
#elif defined(__MINGW32__) || defined(__MINGW64__)
p = __mingw_aligned_malloc(size, alignment);
#else
if (posix_memalign(&p, alignment, size) != 0) return NULL;
#endif
return p;
}
static inline void roaring_bitmap_aligned_free(void *memblock) {
#ifdef _MSC_VER
_aligned_free(memblock);
#elif defined(__MINGW32__) || defined(__MINGW64__)
__mingw_aligned_free(memblock);
#else
free(memblock);
#endif
}
#if defined(_MSC_VER)
#define ALIGNED(x) __declspec(align(x))
#else
#if defined(__GNUC__)
#define ALIGNED(x) __attribute__((aligned(x)))
#endif
#endif
#ifdef __GNUC__
#define WARN_UNUSED __attribute__((warn_unused_result))
#else
#define WARN_UNUSED
#endif
#define IS_BIG_ENDIAN (*(uint16_t *)"\0\xff" < 0x100)
static inline int hamming(uint64_t x) {
#ifdef USESSE4
return (int) _mm_popcnt_u64(x);
#else
return __builtin_popcountll(x);
#endif
}
#ifndef UINT64_C
#define UINT64_C(c) (c##ULL)
#endif
#ifndef UINT32_C
#define UINT32_C(c) (c##UL)
#endif
#endif
#ifndef PERFPARAMETERS_H_
#define PERFPARAMETERS_H_
#include <stdbool.h>
enum { ARRAY_LAZY_LOWERBOUND = 1024 };
enum { RUN_DEFAULT_INIT_SIZE = 0 };
enum { ARRAY_DEFAULT_INIT_SIZE = 0 };
#ifndef LAZY_OR_BITSET_CONVERSION
#define LAZY_OR_BITSET_CONVERSION true
#endif
#ifndef LAZY_OR_BITSET_CONVERSION_TO_FULL
#define LAZY_OR_BITSET_CONVERSION_TO_FULL true
#endif
#ifndef OR_BITSET_CONVERSION_TO_FULL
#define OR_BITSET_CONVERSION_TO_FULL true
#endif
#endif
#ifndef ARRAY_UTIL_H
#define ARRAY_UTIL_H
#include <stddef.h>
#include <stdint.h>
inline int32_t binarySearch(const uint16_t *array, int32_t lenarray,
uint16_t ikey) {
int32_t low = 0;
int32_t high = lenarray - 1;
while (low <= high) {
int32_t middleIndex = (low + high) >> 1;
uint16_t middleValue = array[middleIndex];
if (middleValue < ikey) {
low = middleIndex + 1;
} else if (middleValue > ikey) {
high = middleIndex - 1;
} else {
return middleIndex;
}
}
return -(low + 1);
}
static inline int32_t advanceUntil(const uint16_t *array, int32_t pos,
int32_t length, uint16_t min) {
int32_t lower = pos + 1;
if ((lower >= length) || (array[lower] >= min)) {
return lower;
}
int32_t spansize = 1;
while ((lower + spansize < length) && (array[lower + spansize] < min)) {
spansize <<= 1;
}
int32_t upper = (lower + spansize < length) ? lower + spansize : length - 1;
if (array[upper] == min) {
return upper;
}
if (array[upper] < min) {
return length;
}
lower += (spansize >> 1);
int32_t mid = 0;
while (lower + 1 != upper) {
mid = (lower + upper) >> 1;
if (array[mid] == min) {
return mid;
} else if (array[mid] < min) {
lower = mid;
} else {
upper = mid;
}
}
return upper;
}
static inline int32_t count_less(const uint16_t *array, int32_t lenarray,
uint16_t ikey) {
if (lenarray == 0) return 0;
int32_t pos = binarySearch(array, lenarray, ikey);
return pos >= 0 ? pos : -(pos+1);
}
static inline int32_t count_greater(const uint16_t *array, int32_t lenarray,
uint16_t ikey) {
if (lenarray == 0) return 0;
int32_t pos = binarySearch(array, lenarray, ikey);
if (pos >= 0) {
return lenarray - (pos+1);
} else {
return lenarray - (-pos-1);
}
}
int32_t intersect_vector16(const uint16_t *__restrict__ A, size_t s_a,
const uint16_t *__restrict__ B, size_t s_b,
uint16_t *C);
int32_t intersect_vector16_cardinality(const uint16_t *__restrict__ A,
size_t s_a,
const uint16_t *__restrict__ B,
size_t s_b);
int32_t intersect_skewed_uint16(const uint16_t *smallarray, size_t size_s,
const uint16_t *largearray, size_t size_l,
uint16_t *buffer);
int32_t intersect_skewed_uint16_cardinality(const uint16_t *smallarray,
size_t size_s,
const uint16_t *largearray,
size_t size_l);
bool intersect_skewed_uint16_nonempty(const uint16_t *smallarray, size_t size_s,
const uint16_t *largearray, size_t size_l);
int32_t intersect_uint16(const uint16_t *A, const size_t lenA,
const uint16_t *B, const size_t lenB, uint16_t *out);
int32_t intersect_uint16_cardinality(const uint16_t *A, const size_t lenA,
const uint16_t *B, const size_t lenB);
bool intersect_uint16_nonempty(const uint16_t *A, const size_t lenA,
const uint16_t *B, const size_t lenB);
size_t union_uint16(const uint16_t *set_1, size_t size_1, const uint16_t *set_2,
size_t size_2, uint16_t *buffer);
int32_t xor_uint16(const uint16_t *array_1, int32_t card_1,
const uint16_t *array_2, int32_t card_2, uint16_t *out);
int difference_uint16(const uint16_t *a1, int length1, const uint16_t *a2,
int length2, uint16_t *a_out);
size_t intersection_uint32(const uint32_t *A, const size_t lenA,
const uint32_t *B, const size_t lenB, uint32_t *out);
size_t intersection_uint32_card(const uint32_t *A, const size_t lenA,
const uint32_t *B, const size_t lenB);
size_t union_uint32(const uint32_t *set_1, size_t size_1, const uint32_t *set_2,
size_t size_2, uint32_t *buffer);
uint32_t union_vector16(const uint16_t *__restrict__ set_1, uint32_t size_1,
const uint16_t *__restrict__ set_2, uint32_t size_2,
uint16_t *__restrict__ buffer);
uint32_t xor_vector16(const uint16_t *__restrict__ array1, uint32_t length1,
const uint16_t *__restrict__ array2, uint32_t length2,
uint16_t *__restrict__ output);
int32_t difference_vector16(const uint16_t *__restrict__ A, size_t s_a,
const uint16_t *__restrict__ B, size_t s_b,
uint16_t *C);
size_t union_uint32_card(const uint32_t *set_1, size_t size_1,
const uint32_t *set_2, size_t size_2);
size_t fast_union_uint16(const uint16_t *set_1, size_t size_1, const uint16_t *set_2,
size_t size_2, uint16_t *buffer);
bool memequals(const void *s1, const void *s2, size_t n);
#endif
#ifndef ROARING_TYPES_H
#define ROARING_TYPES_H
typedef bool (*roaring_iterator)(uint32_t value, void *param);
typedef bool (*roaring_iterator64)(uint64_t value, void *param);
typedef struct roaring_statistics_s {
uint32_t n_containers;
uint32_t n_array_containers;
uint32_t n_run_containers;
uint32_t n_bitset_containers;
uint32_t
n_values_array_containers;
uint32_t n_values_run_containers;
uint32_t
n_values_bitset_containers;
uint32_t n_bytes_array_containers;
uint32_t n_bytes_run_containers;
uint32_t n_bytes_bitset_containers;
uint32_t
max_value;
uint32_t
min_value;
uint64_t sum_value;
uint64_t cardinality;
} roaring_statistics_t;
#endif
#ifndef INCLUDE_UTILASM_H_
#define INCLUDE_UTILASM_H_
#if defined(USE_BMI) & defined(ROARING_INLINE_ASM)
#define ASMBITMANIPOPTIMIZATION
#define ASM_SHIFT_RIGHT(srcReg, bitsReg, destReg) \
__asm volatile("shrx %1, %2, %0" \
: "=r"(destReg) \
: \
"r"(bitsReg), \
"r"(srcReg) \
)
#define ASM_INPLACESHIFT_RIGHT(srcReg, bitsReg) \
__asm volatile("shrx %1, %0, %0" \
: "+r"(srcReg) \
: \
"r"(bitsReg) \
)
#define ASM_SHIFT_LEFT(srcReg, bitsReg, destReg) \
__asm volatile("shlx %1, %2, %0" \
: "=r"(destReg) \
: \
"r"(bitsReg), \
"r"(srcReg) \
)
#define ASM_SET_BIT_INC_WAS_CLEAR(testByte, testBit, count) \
__asm volatile( \
"bts %2, %0\n" \
"sbb $-1, %1\n" \
: "+r"(testByte), \
"+r"(count) \
: \
"r"(testBit) \
)
#define ASM_CLEAR_BIT_DEC_WAS_SET(testByte, testBit, count) \
__asm volatile( \
"btr %2, %0\n" \
"sbb $0, %1\n" \
: "+r"(testByte), \
"+r"(count) \
: \
"r"(testBit) \
)
#define ASM_BT64(testByte, testBit, count) \
__asm volatile( \
"bt %2,%1\n" \
"sbb %0,%0" \
: "=r"(count) \
: \
"r"(testByte), \
"r"(testBit) \
)
#endif #endif
#ifndef BITSET_UTIL_H
#define BITSET_UTIL_H
#include <stdint.h>
static inline void bitset_set_range(uint64_t *bitmap, uint32_t start,
uint32_t end) {
if (start == end) return;
uint32_t firstword = start / 64;
uint32_t endword = (end - 1) / 64;
if (firstword == endword) {
bitmap[firstword] |= ((~UINT64_C(0)) << (start % 64)) &
((~UINT64_C(0)) >> ((~end + 1) % 64));
return;
}
bitmap[firstword] |= (~UINT64_C(0)) << (start % 64);
for (uint32_t i = firstword + 1; i < endword; i++) bitmap[i] = ~UINT64_C(0);
bitmap[endword] |= (~UINT64_C(0)) >> ((~end + 1) % 64);
}
static inline int bitset_lenrange_cardinality(uint64_t *bitmap, uint32_t start,
uint32_t lenminusone) {
uint32_t firstword = start / 64;
uint32_t endword = (start + lenminusone) / 64;
if (firstword == endword) {
return hamming(bitmap[firstword] &
((~UINT64_C(0)) >> ((63 - lenminusone) % 64))
<< (start % 64));
}
int answer = hamming(bitmap[firstword] & ((~UINT64_C(0)) << (start % 64)));
for (uint32_t i = firstword + 1; i < endword; i++) {
answer += hamming(bitmap[i]);
}
answer +=
hamming(bitmap[endword] &
(~UINT64_C(0)) >> (((~start + 1) - lenminusone - 1) % 64));
return answer;
}
static inline bool bitset_lenrange_empty(uint64_t *bitmap, uint32_t start,
uint32_t lenminusone) {
uint32_t firstword = start / 64;
uint32_t endword = (start + lenminusone) / 64;
if (firstword == endword) {
return (bitmap[firstword] & ((~UINT64_C(0)) >> ((63 - lenminusone) % 64))
<< (start % 64)) == 0;
}
if(((bitmap[firstword] & ((~UINT64_C(0)) << (start%64)))) != 0) return false;
for (uint32_t i = firstword + 1; i < endword; i++) {
if(bitmap[i] != 0) return false;
}
if((bitmap[endword] & (~UINT64_C(0)) >> (((~start + 1) - lenminusone - 1) % 64)) != 0) return false;
return true;
}
static inline void bitset_set_lenrange(uint64_t *bitmap, uint32_t start,
uint32_t lenminusone) {
uint32_t firstword = start / 64;
uint32_t endword = (start + lenminusone) / 64;
if (firstword == endword) {
bitmap[firstword] |= ((~UINT64_C(0)) >> ((63 - lenminusone) % 64))
<< (start % 64);
return;
}
uint64_t temp = bitmap[endword];
bitmap[firstword] |= (~UINT64_C(0)) << (start % 64);
for (uint32_t i = firstword + 1; i < endword; i += 2)
bitmap[i] = bitmap[i + 1] = ~UINT64_C(0);
bitmap[endword] =
temp | (~UINT64_C(0)) >> (((~start + 1) - lenminusone - 1) % 64);
}
static inline void bitset_flip_range(uint64_t *bitmap, uint32_t start,
uint32_t end) {
if (start == end) return;
uint32_t firstword = start / 64;
uint32_t endword = (end - 1) / 64;
bitmap[firstword] ^= ~((~UINT64_C(0)) << (start % 64));
for (uint32_t i = firstword; i < endword; i++) bitmap[i] = ~bitmap[i];
bitmap[endword] ^= ((~UINT64_C(0)) >> ((~end + 1) % 64));
}
static inline void bitset_reset_range(uint64_t *bitmap, uint32_t start,
uint32_t end) {
if (start == end) return;
uint32_t firstword = start / 64;
uint32_t endword = (end - 1) / 64;
if (firstword == endword) {
bitmap[firstword] &= ~(((~UINT64_C(0)) << (start % 64)) &
((~UINT64_C(0)) >> ((~end + 1) % 64)));
return;
}
bitmap[firstword] &= ~((~UINT64_C(0)) << (start % 64));
for (uint32_t i = firstword + 1; i < endword; i++) bitmap[i] = UINT64_C(0);
bitmap[endword] &= ~((~UINT64_C(0)) >> ((~end + 1) % 64));
}
size_t bitset_extract_setbits_avx2(uint64_t *bitset, size_t length, void *vout,
size_t outcapacity, uint32_t base);
size_t bitset_extract_setbits(uint64_t *bitset, size_t length, void *vout,
uint32_t base);
size_t bitset_extract_setbits_sse_uint16(const uint64_t *bitset, size_t length,
uint16_t *out, size_t outcapacity,
uint16_t base);
size_t bitset_extract_setbits_uint16(const uint64_t *bitset, size_t length,
uint16_t *out, uint16_t base);
size_t bitset_extract_intersection_setbits_uint16(const uint64_t * __restrict__ bitset1,
const uint64_t * __restrict__ bitset2,
size_t length, uint16_t *out,
uint16_t base);
uint64_t bitset_set_list_withcard(void *bitset, uint64_t card,
const uint16_t *list, uint64_t length);
void bitset_set_list(void *bitset, const uint16_t *list, uint64_t length);
uint64_t bitset_clear_list(void *bitset, uint64_t card, const uint16_t *list,
uint64_t length);
uint64_t bitset_flip_list_withcard(void *bitset, uint64_t card,
const uint16_t *list, uint64_t length);
void bitset_flip_list(void *bitset, const uint16_t *list, uint64_t length);
#ifdef USEAVX
static inline __m256i popcount256(__m256i v) {
const __m256i lookuppos = _mm256_setr_epi8(
4 + 0, 4 + 1, 4 + 1, 4 + 2,
4 + 1, 4 + 2, 4 + 2, 4 + 3,
4 + 1, 4 + 2, 4 + 2, 4 + 3,
4 + 2, 4 + 3, 4 + 3, 4 + 4,
4 + 0, 4 + 1, 4 + 1, 4 + 2,
4 + 1, 4 + 2, 4 + 2, 4 + 3,
4 + 1, 4 + 2, 4 + 2, 4 + 3,
4 + 2, 4 + 3, 4 + 3, 4 + 4);
const __m256i lookupneg = _mm256_setr_epi8(
4 - 0, 4 - 1, 4 - 1, 4 - 2,
4 - 1, 4 - 2, 4 - 2, 4 - 3,
4 - 1, 4 - 2, 4 - 2, 4 - 3,
4 - 2, 4 - 3, 4 - 3, 4 - 4,
4 - 0, 4 - 1, 4 - 1, 4 - 2,
4 - 1, 4 - 2, 4 - 2, 4 - 3,
4 - 1, 4 - 2, 4 - 2, 4 - 3,
4 - 2, 4 - 3, 4 - 3, 4 - 4);
const __m256i low_mask = _mm256_set1_epi8(0x0f);
const __m256i lo = _mm256_and_si256(v, low_mask);
const __m256i hi = _mm256_and_si256(_mm256_srli_epi16(v, 4), low_mask);
const __m256i popcnt1 = _mm256_shuffle_epi8(lookuppos, lo);
const __m256i popcnt2 = _mm256_shuffle_epi8(lookupneg, hi);
return _mm256_sad_epu8(popcnt1, popcnt2);
}
static inline void CSA(__m256i *h, __m256i *l, __m256i a, __m256i b,
__m256i c) {
const __m256i u = _mm256_xor_si256(a, b);
*h = _mm256_or_si256(_mm256_and_si256(a, b), _mm256_and_si256(u, c));
*l = _mm256_xor_si256(u, c);
}
inline static uint64_t avx2_harley_seal_popcount256(const __m256i *data,
const uint64_t size) {
__m256i total = _mm256_setzero_si256();
__m256i ones = _mm256_setzero_si256();
__m256i twos = _mm256_setzero_si256();
__m256i fours = _mm256_setzero_si256();
__m256i eights = _mm256_setzero_si256();
__m256i sixteens = _mm256_setzero_si256();
__m256i twosA, twosB, foursA, foursB, eightsA, eightsB;
const uint64_t limit = size - size % 16;
uint64_t i = 0;
for (; i < limit; i += 16) {
CSA(&twosA, &ones, ones, _mm256_lddqu_si256(data + i),
_mm256_lddqu_si256(data + i + 1));
CSA(&twosB, &ones, ones, _mm256_lddqu_si256(data + i + 2),
_mm256_lddqu_si256(data + i + 3));
CSA(&foursA, &twos, twos, twosA, twosB);
CSA(&twosA, &ones, ones, _mm256_lddqu_si256(data + i + 4),
_mm256_lddqu_si256(data + i + 5));
CSA(&twosB, &ones, ones, _mm256_lddqu_si256(data + i + 6),
_mm256_lddqu_si256(data + i + 7));
CSA(&foursB, &twos, twos, twosA, twosB);
CSA(&eightsA, &fours, fours, foursA, foursB);
CSA(&twosA, &ones, ones, _mm256_lddqu_si256(data + i + 8),
_mm256_lddqu_si256(data + i + 9));
CSA(&twosB, &ones, ones, _mm256_lddqu_si256(data + i + 10),
_mm256_lddqu_si256(data + i + 11));
CSA(&foursA, &twos, twos, twosA, twosB);
CSA(&twosA, &ones, ones, _mm256_lddqu_si256(data + i + 12),
_mm256_lddqu_si256(data + i + 13));
CSA(&twosB, &ones, ones, _mm256_lddqu_si256(data + i + 14),
_mm256_lddqu_si256(data + i + 15));
CSA(&foursB, &twos, twos, twosA, twosB);
CSA(&eightsB, &fours, fours, foursA, foursB);
CSA(&sixteens, &eights, eights, eightsA, eightsB);
total = _mm256_add_epi64(total, popcount256(sixteens));
}
total = _mm256_slli_epi64(total, 4); total = _mm256_add_epi64(
total, _mm256_slli_epi64(popcount256(eights), 3)); total = _mm256_add_epi64(
total, _mm256_slli_epi64(popcount256(fours), 2)); total = _mm256_add_epi64(
total, _mm256_slli_epi64(popcount256(twos), 1)); total = _mm256_add_epi64(total, popcount256(ones));
for (; i < size; i++)
total =
_mm256_add_epi64(total, popcount256(_mm256_lddqu_si256(data + i)));
return (uint64_t)(_mm256_extract_epi64(total, 0)) +
(uint64_t)(_mm256_extract_epi64(total, 1)) +
(uint64_t)(_mm256_extract_epi64(total, 2)) +
(uint64_t)(_mm256_extract_epi64(total, 3));
}
#define AVXPOPCNTFNC(opname, avx_intrinsic) \
static inline uint64_t avx2_harley_seal_popcount256_##opname( \
const __m256i *data1, const __m256i *data2, const uint64_t size) { \
__m256i total = _mm256_setzero_si256(); \
__m256i ones = _mm256_setzero_si256(); \
__m256i twos = _mm256_setzero_si256(); \
__m256i fours = _mm256_setzero_si256(); \
__m256i eights = _mm256_setzero_si256(); \
__m256i sixteens = _mm256_setzero_si256(); \
__m256i twosA, twosB, foursA, foursB, eightsA, eightsB; \
__m256i A1, A2; \
const uint64_t limit = size - size % 16; \
uint64_t i = 0; \
for (; i < limit; i += 16) { \
A1 = avx_intrinsic(_mm256_lddqu_si256(data1 + i), \
_mm256_lddqu_si256(data2 + i)); \
A2 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 1), \
_mm256_lddqu_si256(data2 + i + 1)); \
CSA(&twosA, &ones, ones, A1, A2); \
A1 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 2), \
_mm256_lddqu_si256(data2 + i + 2)); \
A2 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 3), \
_mm256_lddqu_si256(data2 + i + 3)); \
CSA(&twosB, &ones, ones, A1, A2); \
CSA(&foursA, &twos, twos, twosA, twosB); \
A1 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 4), \
_mm256_lddqu_si256(data2 + i + 4)); \
A2 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 5), \
_mm256_lddqu_si256(data2 + i + 5)); \
CSA(&twosA, &ones, ones, A1, A2); \
A1 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 6), \
_mm256_lddqu_si256(data2 + i + 6)); \
A2 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 7), \
_mm256_lddqu_si256(data2 + i + 7)); \
CSA(&twosB, &ones, ones, A1, A2); \
CSA(&foursB, &twos, twos, twosA, twosB); \
CSA(&eightsA, &fours, fours, foursA, foursB); \
A1 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 8), \
_mm256_lddqu_si256(data2 + i + 8)); \
A2 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 9), \
_mm256_lddqu_si256(data2 + i + 9)); \
CSA(&twosA, &ones, ones, A1, A2); \
A1 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 10), \
_mm256_lddqu_si256(data2 + i + 10)); \
A2 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 11), \
_mm256_lddqu_si256(data2 + i + 11)); \
CSA(&twosB, &ones, ones, A1, A2); \
CSA(&foursA, &twos, twos, twosA, twosB); \
A1 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 12), \
_mm256_lddqu_si256(data2 + i + 12)); \
A2 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 13), \
_mm256_lddqu_si256(data2 + i + 13)); \
CSA(&twosA, &ones, ones, A1, A2); \
A1 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 14), \
_mm256_lddqu_si256(data2 + i + 14)); \
A2 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 15), \
_mm256_lddqu_si256(data2 + i + 15)); \
CSA(&twosB, &ones, ones, A1, A2); \
CSA(&foursB, &twos, twos, twosA, twosB); \
CSA(&eightsB, &fours, fours, foursA, foursB); \
CSA(&sixteens, &eights, eights, eightsA, eightsB); \
total = _mm256_add_epi64(total, popcount256(sixteens)); \
} \
total = _mm256_slli_epi64(total, 4); \
total = _mm256_add_epi64(total, \
_mm256_slli_epi64(popcount256(eights), 3)); \
total = \
_mm256_add_epi64(total, _mm256_slli_epi64(popcount256(fours), 2)); \
total = \
_mm256_add_epi64(total, _mm256_slli_epi64(popcount256(twos), 1)); \
total = _mm256_add_epi64(total, popcount256(ones)); \
for (; i < size; i++) { \
A1 = avx_intrinsic(_mm256_lddqu_si256(data1 + i), \
_mm256_lddqu_si256(data2 + i)); \
total = _mm256_add_epi64(total, popcount256(A1)); \
} \
return (uint64_t)(_mm256_extract_epi64(total, 0)) + \
(uint64_t)(_mm256_extract_epi64(total, 1)) + \
(uint64_t)(_mm256_extract_epi64(total, 2)) + \
(uint64_t)(_mm256_extract_epi64(total, 3)); \
} \
static inline uint64_t avx2_harley_seal_popcount256andstore_##opname( \
const __m256i *__restrict__ data1, const __m256i *__restrict__ data2, \
__m256i *__restrict__ out, const uint64_t size) { \
__m256i total = _mm256_setzero_si256(); \
__m256i ones = _mm256_setzero_si256(); \
__m256i twos = _mm256_setzero_si256(); \
__m256i fours = _mm256_setzero_si256(); \
__m256i eights = _mm256_setzero_si256(); \
__m256i sixteens = _mm256_setzero_si256(); \
__m256i twosA, twosB, foursA, foursB, eightsA, eightsB; \
__m256i A1, A2; \
const uint64_t limit = size - size % 16; \
uint64_t i = 0; \
for (; i < limit; i += 16) { \
A1 = avx_intrinsic(_mm256_lddqu_si256(data1 + i), \
_mm256_lddqu_si256(data2 + i)); \
_mm256_storeu_si256(out + i, A1); \
A2 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 1), \
_mm256_lddqu_si256(data2 + i + 1)); \
_mm256_storeu_si256(out + i + 1, A2); \
CSA(&twosA, &ones, ones, A1, A2); \
A1 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 2), \
_mm256_lddqu_si256(data2 + i + 2)); \
_mm256_storeu_si256(out + i + 2, A1); \
A2 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 3), \
_mm256_lddqu_si256(data2 + i + 3)); \
_mm256_storeu_si256(out + i + 3, A2); \
CSA(&twosB, &ones, ones, A1, A2); \
CSA(&foursA, &twos, twos, twosA, twosB); \
A1 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 4), \
_mm256_lddqu_si256(data2 + i + 4)); \
_mm256_storeu_si256(out + i + 4, A1); \
A2 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 5), \
_mm256_lddqu_si256(data2 + i + 5)); \
_mm256_storeu_si256(out + i + 5, A2); \
CSA(&twosA, &ones, ones, A1, A2); \
A1 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 6), \
_mm256_lddqu_si256(data2 + i + 6)); \
_mm256_storeu_si256(out + i + 6, A1); \
A2 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 7), \
_mm256_lddqu_si256(data2 + i + 7)); \
_mm256_storeu_si256(out + i + 7, A2); \
CSA(&twosB, &ones, ones, A1, A2); \
CSA(&foursB, &twos, twos, twosA, twosB); \
CSA(&eightsA, &fours, fours, foursA, foursB); \
A1 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 8), \
_mm256_lddqu_si256(data2 + i + 8)); \
_mm256_storeu_si256(out + i + 8, A1); \
A2 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 9), \
_mm256_lddqu_si256(data2 + i + 9)); \
_mm256_storeu_si256(out + i + 9, A2); \
CSA(&twosA, &ones, ones, A1, A2); \
A1 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 10), \
_mm256_lddqu_si256(data2 + i + 10)); \
_mm256_storeu_si256(out + i + 10, A1); \
A2 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 11), \
_mm256_lddqu_si256(data2 + i + 11)); \
_mm256_storeu_si256(out + i + 11, A2); \
CSA(&twosB, &ones, ones, A1, A2); \
CSA(&foursA, &twos, twos, twosA, twosB); \
A1 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 12), \
_mm256_lddqu_si256(data2 + i + 12)); \
_mm256_storeu_si256(out + i + 12, A1); \
A2 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 13), \
_mm256_lddqu_si256(data2 + i + 13)); \
_mm256_storeu_si256(out + i + 13, A2); \
CSA(&twosA, &ones, ones, A1, A2); \
A1 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 14), \
_mm256_lddqu_si256(data2 + i + 14)); \
_mm256_storeu_si256(out + i + 14, A1); \
A2 = avx_intrinsic(_mm256_lddqu_si256(data1 + i + 15), \
_mm256_lddqu_si256(data2 + i + 15)); \
_mm256_storeu_si256(out + i + 15, A2); \
CSA(&twosB, &ones, ones, A1, A2); \
CSA(&foursB, &twos, twos, twosA, twosB); \
CSA(&eightsB, &fours, fours, foursA, foursB); \
CSA(&sixteens, &eights, eights, eightsA, eightsB); \
total = _mm256_add_epi64(total, popcount256(sixteens)); \
} \
total = _mm256_slli_epi64(total, 4); \
total = _mm256_add_epi64(total, \
_mm256_slli_epi64(popcount256(eights), 3)); \
total = \
_mm256_add_epi64(total, _mm256_slli_epi64(popcount256(fours), 2)); \
total = \
_mm256_add_epi64(total, _mm256_slli_epi64(popcount256(twos), 1)); \
total = _mm256_add_epi64(total, popcount256(ones)); \
for (; i < size; i++) { \
A1 = avx_intrinsic(_mm256_lddqu_si256(data1 + i), \
_mm256_lddqu_si256(data2 + i)); \
_mm256_storeu_si256(out + i, A1); \
total = _mm256_add_epi64(total, popcount256(A1)); \
} \
return (uint64_t)(_mm256_extract_epi64(total, 0)) + \
(uint64_t)(_mm256_extract_epi64(total, 1)) + \
(uint64_t)(_mm256_extract_epi64(total, 2)) + \
(uint64_t)(_mm256_extract_epi64(total, 3)); \
}
AVXPOPCNTFNC(or, _mm256_or_si256)
AVXPOPCNTFNC(union, _mm256_or_si256)
AVXPOPCNTFNC(and, _mm256_and_si256)
AVXPOPCNTFNC(intersection, _mm256_and_si256)
AVXPOPCNTFNC (xor, _mm256_xor_si256)
AVXPOPCNTFNC(andnot, _mm256_andnot_si256)
#endif
#endif
#ifndef INCLUDE_CONTAINERS_ARRAY_H_
#define INCLUDE_CONTAINERS_ARRAY_H_
#include <string.h>
enum { DEFAULT_MAX_SIZE = 4096 };
struct array_container_s {
int32_t cardinality;
int32_t capacity;
uint16_t *array;
};
typedef struct array_container_s array_container_t;
array_container_t *array_container_create(void);
array_container_t *array_container_create_given_capacity(int32_t size);
array_container_t * array_container_create_range(uint32_t min, uint32_t max);
int array_container_shrink_to_fit(array_container_t *src);
void array_container_free(array_container_t *array);
array_container_t *array_container_clone(const array_container_t *src);
int32_t array_container_serialize(const array_container_t *container,
char *buf) WARN_UNUSED;
uint32_t array_container_serialization_len(const array_container_t *container);
void *array_container_deserialize(const char *buf, size_t buf_len);
static inline int array_container_cardinality(const array_container_t *array) {
return array->cardinality;
}
static inline bool array_container_nonzero_cardinality(
const array_container_t *array) {
return array->cardinality > 0;
}
void array_container_copy(const array_container_t *src, array_container_t *dst);
void array_container_add_from_range(array_container_t *arr, uint32_t min,
uint32_t max, uint16_t step);
static inline void array_container_clear(array_container_t *array) {
array->cardinality = 0;
}
static inline bool array_container_empty(const array_container_t *array) {
return array->cardinality == 0;
}
static inline bool array_container_full(const array_container_t *array) {
return array->cardinality == array->capacity;
}
void array_container_union(const array_container_t *src_1,
const array_container_t *src_2,
array_container_t *dst);
void array_container_xor(const array_container_t *array_1,
const array_container_t *array_2,
array_container_t *out);
void array_container_intersection(const array_container_t *src_1,
const array_container_t *src_2,
array_container_t *dst);
bool array_container_intersect(const array_container_t *src_1,
const array_container_t *src_2);
int array_container_intersection_cardinality(const array_container_t *src_1,
const array_container_t *src_2);
void array_container_intersection_inplace(array_container_t *src_1,
const array_container_t *src_2);
int array_container_to_uint32_array(void *vout, const array_container_t *cont,
uint32_t base);
int32_t array_container_number_of_runs(const array_container_t *a);
void array_container_printf(const array_container_t *v);
void array_container_printf_as_uint32_array(const array_container_t *v,
uint32_t base);
static inline int32_t array_container_serialized_size_in_bytes(int32_t card) {
return card * 2 + 2;
}
void array_container_grow(array_container_t *container, int32_t min,
bool preserve);
bool array_container_iterate(const array_container_t *cont, uint32_t base,
roaring_iterator iterator, void *ptr);
bool array_container_iterate64(const array_container_t *cont, uint32_t base,
roaring_iterator64 iterator, uint64_t high_bits,
void *ptr);
int32_t array_container_write(const array_container_t *container, char *buf);
int32_t array_container_read(int32_t cardinality, array_container_t *container,
const char *buf);
static inline int32_t array_container_size_in_bytes(
const array_container_t *container) {
return container->cardinality * sizeof(uint16_t);
}
static inline bool array_container_equals(
const array_container_t *container1,
const array_container_t *container2) {
if (container1->cardinality != container2->cardinality) {
return false;
}
return memequals(container1->array, container2->array, container1->cardinality*2);
}
bool array_container_is_subset(const array_container_t *container1,
const array_container_t *container2);
static inline bool array_container_select(const array_container_t *container,
uint32_t *start_rank, uint32_t rank,
uint32_t *element) {
int card = array_container_cardinality(container);
if (*start_rank + card <= rank) {
*start_rank += card;
return false;
} else {
*element = container->array[rank - *start_rank];
return true;
}
}
void array_container_andnot(const array_container_t *array_1,
const array_container_t *array_2,
array_container_t *out);
static inline void array_container_append(array_container_t *arr,
uint16_t pos) {
const int32_t capacity = arr->capacity;
if (array_container_full(arr)) {
array_container_grow(arr, capacity + 1, true);
}
arr->array[arr->cardinality++] = pos;
}
static inline int array_container_try_add(array_container_t *arr, uint16_t value,
int32_t max_cardinality) {
const int32_t cardinality = arr->cardinality;
if ((array_container_empty(arr) || arr->array[cardinality - 1] < value) &&
cardinality < max_cardinality) {
array_container_append(arr, value);
return 1;
}
const int32_t loc = binarySearch(arr->array, cardinality, value);
if (loc >= 0) {
return 0;
} else if (cardinality < max_cardinality) {
if (array_container_full(arr)) {
array_container_grow(arr, arr->capacity + 1, true);
}
const int32_t insert_idx = -loc - 1;
memmove(arr->array + insert_idx + 1, arr->array + insert_idx,
(cardinality - insert_idx) * sizeof(uint16_t));
arr->array[insert_idx] = value;
arr->cardinality++;
return 1;
} else {
return -1;
}
}
static inline bool array_container_add(array_container_t *arr, uint16_t value) {
return array_container_try_add(arr, value, INT32_MAX) == 1;
}
static inline bool array_container_remove(array_container_t *arr,
uint16_t pos) {
const int32_t idx = binarySearch(arr->array, arr->cardinality, pos);
const bool is_present = idx >= 0;
if (is_present) {
memmove(arr->array + idx, arr->array + idx + 1,
(arr->cardinality - idx - 1) * sizeof(uint16_t));
arr->cardinality--;
}
return is_present;
}
inline bool array_container_contains(const array_container_t *arr,
uint16_t pos) {
int32_t low = 0;
const uint16_t * carr = (const uint16_t *) arr->array;
int32_t high = arr->cardinality - 1;
while(high >= low + 16) {
int32_t middleIndex = (low + high)>>1;
uint16_t middleValue = carr[middleIndex];
if (middleValue < pos) {
low = middleIndex + 1;
} else if (middleValue > pos) {
high = middleIndex - 1;
} else {
return true;
}
}
for (int i=low; i <= high; i++) {
uint16_t v = carr[i];
if (v == pos) {
return true;
}
if ( v > pos ) return false;
}
return false;
}
static inline bool array_container_contains_range(const array_container_t *arr,
uint32_t range_start, uint32_t range_end) {
const uint16_t rs_included = range_start;
const uint16_t re_included = range_end - 1;
const uint16_t *carr = (const uint16_t *) arr->array;
const int32_t start = advanceUntil(carr, -1, arr->cardinality, rs_included);
const int32_t end = advanceUntil(carr, start - 1, arr->cardinality, re_included);
return (start < arr->cardinality) && (end < arr->cardinality)
&& (((uint16_t)(end - start)) == re_included - rs_included)
&& (carr[start] == rs_included) && (carr[end] == re_included);
}
inline uint16_t array_container_minimum(const array_container_t *arr) {
if (arr->cardinality == 0) return 0;
return arr->array[0];
}
inline uint16_t array_container_maximum(const array_container_t *arr) {
if (arr->cardinality == 0) return 0;
return arr->array[arr->cardinality - 1];
}
inline int array_container_rank(const array_container_t *arr, uint16_t x) {
const int32_t idx = binarySearch(arr->array, arr->cardinality, x);
const bool is_present = idx >= 0;
if (is_present) {
return idx + 1;
} else {
return -idx - 1;
}
}
inline int array_container_index_equalorlarger(const array_container_t *arr, uint16_t x) {
const int32_t idx = binarySearch(arr->array, arr->cardinality, x);
const bool is_present = idx >= 0;
if (is_present) {
return idx;
} else {
int32_t candidate = - idx - 1;
if(candidate < arr->cardinality) return candidate;
return -1;
}
}
static inline void array_container_add_range_nvals(array_container_t *array,
uint32_t min, uint32_t max,
int32_t nvals_less,
int32_t nvals_greater) {
int32_t union_cardinality = nvals_less + (max - min + 1) + nvals_greater;
if (union_cardinality > array->capacity) {
array_container_grow(array, union_cardinality, true);
}
memmove(&(array->array[union_cardinality - nvals_greater]),
&(array->array[array->cardinality - nvals_greater]),
nvals_greater * sizeof(uint16_t));
for (uint32_t i = 0; i <= max - min; i++) {
array->array[nvals_less + i] = min + i;
}
array->cardinality = union_cardinality;
}
static inline void array_container_add_range(array_container_t *array,
uint32_t min, uint32_t max) {
int32_t nvals_greater = count_greater(array->array, array->cardinality, max);
int32_t nvals_less = count_less(array->array, array->cardinality - nvals_greater, min);
array_container_add_range_nvals(array, min, max, nvals_less, nvals_greater);
}
static inline void array_container_remove_range(array_container_t *array,
uint32_t pos, uint32_t count) {
if (count != 0) {
memmove(&(array->array[pos]), &(array->array[pos+count]),
(array->cardinality - pos - count) * sizeof(uint16_t));
array->cardinality -= count;
}
}
#endif
#ifndef INCLUDE_CONTAINERS_BITSET_H_
#define INCLUDE_CONTAINERS_BITSET_H_
#include <stdbool.h>
#include <stdint.h>
#ifdef USEAVX
#define ALIGN_AVX __attribute__((aligned(sizeof(__m256i))))
#else
#define ALIGN_AVX
#endif
enum {
BITSET_CONTAINER_SIZE_IN_WORDS = (1 << 16) / 64,
BITSET_UNKNOWN_CARDINALITY = -1
};
struct bitset_container_s {
int32_t cardinality;
uint64_t *array;
};
typedef struct bitset_container_s bitset_container_t;
bitset_container_t *bitset_container_create(void);
void bitset_container_free(bitset_container_t *bitset);
void bitset_container_clear(bitset_container_t *bitset);
void bitset_container_set_all(bitset_container_t *bitset);
bitset_container_t *bitset_container_clone(const bitset_container_t *src);
int32_t bitset_container_serialize(const bitset_container_t *container,
char *buf) WARN_UNUSED;
uint32_t bitset_container_serialization_len(void);
void *bitset_container_deserialize(const char *buf, size_t buf_len);
void bitset_container_set_range(bitset_container_t *bitset, uint32_t begin,
uint32_t end);
#ifdef ASMBITMANIPOPTIMIZATION
static inline void bitset_container_set(bitset_container_t *bitset,
uint16_t pos) {
uint64_t shift = 6;
uint64_t offset;
uint64_t p = pos;
ASM_SHIFT_RIGHT(p, shift, offset);
uint64_t load = bitset->array[offset];
ASM_SET_BIT_INC_WAS_CLEAR(load, p, bitset->cardinality);
bitset->array[offset] = load;
}
static inline void bitset_container_unset(bitset_container_t *bitset,
uint16_t pos) {
uint64_t shift = 6;
uint64_t offset;
uint64_t p = pos;
ASM_SHIFT_RIGHT(p, shift, offset);
uint64_t load = bitset->array[offset];
ASM_CLEAR_BIT_DEC_WAS_SET(load, p, bitset->cardinality);
bitset->array[offset] = load;
}
static inline bool bitset_container_add(bitset_container_t *bitset,
uint16_t pos) {
uint64_t shift = 6;
uint64_t offset;
uint64_t p = pos;
ASM_SHIFT_RIGHT(p, shift, offset);
uint64_t load = bitset->array[offset];
const int32_t oldcard = bitset->cardinality;
ASM_SET_BIT_INC_WAS_CLEAR(load, p, bitset->cardinality);
bitset->array[offset] = load;
return bitset->cardinality - oldcard;
}
static inline bool bitset_container_remove(bitset_container_t *bitset,
uint16_t pos) {
uint64_t shift = 6;
uint64_t offset;
uint64_t p = pos;
ASM_SHIFT_RIGHT(p, shift, offset);
uint64_t load = bitset->array[offset];
const int32_t oldcard = bitset->cardinality;
ASM_CLEAR_BIT_DEC_WAS_SET(load, p, bitset->cardinality);
bitset->array[offset] = load;
return oldcard - bitset->cardinality;
}
inline bool bitset_container_get(const bitset_container_t *bitset,
uint16_t pos) {
uint64_t word = bitset->array[pos >> 6];
const uint64_t p = pos;
ASM_INPLACESHIFT_RIGHT(word, p);
return word & 1;
}
#else
static inline void bitset_container_set(bitset_container_t *bitset,
uint16_t pos) {
const uint64_t old_word = bitset->array[pos >> 6];
const int index = pos & 63;
const uint64_t new_word = old_word | (UINT64_C(1) << index);
bitset->cardinality += (uint32_t)((old_word ^ new_word) >> index);
bitset->array[pos >> 6] = new_word;
}
static inline void bitset_container_unset(bitset_container_t *bitset,
uint16_t pos) {
const uint64_t old_word = bitset->array[pos >> 6];
const int index = pos & 63;
const uint64_t new_word = old_word & (~(UINT64_C(1) << index));
bitset->cardinality -= (uint32_t)((old_word ^ new_word) >> index);
bitset->array[pos >> 6] = new_word;
}
static inline bool bitset_container_add(bitset_container_t *bitset,
uint16_t pos) {
const uint64_t old_word = bitset->array[pos >> 6];
const int index = pos & 63;
const uint64_t new_word = old_word | (UINT64_C(1) << index);
const uint64_t increment = (old_word ^ new_word) >> index;
bitset->cardinality += (uint32_t)increment;
bitset->array[pos >> 6] = new_word;
return increment > 0;
}
static inline bool bitset_container_remove(bitset_container_t *bitset,
uint16_t pos) {
const uint64_t old_word = bitset->array[pos >> 6];
const int index = pos & 63;
const uint64_t new_word = old_word & (~(UINT64_C(1) << index));
const uint64_t increment = (old_word ^ new_word) >> index;
bitset->cardinality -= (uint32_t)increment;
bitset->array[pos >> 6] = new_word;
return increment > 0;
}
inline bool bitset_container_get(const bitset_container_t *bitset,
uint16_t pos) {
const uint64_t word = bitset->array[pos >> 6];
return (word >> (pos & 63)) & 1;
}
#endif
static inline bool bitset_container_get_range(const bitset_container_t *bitset,
uint32_t pos_start, uint32_t pos_end) {
const uint32_t start = pos_start >> 6;
const uint32_t end = pos_end >> 6;
const uint64_t first = ~((1ULL << (pos_start & 0x3F)) - 1);
const uint64_t last = (1ULL << (pos_end & 0x3F)) - 1;
if (start == end) return ((bitset->array[end] & first & last) == (first & last));
if ((bitset->array[start] & first) != first) return false;
if ((end < BITSET_CONTAINER_SIZE_IN_WORDS) && ((bitset->array[end] & last) != last)){
return false;
}
for (uint16_t i = start + 1; (i < BITSET_CONTAINER_SIZE_IN_WORDS) && (i < end); ++i){
if (bitset->array[i] != UINT64_C(0xFFFFFFFFFFFFFFFF)) return false;
}
return true;
}
inline bool bitset_container_contains(const bitset_container_t *bitset,
uint16_t pos) {
return bitset_container_get(bitset, pos);
}
static inline bool bitset_container_contains_range(const bitset_container_t *bitset,
uint32_t pos_start, uint32_t pos_end) {
return bitset_container_get_range(bitset, pos_start, pos_end);
}
static inline int bitset_container_cardinality(
const bitset_container_t *bitset) {
return bitset->cardinality;
}
void bitset_container_copy(const bitset_container_t *source,
bitset_container_t *dest);
void bitset_container_add_from_range(bitset_container_t *bitset, uint32_t min,
uint32_t max, uint16_t step);
int bitset_container_compute_cardinality(const bitset_container_t *bitset);
static inline bool bitset_container_nonzero_cardinality(
bitset_container_t *bitset) {
if (bitset->cardinality == BITSET_UNKNOWN_CARDINALITY) {
bitset->cardinality = bitset_container_compute_cardinality(bitset);
}
return bitset->cardinality > 0;
}
static inline bool bitset_container_empty(
const bitset_container_t *bitset) {
if (bitset->cardinality == BITSET_UNKNOWN_CARDINALITY) {
for (int i = 0; i < BITSET_CONTAINER_SIZE_IN_WORDS; i ++) {
if((bitset->array[i]) != 0) return false;
}
return true;
}
return bitset->cardinality == 0;
}
static inline bool bitset_container_const_nonzero_cardinality(
const bitset_container_t *bitset) {
return !bitset_container_empty(bitset);
}
bool bitset_container_intersect(const bitset_container_t *src_1,
const bitset_container_t *src_2);
int bitset_container_or(const bitset_container_t *src_1,
const bitset_container_t *src_2,
bitset_container_t *dst);
int bitset_container_or_justcard(const bitset_container_t *src_1,
const bitset_container_t *src_2);
int bitset_container_union(const bitset_container_t *src_1,
const bitset_container_t *src_2,
bitset_container_t *dst);
int bitset_container_union_justcard(const bitset_container_t *src_1,
const bitset_container_t *src_2);
int bitset_container_or_nocard(const bitset_container_t *src_1,
const bitset_container_t *src_2,
bitset_container_t *dst);
int bitset_container_and(const bitset_container_t *src_1,
const bitset_container_t *src_2,
bitset_container_t *dst);
int bitset_container_and_justcard(const bitset_container_t *src_1,
const bitset_container_t *src_2);
int bitset_container_intersection(const bitset_container_t *src_1,
const bitset_container_t *src_2,
bitset_container_t *dst);
int bitset_container_intersection_justcard(const bitset_container_t *src_1,
const bitset_container_t *src_2);
int bitset_container_and_nocard(const bitset_container_t *src_1,
const bitset_container_t *src_2,
bitset_container_t *dst);
int bitset_container_xor(const bitset_container_t *src_1,
const bitset_container_t *src_2,
bitset_container_t *dst);
int bitset_container_xor_justcard(const bitset_container_t *src_1,
const bitset_container_t *src_2);
int bitset_container_xor_nocard(const bitset_container_t *src_1,
const bitset_container_t *src_2,
bitset_container_t *dst);
int bitset_container_andnot(const bitset_container_t *src_1,
const bitset_container_t *src_2,
bitset_container_t *dst);
int bitset_container_andnot_justcard(const bitset_container_t *src_1,
const bitset_container_t *src_2);
int bitset_container_andnot_nocard(const bitset_container_t *src_1,
const bitset_container_t *src_2,
bitset_container_t *dst);
int bitset_container_to_uint32_array(void *out, const bitset_container_t *cont,
uint32_t base);
void bitset_container_printf(const bitset_container_t *v);
void bitset_container_printf_as_uint32_array(const bitset_container_t *v,
uint32_t base);
static inline int32_t bitset_container_serialized_size_in_bytes(void) {
return BITSET_CONTAINER_SIZE_IN_WORDS * 8;
}
int bitset_container_number_of_runs(bitset_container_t *b);
bool bitset_container_iterate(const bitset_container_t *cont, uint32_t base,
roaring_iterator iterator, void *ptr);
bool bitset_container_iterate64(const bitset_container_t *cont, uint32_t base,
roaring_iterator64 iterator, uint64_t high_bits,
void *ptr);
int32_t bitset_container_write(const bitset_container_t *container, char *buf);
int32_t bitset_container_read(int32_t cardinality,
bitset_container_t *container, const char *buf);
static inline int32_t bitset_container_size_in_bytes(
const bitset_container_t *container) {
(void)container;
return BITSET_CONTAINER_SIZE_IN_WORDS * sizeof(uint64_t);
}
bool bitset_container_equals(const bitset_container_t *container1,
const bitset_container_t *container2);
bool bitset_container_is_subset(const bitset_container_t *container1,
const bitset_container_t *container2);
bool bitset_container_select(const bitset_container_t *container,
uint32_t *start_rank, uint32_t rank,
uint32_t *element);
uint16_t bitset_container_minimum(const bitset_container_t *container);
uint16_t bitset_container_maximum(const bitset_container_t *container);
int bitset_container_rank(const bitset_container_t *container, uint16_t x);
int bitset_container_index_equalorlarger(const bitset_container_t *container, uint16_t x);
#endif
#ifndef INCLUDE_CONTAINERS_RUN_H_
#define INCLUDE_CONTAINERS_RUN_H_
#include <assert.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
struct rle16_s {
uint16_t value;
uint16_t length;
};
typedef struct rle16_s rle16_t;
struct run_container_s {
int32_t n_runs;
int32_t capacity;
rle16_t *runs;
};
typedef struct run_container_s run_container_t;
run_container_t *run_container_create(void);
run_container_t *run_container_create_given_capacity(int32_t size);
int run_container_shrink_to_fit(run_container_t *src);
void run_container_free(run_container_t *run);
run_container_t *run_container_clone(const run_container_t *src);
int32_t run_container_serialize(const run_container_t *container,
char *buf) WARN_UNUSED;
uint32_t run_container_serialization_len(const run_container_t *container);
void *run_container_deserialize(const char *buf, size_t buf_len);
static inline void recoverRoomAtIndex(run_container_t *run, uint16_t index) {
memmove(run->runs + index, run->runs + (1 + index),
(run->n_runs - index - 1) * sizeof(rle16_t));
run->n_runs--;
}
inline int32_t interleavedBinarySearch(const rle16_t *array, int32_t lenarray,
uint16_t ikey) {
int32_t low = 0;
int32_t high = lenarray - 1;
while (low <= high) {
int32_t middleIndex = (low + high) >> 1;
uint16_t middleValue = array[middleIndex].value;
if (middleValue < ikey) {
low = middleIndex + 1;
} else if (middleValue > ikey) {
high = middleIndex - 1;
} else {
return middleIndex;
}
}
return -(low + 1);
}
static inline int32_t rle16_find_run(const rle16_t *array, int32_t lenarray,
uint16_t ikey) {
int32_t low = 0;
int32_t high = lenarray - 1;
while (low <= high) {
int32_t middleIndex = (low + high) >> 1;
uint16_t min = array[middleIndex].value;
uint16_t max = array[middleIndex].value + array[middleIndex].length;
if (ikey > max) {
low = middleIndex + 1;
} else if (ikey < min) {
high = middleIndex - 1;
} else {
return middleIndex;
}
}
return -(low + 1);
}
static inline int32_t rle16_count_less(const rle16_t* array, int32_t lenarray,
uint16_t key) {
if (lenarray == 0) return 0;
int32_t low = 0;
int32_t high = lenarray - 1;
while (low <= high) {
int32_t middleIndex = (low + high) >> 1;
uint16_t min_value = array[middleIndex].value;
uint16_t max_value = array[middleIndex].value + array[middleIndex].length;
if (max_value + UINT32_C(1) < key) { low = middleIndex + 1;
} else if (key < min_value) {
high = middleIndex - 1;
} else {
return middleIndex;
}
}
return low;
}
static inline int32_t rle16_count_greater(const rle16_t* array, int32_t lenarray,
uint16_t key) {
if (lenarray == 0) return 0;
int32_t low = 0;
int32_t high = lenarray - 1;
while (low <= high) {
int32_t middleIndex = (low + high) >> 1;
uint16_t min_value = array[middleIndex].value;
uint16_t max_value = array[middleIndex].value + array[middleIndex].length;
if (max_value < key) {
low = middleIndex + 1;
} else if (key + UINT32_C(1) < min_value) { high = middleIndex - 1;
} else {
return lenarray - (middleIndex + 1);
}
}
return lenarray - low;
}
void run_container_grow(run_container_t *run, int32_t min, bool copy);
static inline void makeRoomAtIndex(run_container_t *run, uint16_t index) {
if (run->n_runs + 1 > run->capacity)
run_container_grow(run, run->n_runs + 1, true);
memmove(run->runs + 1 + index, run->runs + index,
(run->n_runs - index) * sizeof(rle16_t));
run->n_runs++;
}
bool run_container_add(run_container_t *run, uint16_t pos);
static inline bool run_container_remove(run_container_t *run, uint16_t pos) {
int32_t index = interleavedBinarySearch(run->runs, run->n_runs, pos);
if (index >= 0) {
int32_t le = run->runs[index].length;
if (le == 0) {
recoverRoomAtIndex(run, (uint16_t)index);
} else {
run->runs[index].value++;
run->runs[index].length--;
}
return true;
}
index = -index - 2; if (index >= 0) { int32_t offset = pos - run->runs[index].value;
int32_t le = run->runs[index].length;
if (offset < le) {
run->runs[index].length = (uint16_t)(offset - 1);
uint16_t newvalue = pos + 1;
int32_t newlength = le - offset - 1;
makeRoomAtIndex(run, (uint16_t)(index + 1));
run->runs[index + 1].value = newvalue;
run->runs[index + 1].length = (uint16_t)newlength;
return true;
} else if (offset == le) {
run->runs[index].length--;
return true;
}
}
return false;
}
inline bool run_container_contains(const run_container_t *run, uint16_t pos) {
int32_t index = interleavedBinarySearch(run->runs, run->n_runs, pos);
if (index >= 0) return true;
index = -index - 2; if (index != -1) { int32_t offset = pos - run->runs[index].value;
int32_t le = run->runs[index].length;
if (offset <= le) return true;
}
return false;
}
static inline bool run_container_contains_range(const run_container_t *run,
uint32_t pos_start, uint32_t pos_end) {
uint32_t count = 0;
int32_t index = interleavedBinarySearch(run->runs, run->n_runs, pos_start);
if (index < 0) {
index = -index - 2;
if ((index == -1) || ((pos_start - run->runs[index].value) > run->runs[index].length)){
return false;
}
}
for (int32_t i = index; i < run->n_runs; ++i) {
const uint32_t stop = run->runs[i].value + run->runs[i].length;
if (run->runs[i].value >= pos_end) break;
if (stop >= pos_end) {
count += (((pos_end - run->runs[i].value) > 0) ? (pos_end - run->runs[i].value) : 0);
break;
}
const uint32_t min = (stop - pos_start) > 0 ? (stop - pos_start) : 0;
count += (min < run->runs[i].length) ? min : run->runs[i].length;
}
return count >= (pos_end - pos_start - 1);
}
#ifdef USEAVX
static inline int run_container_cardinality(const run_container_t *run) {
const int32_t n_runs = run->n_runs;
const rle16_t *runs = run->runs;
int sum = n_runs;
int32_t k = 0;
const int32_t step = sizeof(__m256i) / sizeof(rle16_t);
if (n_runs > step) {
__m256i total = _mm256_setzero_si256();
for (; k + step <= n_runs; k += step) {
__m256i ymm1 = _mm256_lddqu_si256((const __m256i *)(runs + k));
__m256i justlengths = _mm256_srli_epi32(ymm1, 16);
total = _mm256_add_epi32(total, justlengths);
}
uint32_t buffer[sizeof(__m256i) / sizeof(rle16_t)];
_mm256_storeu_si256((__m256i *)buffer, total);
sum += (buffer[0] + buffer[1]) + (buffer[2] + buffer[3]) +
(buffer[4] + buffer[5]) + (buffer[6] + buffer[7]);
}
for (; k < n_runs; ++k) {
sum += runs[k].length;
}
return sum;
}
#else
static inline int run_container_cardinality(const run_container_t *run) {
const int32_t n_runs = run->n_runs;
const rle16_t *runs = run->runs;
int sum = n_runs;
for (int k = 0; k < n_runs; ++k) {
sum += runs[k].length;
}
return sum;
}
#endif
static inline bool run_container_nonzero_cardinality(
const run_container_t *run) {
return run->n_runs > 0; }
static inline bool run_container_empty(
const run_container_t *run) {
return run->n_runs == 0; }
void run_container_copy(const run_container_t *src, run_container_t *dst);
static inline void run_container_clear(run_container_t *run) {
run->n_runs = 0;
}
static inline void run_container_append(run_container_t *run, rle16_t vl,
rle16_t *previousrl) {
const uint32_t previousend = previousrl->value + previousrl->length;
if (vl.value > previousend + 1) { run->runs[run->n_runs] = vl;
run->n_runs++;
*previousrl = vl;
} else {
uint32_t newend = vl.value + vl.length + UINT32_C(1);
if (newend > previousend) { previousrl->length = (uint16_t)(newend - 1 - previousrl->value);
run->runs[run->n_runs - 1] = *previousrl;
}
}
}
static inline rle16_t run_container_append_first(run_container_t *run,
rle16_t vl) {
run->runs[run->n_runs] = vl;
run->n_runs++;
return vl;
}
static inline void run_container_append_value(run_container_t *run,
uint16_t val,
rle16_t *previousrl) {
const uint32_t previousend = previousrl->value + previousrl->length;
if (val > previousend + 1) { previousrl->value = val;
previousrl->length = 0;
run->runs[run->n_runs] = *previousrl;
run->n_runs++;
} else if (val == previousend + 1) { previousrl->length++;
run->runs[run->n_runs - 1] = *previousrl;
}
}
static inline rle16_t run_container_append_value_first(run_container_t *run,
uint16_t val) {
rle16_t newrle;
newrle.value = val;
newrle.length = 0;
run->runs[run->n_runs] = newrle;
run->n_runs++;
return newrle;
}
static inline bool run_container_is_full(const run_container_t *run) {
rle16_t vl = run->runs[0];
return (run->n_runs == 1) && (vl.value == 0) && (vl.length == 0xFFFF);
}
void run_container_union(const run_container_t *src_1,
const run_container_t *src_2, run_container_t *dst);
void run_container_union_inplace(run_container_t *src_1,
const run_container_t *src_2);
void run_container_intersection(const run_container_t *src_1,
const run_container_t *src_2,
run_container_t *dst);
int run_container_intersection_cardinality(const run_container_t *src_1,
const run_container_t *src_2);
bool run_container_intersect(const run_container_t *src_1,
const run_container_t *src_2);
void run_container_xor(const run_container_t *src_1,
const run_container_t *src_2, run_container_t *dst);
int run_container_to_uint32_array(void *vout, const run_container_t *cont,
uint32_t base);
void run_container_printf(const run_container_t *v);
void run_container_printf_as_uint32_array(const run_container_t *v,
uint32_t base);
static inline int32_t run_container_serialized_size_in_bytes(int32_t num_runs) {
return sizeof(uint16_t) +
sizeof(rle16_t) * num_runs; }
bool run_container_iterate(const run_container_t *cont, uint32_t base,
roaring_iterator iterator, void *ptr);
bool run_container_iterate64(const run_container_t *cont, uint32_t base,
roaring_iterator64 iterator, uint64_t high_bits,
void *ptr);
int32_t run_container_write(const run_container_t *container, char *buf);
int32_t run_container_read(int32_t cardinality, run_container_t *container,
const char *buf);
static inline int32_t run_container_size_in_bytes(
const run_container_t *container) {
return run_container_serialized_size_in_bytes(container->n_runs);
}
static inline bool run_container_equals(const run_container_t *container1,
const run_container_t *container2) {
if (container1->n_runs != container2->n_runs) {
return false;
}
return memequals(container1->runs, container2->runs,
container1->n_runs * sizeof(rle16_t));
}
bool run_container_is_subset(const run_container_t *container1,
const run_container_t *container2);
void run_container_smart_append_exclusive(run_container_t *src,
const uint16_t start,
const uint16_t length);
static inline run_container_t *run_container_create_range(uint32_t start,
uint32_t stop) {
run_container_t *rc = run_container_create_given_capacity(1);
if (rc) {
rle16_t r;
r.value = (uint16_t)start;
r.length = (uint16_t)(stop - start - 1);
run_container_append_first(rc, r);
}
return rc;
}
bool run_container_select(const run_container_t *container,
uint32_t *start_rank, uint32_t rank,
uint32_t *element);
void run_container_andnot(const run_container_t *src_1,
const run_container_t *src_2, run_container_t *dst);
inline uint16_t run_container_minimum(const run_container_t *run) {
if (run->n_runs == 0) return 0;
return run->runs[0].value;
}
inline uint16_t run_container_maximum(const run_container_t *run) {
if (run->n_runs == 0) return 0;
return run->runs[run->n_runs - 1].value + run->runs[run->n_runs - 1].length;
}
int run_container_rank(const run_container_t *arr, uint16_t x);
inline int run_container_index_equalorlarger(const run_container_t *arr, uint16_t x) {
int32_t index = interleavedBinarySearch(arr->runs, arr->n_runs, x);
if (index >= 0) return index;
index = -index - 2; if (index != -1) { int32_t offset = x - arr->runs[index].value;
int32_t le = arr->runs[index].length;
if (offset <= le) return index;
}
index += 1;
if(index < arr->n_runs) {
return index;
}
return -1;
}
static inline void run_container_add_range_nruns(run_container_t* run,
uint32_t min, uint32_t max,
int32_t nruns_less,
int32_t nruns_greater) {
int32_t nruns_common = run->n_runs - nruns_less - nruns_greater;
if (nruns_common == 0) {
makeRoomAtIndex(run, nruns_less);
run->runs[nruns_less].value = min;
run->runs[nruns_less].length = max - min;
} else {
uint32_t common_min = run->runs[nruns_less].value;
uint32_t common_max = run->runs[nruns_less + nruns_common - 1].value +
run->runs[nruns_less + nruns_common - 1].length;
uint32_t result_min = (common_min < min) ? common_min : min;
uint32_t result_max = (common_max > max) ? common_max : max;
run->runs[nruns_less].value = result_min;
run->runs[nruns_less].length = result_max - result_min;
memmove(&(run->runs[nruns_less + 1]),
&(run->runs[run->n_runs - nruns_greater]),
nruns_greater*sizeof(rle16_t));
run->n_runs = nruns_less + 1 + nruns_greater;
}
}
static inline void run_container_add_range(run_container_t* run,
uint32_t min, uint32_t max) {
int32_t nruns_greater = rle16_count_greater(run->runs, run->n_runs, max);
int32_t nruns_less = rle16_count_less(run->runs, run->n_runs - nruns_greater, min);
run_container_add_range_nruns(run, min, max, nruns_less, nruns_greater);
}
static inline void run_container_shift_tail(run_container_t* run,
int32_t count, int32_t distance) {
if (distance > 0) {
if (run->capacity < count+distance) {
run_container_grow(run, count+distance, true);
}
}
int32_t srcpos = run->n_runs - count;
int32_t dstpos = srcpos + distance;
memmove(&(run->runs[dstpos]), &(run->runs[srcpos]), sizeof(rle16_t) * count);
run->n_runs += distance;
}
static inline void run_container_remove_range(run_container_t *run, uint32_t min, uint32_t max) {
int32_t first = rle16_find_run(run->runs, run->n_runs, min);
int32_t last = rle16_find_run(run->runs, run->n_runs, max);
if (first >= 0 && min > run->runs[first].value &&
max < ((uint32_t)run->runs[first].value + (uint32_t)run->runs[first].length)) {
makeRoomAtIndex(run, first+1);
run->runs[first+1].value = max + 1;
run->runs[first+1].length = (run->runs[first].value + run->runs[first].length) - (max + 1);
run->runs[first].length = (min - 1) - run->runs[first].value;
return;
}
if (first >= 0) {
if (min > run->runs[first].value) {
run->runs[first].length = (min - 1) - run->runs[first].value;
first++;
}
} else {
first = -first-1;
}
if (last >= 0) {
uint16_t run_max = run->runs[last].value + run->runs[last].length;
if (run_max > max) {
run->runs[last].value = max + 1;
run->runs[last].length = run_max - (max + 1);
last--;
}
} else {
last = (-last-1) - 1;
}
if (first <= last) {
run_container_shift_tail(run, run->n_runs - (last+1), -(last-first+1));
}
}
#endif
#ifndef INCLUDE_CONTAINERS_CONVERT_H_
#define INCLUDE_CONTAINERS_CONVERT_H_
bitset_container_t *bitset_container_from_array(const array_container_t *arr);
bitset_container_t *bitset_container_from_run(const run_container_t *arr);
array_container_t *array_container_from_run(const run_container_t *arr);
array_container_t *array_container_from_bitset(const bitset_container_t *bits);
run_container_t *run_container_from_array(const array_container_t *c);
void *convert_to_bitset_or_array_container(run_container_t *r, int32_t card,
uint8_t *resulttype);
void *convert_run_optimize(void *c, uint8_t typecode_original,
uint8_t *typecode_after);
void *convert_run_to_efficient_container(run_container_t *c,
uint8_t *typecode_after);
void *convert_run_to_efficient_container_and_free(run_container_t *c,
uint8_t *typecode_after);
bitset_container_t *bitset_container_from_run_range(const run_container_t *run,
uint32_t min, uint32_t max);
#endif
#ifndef CONTAINERS_MIXED_EQUAL_H_
#define CONTAINERS_MIXED_EQUAL_H_
bool array_container_equal_bitset(const array_container_t* container1,
const bitset_container_t* container2);
bool run_container_equals_array(const run_container_t* container1,
const array_container_t* container2);
bool run_container_equals_bitset(const run_container_t* container1,
const bitset_container_t* container2);
#endif
#ifndef CONTAINERS_MIXED_SUBSET_H_
#define CONTAINERS_MIXED_SUBSET_H_
bool array_container_is_subset_bitset(const array_container_t* container1,
const bitset_container_t* container2);
bool run_container_is_subset_array(const run_container_t* container1,
const array_container_t* container2);
bool array_container_is_subset_run(const array_container_t* container1,
const run_container_t* container2);
bool run_container_is_subset_bitset(const run_container_t* container1,
const bitset_container_t* container2);
bool bitset_container_is_subset_run(const bitset_container_t* container1,
const run_container_t* container2);
#endif
#ifndef INCLUDE_CONTAINERS_MIXED_ANDNOT_H_
#define INCLUDE_CONTAINERS_MIXED_ANDNOT_H_
void array_bitset_container_andnot(const array_container_t *src_1,
const bitset_container_t *src_2,
array_container_t *dst);
void array_bitset_container_iandnot(array_container_t *src_1,
const bitset_container_t *src_2);
bool bitset_array_container_andnot(const bitset_container_t *src_1,
const array_container_t *src_2, void **dst);
bool bitset_array_container_iandnot(bitset_container_t *src_1,
const array_container_t *src_2, void **dst);
bool run_bitset_container_andnot(const run_container_t *src_1,
const bitset_container_t *src_2, void **dst);
bool run_bitset_container_iandnot(run_container_t *src_1,
const bitset_container_t *src_2, void **dst);
bool bitset_run_container_andnot(const bitset_container_t *src_1,
const run_container_t *src_2, void **dst);
bool bitset_run_container_iandnot(bitset_container_t *src_1,
const run_container_t *src_2, void **dst);
int run_array_container_andnot(const run_container_t *src_1,
const array_container_t *src_2, void **dst);
int run_array_container_iandnot(run_container_t *src_1,
const array_container_t *src_2, void **dst);
void array_run_container_andnot(const array_container_t *src_1,
const run_container_t *src_2,
array_container_t *dst);
void array_run_container_iandnot(array_container_t *src_1,
const run_container_t *src_2);
int run_run_container_andnot(const run_container_t *src_1,
const run_container_t *src_2, void **dst);
int run_run_container_iandnot(run_container_t *src_1,
const run_container_t *src_2, void **dst);
void array_array_container_andnot(const array_container_t *src_1,
const array_container_t *src_2,
array_container_t *dst);
void array_array_container_iandnot(array_container_t *src_1,
const array_container_t *src_2);
bool bitset_bitset_container_andnot(const bitset_container_t *src_1,
const bitset_container_t *src_2,
void **dst);
bool bitset_bitset_container_iandnot(bitset_container_t *src_1,
const bitset_container_t *src_2,
void **dst);
#endif
#ifndef INCLUDE_CONTAINERS_MIXED_INTERSECTION_H_
#define INCLUDE_CONTAINERS_MIXED_INTERSECTION_H_
void array_bitset_container_intersection(const array_container_t *src_1,
const bitset_container_t *src_2,
array_container_t *dst);
int array_bitset_container_intersection_cardinality(
const array_container_t *src_1, const bitset_container_t *src_2);
bool array_bitset_container_intersect(const array_container_t *src_1,
const bitset_container_t *src_2);
bool bitset_bitset_container_intersection(const bitset_container_t *src_1,
const bitset_container_t *src_2,
void **dst);
void array_run_container_intersection(const array_container_t *src_1,
const run_container_t *src_2,
array_container_t *dst);
bool run_bitset_container_intersection(const run_container_t *src_1,
const bitset_container_t *src_2,
void **dst);
int array_run_container_intersection_cardinality(const array_container_t *src_1,
const run_container_t *src_2);
int run_bitset_container_intersection_cardinality(const run_container_t *src_1,
const bitset_container_t *src_2);
bool array_run_container_intersect(const array_container_t *src_1,
const run_container_t *src_2);
bool run_bitset_container_intersect(const run_container_t *src_1,
const bitset_container_t *src_2);
bool bitset_bitset_container_intersection_inplace(
bitset_container_t *src_1, const bitset_container_t *src_2, void **dst);
#endif
#ifndef INCLUDE_CONTAINERS_MIXED_NEGATION_H_
#define INCLUDE_CONTAINERS_MIXED_NEGATION_H_
void array_container_negation(const array_container_t *src,
bitset_container_t *dst);
bool bitset_container_negation(const bitset_container_t *src, void **dst);
bool bitset_container_negation_inplace(bitset_container_t *src, void **dst);
int run_container_negation(const run_container_t *src, void **dst);
int run_container_negation_inplace(run_container_t *src, void **dst);
bool array_container_negation_range(const array_container_t *src,
const int range_start, const int range_end,
void **dst);
bool array_container_negation_range_inplace(array_container_t *src,
const int range_start,
const int range_end, void **dst);
bool bitset_container_negation_range(const bitset_container_t *src,
const int range_start, const int range_end,
void **dst);
bool bitset_container_negation_range_inplace(bitset_container_t *src,
const int range_start,
const int range_end, void **dst);
int run_container_negation_range(const run_container_t *src,
const int range_start, const int range_end,
void **dst);
int run_container_negation_range_inplace(run_container_t *src,
const int range_start,
const int range_end, void **dst);
#endif
#ifndef INCLUDE_CONTAINERS_MIXED_UNION_H_
#define INCLUDE_CONTAINERS_MIXED_UNION_H_
void array_bitset_container_union(const array_container_t *src_1,
const bitset_container_t *src_2,
bitset_container_t *dst);
void array_bitset_container_lazy_union(const array_container_t *src_1,
const bitset_container_t *src_2,
bitset_container_t *dst);
bool array_array_container_union(const array_container_t *src_1,
const array_container_t *src_2, void **dst);
bool array_array_container_inplace_union(array_container_t *src_1,
const array_container_t *src_2, void **dst);
bool array_array_container_lazy_union(const array_container_t *src_1,
const array_container_t *src_2,
void **dst);
bool array_array_container_lazy_inplace_union(array_container_t *src_1,
const array_container_t *src_2,
void **dst);
void array_run_container_union(const array_container_t *src_1,
const run_container_t *src_2,
run_container_t *dst);
void array_run_container_inplace_union(const array_container_t *src_1,
run_container_t *src_2);
void run_bitset_container_union(const run_container_t *src_1,
const bitset_container_t *src_2,
bitset_container_t *dst);
void run_bitset_container_lazy_union(const run_container_t *src_1,
const bitset_container_t *src_2,
bitset_container_t *dst);
#endif
#ifndef INCLUDE_CONTAINERS_MIXED_XOR_H_
#define INCLUDE_CONTAINERS_MIXED_XOR_H_
bool array_bitset_container_xor(const array_container_t *src_1,
const bitset_container_t *src_2, void **dst);
void array_bitset_container_lazy_xor(const array_container_t *src_1,
const bitset_container_t *src_2,
bitset_container_t *dst);
bool bitset_bitset_container_xor(const bitset_container_t *src_1,
const bitset_container_t *src_2, void **dst);
bool run_bitset_container_xor(const run_container_t *src_1,
const bitset_container_t *src_2, void **dst);
void run_bitset_container_lazy_xor(const run_container_t *src_1,
const bitset_container_t *src_2,
bitset_container_t *dst);
int array_run_container_xor(const array_container_t *src_1,
const run_container_t *src_2, void **dst);
bool array_array_container_xor(const array_container_t *src_1,
const array_container_t *src_2, void **dst);
bool array_array_container_lazy_xor(const array_container_t *src_1,
const array_container_t *src_2, void **dst);
void array_run_container_lazy_xor(const array_container_t *src_1,
const run_container_t *src_2,
run_container_t *dst);
int run_run_container_xor(const run_container_t *src_1,
const run_container_t *src_2, void **dst);
bool bitset_array_container_ixor(bitset_container_t *src_1,
const array_container_t *src_2, void **dst);
bool bitset_bitset_container_ixor(bitset_container_t *src_1,
const bitset_container_t *src_2, void **dst);
bool array_bitset_container_ixor(array_container_t *src_1,
const bitset_container_t *src_2, void **dst);
bool run_bitset_container_ixor(run_container_t *src_1,
const bitset_container_t *src_2, void **dst);
bool bitset_run_container_ixor(bitset_container_t *src_1,
const run_container_t *src_2, void **dst);
int array_run_container_ixor(array_container_t *src_1,
const run_container_t *src_2, void **dst);
int run_array_container_ixor(run_container_t *src_1,
const array_container_t *src_2, void **dst);
bool array_array_container_ixor(array_container_t *src_1,
const array_container_t *src_2, void **dst);
int run_run_container_ixor(run_container_t *src_1, const run_container_t *src_2,
void **dst);
#endif
#ifndef CONTAINERS_CONTAINERS_H
#define CONTAINERS_CONTAINERS_H
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#define BITSET_CONTAINER_TYPE_CODE 1
#define ARRAY_CONTAINER_TYPE_CODE 2
#define RUN_CONTAINER_TYPE_CODE 3
#define SHARED_CONTAINER_TYPE_CODE 4
#define CONTAINER_PAIR(c1, c2) (4 * (c1) + (c2))
struct shared_container_s {
void *container;
uint8_t typecode;
uint32_t counter; };
typedef struct shared_container_s shared_container_t;
void *get_copy_of_container(void *container, uint8_t *typecode,
bool copy_on_write);
void shared_container_free(shared_container_t *container);
void *shared_container_extract_copy(shared_container_t *container,
uint8_t *typecode);
inline const void *container_unwrap_shared(
const void *candidate_shared_container, uint8_t *type) {
if (*type == SHARED_CONTAINER_TYPE_CODE) {
*type =
((const shared_container_t *)candidate_shared_container)->typecode;
assert(*type != SHARED_CONTAINER_TYPE_CODE);
return ((const shared_container_t *)candidate_shared_container)->container;
} else {
return candidate_shared_container;
}
}
inline void *container_mutable_unwrap_shared(
void *candidate_shared_container, uint8_t *type) {
if (*type == SHARED_CONTAINER_TYPE_CODE) {
*type =
((shared_container_t *)candidate_shared_container)->typecode;
assert(*type != SHARED_CONTAINER_TYPE_CODE);
return ((shared_container_t *)candidate_shared_container)->container;
} else {
return candidate_shared_container;
}
}
static inline uint8_t get_container_type(const void *container, uint8_t type) {
if (type == SHARED_CONTAINER_TYPE_CODE) {
return ((const shared_container_t *)container)->typecode;
} else {
return type;
}
}
void *container_clone(const void *container, uint8_t typecode);
static inline void *get_writable_copy_if_shared(
void *candidate_shared_container, uint8_t *type) {
if (*type == SHARED_CONTAINER_TYPE_CODE) {
return shared_container_extract_copy(
(shared_container_t *)candidate_shared_container, type);
} else {
return candidate_shared_container;
}
}
static const char *container_names[] = {"bitset", "array", "run", "shared"};
static const char *shared_container_names[] = {
"bitset (shared)", "array (shared)", "run (shared)"};
static inline void *container_to_bitset(void *container, uint8_t typecode) {
bitset_container_t *result = NULL;
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
return container; case ARRAY_CONTAINER_TYPE_CODE:
result =
bitset_container_from_array((array_container_t *)container);
return result;
case RUN_CONTAINER_TYPE_CODE:
result = bitset_container_from_run((run_container_t *)container);
return result;
case SHARED_CONTAINER_TYPE_CODE:
assert(false);
}
assert(false);
__builtin_unreachable();
return 0; }
static inline const char *get_container_name(uint8_t typecode) {
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
return container_names[0];
case ARRAY_CONTAINER_TYPE_CODE:
return container_names[1];
case RUN_CONTAINER_TYPE_CODE:
return container_names[2];
case SHARED_CONTAINER_TYPE_CODE:
return container_names[3];
default:
assert(false);
__builtin_unreachable();
return "unknown";
}
}
static inline const char *get_full_container_name(const void *container,
uint8_t typecode) {
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
return container_names[0];
case ARRAY_CONTAINER_TYPE_CODE:
return container_names[1];
case RUN_CONTAINER_TYPE_CODE:
return container_names[2];
case SHARED_CONTAINER_TYPE_CODE:
switch (((const shared_container_t *)container)->typecode) {
case BITSET_CONTAINER_TYPE_CODE:
return shared_container_names[0];
case ARRAY_CONTAINER_TYPE_CODE:
return shared_container_names[1];
case RUN_CONTAINER_TYPE_CODE:
return shared_container_names[2];
default:
assert(false);
__builtin_unreachable();
return "unknown";
}
break;
default:
assert(false);
__builtin_unreachable();
return "unknown";
}
__builtin_unreachable();
return NULL;
}
static inline int container_get_cardinality(const void *container,
uint8_t typecode) {
container = container_unwrap_shared(container, &typecode);
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
return bitset_container_cardinality(
(const bitset_container_t *)container);
case ARRAY_CONTAINER_TYPE_CODE:
return array_container_cardinality(
(const array_container_t *)container);
case RUN_CONTAINER_TYPE_CODE:
return run_container_cardinality(
(const run_container_t *)container);
}
assert(false);
__builtin_unreachable();
return 0; }
static inline bool container_is_full(const void *container, uint8_t typecode) {
container = container_unwrap_shared(container, &typecode);
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
return bitset_container_cardinality(
(const bitset_container_t *)container) == (1 << 16);
case ARRAY_CONTAINER_TYPE_CODE:
return array_container_cardinality(
(const array_container_t *)container) == (1 << 16);
case RUN_CONTAINER_TYPE_CODE:
return run_container_is_full((const run_container_t *)container);
}
assert(false);
__builtin_unreachable();
return 0; }
static inline int container_shrink_to_fit(void *container, uint8_t typecode) {
container = container_mutable_unwrap_shared(container, &typecode);
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
return 0; case ARRAY_CONTAINER_TYPE_CODE:
return array_container_shrink_to_fit(
(array_container_t *)container);
case RUN_CONTAINER_TYPE_CODE:
return run_container_shrink_to_fit((run_container_t *)container);
}
assert(false);
__builtin_unreachable();
return 0; }
static inline void *container_range_of_ones(uint32_t range_start,
uint32_t range_end,
uint8_t *result_type) {
assert(range_end >= range_start);
uint64_t cardinality = range_end - range_start + 1;
if(cardinality <= 2) {
*result_type = ARRAY_CONTAINER_TYPE_CODE;
return array_container_create_range(range_start, range_end);
} else {
*result_type = RUN_CONTAINER_TYPE_CODE;
return run_container_create_range(range_start, range_end);
}
}
static inline void *container_from_range(uint8_t *type, uint32_t min,
uint32_t max, uint16_t step) {
if (step == 0) return NULL; if (step == 1) {
return container_range_of_ones(min,max,type);
}
int size = (max - min + step - 1) / step;
if (size <= DEFAULT_MAX_SIZE) { *type = ARRAY_CONTAINER_TYPE_CODE;
array_container_t *array = array_container_create_given_capacity(size);
array_container_add_from_range(array, min, max, step);
assert(array->cardinality == size);
return array;
} else { *type = BITSET_CONTAINER_TYPE_CODE;
bitset_container_t *bitset = bitset_container_create();
bitset_container_add_from_range(bitset, min, max, step);
assert(bitset->cardinality == size);
return bitset;
}
}
static inline void *container_repair_after_lazy(void *container,
uint8_t *typecode) {
container = get_writable_copy_if_shared(
container, typecode); void *result = NULL;
switch (*typecode) {
case BITSET_CONTAINER_TYPE_CODE:
((bitset_container_t *)container)->cardinality =
bitset_container_compute_cardinality(
(bitset_container_t *)container);
if (((bitset_container_t *)container)->cardinality <=
DEFAULT_MAX_SIZE) {
result = array_container_from_bitset(
(const bitset_container_t *)container);
bitset_container_free((bitset_container_t *)container);
*typecode = ARRAY_CONTAINER_TYPE_CODE;
return result;
}
return container;
case ARRAY_CONTAINER_TYPE_CODE:
return container; case RUN_CONTAINER_TYPE_CODE:
return convert_run_to_efficient_container_and_free(
(run_container_t *)container, typecode);
case SHARED_CONTAINER_TYPE_CODE:
assert(false);
}
assert(false);
__builtin_unreachable();
return 0; }
static inline int32_t container_write(const void *container, uint8_t typecode,
char *buf) {
container = container_unwrap_shared(container, &typecode);
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
return bitset_container_write((const bitset_container_t *)container, buf);
case ARRAY_CONTAINER_TYPE_CODE:
return array_container_write((const array_container_t *)container, buf);
case RUN_CONTAINER_TYPE_CODE:
return run_container_write((const run_container_t *)container, buf);
}
assert(false);
__builtin_unreachable();
return 0; }
static inline int32_t container_size_in_bytes(const void *container,
uint8_t typecode) {
container = container_unwrap_shared(container, &typecode);
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
return bitset_container_size_in_bytes(
(const bitset_container_t *)container);
case ARRAY_CONTAINER_TYPE_CODE:
return array_container_size_in_bytes(
(const array_container_t *)container);
case RUN_CONTAINER_TYPE_CODE:
return run_container_size_in_bytes((const run_container_t *)container);
}
assert(false);
__builtin_unreachable();
return 0; }
void container_printf(const void *container, uint8_t typecode);
void container_printf_as_uint32_array(const void *container, uint8_t typecode,
uint32_t base);
static inline bool container_nonzero_cardinality(const void *container,
uint8_t typecode) {
container = container_unwrap_shared(container, &typecode);
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
return bitset_container_const_nonzero_cardinality(
(const bitset_container_t *)container);
case ARRAY_CONTAINER_TYPE_CODE:
return array_container_nonzero_cardinality(
(const array_container_t *)container);
case RUN_CONTAINER_TYPE_CODE:
return run_container_nonzero_cardinality(
(const run_container_t *)container);
}
assert(false);
__builtin_unreachable();
return 0; }
void container_free(void *container, uint8_t typecode);
static inline int container_to_uint32_array(uint32_t *output,
const void *container,
uint8_t typecode, uint32_t base) {
container = container_unwrap_shared(container, &typecode);
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
return bitset_container_to_uint32_array(
output, (const bitset_container_t *)container, base);
case ARRAY_CONTAINER_TYPE_CODE:
return array_container_to_uint32_array(
output, (const array_container_t *)container, base);
case RUN_CONTAINER_TYPE_CODE:
return run_container_to_uint32_array(
output, (const run_container_t *)container, base);
}
assert(false);
__builtin_unreachable();
return 0; }
static inline void *container_add(void *container, uint16_t val,
uint8_t typecode, uint8_t *new_typecode) {
container = get_writable_copy_if_shared(container, &typecode);
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
bitset_container_set((bitset_container_t *)container, val);
*new_typecode = BITSET_CONTAINER_TYPE_CODE;
return container;
case ARRAY_CONTAINER_TYPE_CODE: {
array_container_t *ac = (array_container_t *)container;
if (array_container_try_add(ac, val, DEFAULT_MAX_SIZE) != -1) {
*new_typecode = ARRAY_CONTAINER_TYPE_CODE;
return ac;
} else {
bitset_container_t* bitset = bitset_container_from_array(ac);
bitset_container_add(bitset, val);
*new_typecode = BITSET_CONTAINER_TYPE_CODE;
return bitset;
}
} break;
case RUN_CONTAINER_TYPE_CODE:
run_container_add((run_container_t *)container, val);
*new_typecode = RUN_CONTAINER_TYPE_CODE;
return container;
default:
assert(false);
__builtin_unreachable();
return NULL;
}
}
static inline void *container_remove(void *container, uint16_t val,
uint8_t typecode, uint8_t *new_typecode) {
container = get_writable_copy_if_shared(container, &typecode);
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
if (bitset_container_remove((bitset_container_t *)container, val)) {
if (bitset_container_cardinality(
(bitset_container_t *)container) <= DEFAULT_MAX_SIZE) {
*new_typecode = ARRAY_CONTAINER_TYPE_CODE;
return array_container_from_bitset(
(bitset_container_t *)container);
}
}
*new_typecode = typecode;
return container;
case ARRAY_CONTAINER_TYPE_CODE:
*new_typecode = typecode;
array_container_remove((array_container_t *)container, val);
return container;
case RUN_CONTAINER_TYPE_CODE:
run_container_remove((run_container_t *)container, val);
*new_typecode = RUN_CONTAINER_TYPE_CODE;
return container;
default:
assert(false);
__builtin_unreachable();
return NULL;
}
}
inline bool container_contains(const void *container, uint16_t val,
uint8_t typecode) {
container = container_unwrap_shared(container, &typecode);
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
return bitset_container_get((const bitset_container_t *)container,
val);
case ARRAY_CONTAINER_TYPE_CODE:
return array_container_contains(
(const array_container_t *)container, val);
case RUN_CONTAINER_TYPE_CODE:
return run_container_contains((const run_container_t *)container,
val);
default:
assert(false);
__builtin_unreachable();
return false;
}
}
static inline bool container_contains_range(const void *container, uint32_t range_start,
uint32_t range_end, uint8_t typecode) {
container = container_unwrap_shared(container, &typecode);
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
return bitset_container_get_range((const bitset_container_t *)container,
range_start, range_end);
case ARRAY_CONTAINER_TYPE_CODE:
return array_container_contains_range((const array_container_t *)container,
range_start, range_end);
case RUN_CONTAINER_TYPE_CODE:
return run_container_contains_range((const run_container_t *)container,
range_start, range_end);
default:
assert(false);
__builtin_unreachable();
return false;
}
}
int32_t container_serialize(const void *container, uint8_t typecode,
char *buf) WARN_UNUSED;
uint32_t container_serialization_len(const void *container, uint8_t typecode);
void *container_deserialize(uint8_t typecode, const char *buf, size_t buf_len);
static inline bool container_equals(const void *c1, uint8_t type1,
const void *c2, uint8_t type2) {
c1 = container_unwrap_shared(c1, &type1);
c2 = container_unwrap_shared(c2, &type2);
switch (CONTAINER_PAIR(type1, type2)) {
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
return bitset_container_equals((const bitset_container_t *)c1,
(const bitset_container_t *)c2);
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
RUN_CONTAINER_TYPE_CODE):
return run_container_equals_bitset((const run_container_t *)c2,
(const bitset_container_t *)c1);
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
return run_container_equals_bitset((const run_container_t *)c1,
(const bitset_container_t *)c2);
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
return array_container_equal_bitset((const array_container_t *)c2,
(const bitset_container_t *)c1);
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
return array_container_equal_bitset((const array_container_t *)c1,
(const bitset_container_t *)c2);
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
return run_container_equals_array((const run_container_t *)c2,
(const array_container_t *)c1);
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE):
return run_container_equals_array((const run_container_t *)c1,
(const array_container_t *)c2);
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
return array_container_equals((const array_container_t *)c1,
(const array_container_t *)c2);
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
return run_container_equals((const run_container_t *)c1,
(const run_container_t *)c2);
default:
assert(false);
__builtin_unreachable();
return false;
}
}
static inline bool container_is_subset(const void *c1, uint8_t type1,
const void *c2, uint8_t type2) {
c1 = container_unwrap_shared(c1, &type1);
c2 = container_unwrap_shared(c2, &type2);
switch (CONTAINER_PAIR(type1, type2)) {
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
return bitset_container_is_subset((const bitset_container_t *)c1,
(const bitset_container_t *)c2);
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
RUN_CONTAINER_TYPE_CODE):
return bitset_container_is_subset_run((const bitset_container_t *)c1,
(const run_container_t *)c2);
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
return run_container_is_subset_bitset((const run_container_t *)c1,
(const bitset_container_t *)c2);
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
return false; case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
return array_container_is_subset_bitset((const array_container_t *)c1,
(const bitset_container_t *)c2);
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
return array_container_is_subset_run((const array_container_t *)c1,
(const run_container_t *)c2);
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE):
return run_container_is_subset_array((const run_container_t *)c1,
(const array_container_t *)c2);
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
return array_container_is_subset((const array_container_t *)c1,
(const array_container_t *)c2);
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
return run_container_is_subset((const run_container_t *)c1,
(const run_container_t *)c2);
default:
assert(false);
__builtin_unreachable();
return false;
}
}
static inline void *container_and(const void *c1, uint8_t type1, const void *c2,
uint8_t type2, uint8_t *result_type) {
c1 = container_unwrap_shared(c1, &type1);
c2 = container_unwrap_shared(c2, &type2);
void *result = NULL;
switch (CONTAINER_PAIR(type1, type2)) {
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
*result_type = bitset_bitset_container_intersection(
(const bitset_container_t *)c1,
(const bitset_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
result = array_container_create();
array_container_intersection((const array_container_t *)c1,
(const array_container_t *)c2,
(array_container_t *)result);
*result_type = ARRAY_CONTAINER_TYPE_CODE; return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
result = run_container_create();
run_container_intersection((const run_container_t *)c1,
(const run_container_t *)c2,
(run_container_t *)result);
return convert_run_to_efficient_container_and_free(
(run_container_t *)result, result_type);
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
result = array_container_create();
array_bitset_container_intersection((const array_container_t *)c2,
(const bitset_container_t *)c1,
(array_container_t *)result);
*result_type = ARRAY_CONTAINER_TYPE_CODE; return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
result = array_container_create();
*result_type = ARRAY_CONTAINER_TYPE_CODE; array_bitset_container_intersection((const array_container_t *)c1,
(const bitset_container_t *)c2,
(array_container_t *)result);
return result;
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
RUN_CONTAINER_TYPE_CODE):
*result_type = run_bitset_container_intersection(
(const run_container_t *)c2,
(const bitset_container_t *)c1, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
*result_type = run_bitset_container_intersection(
(const run_container_t *)c1,
(const bitset_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
result = array_container_create();
*result_type = ARRAY_CONTAINER_TYPE_CODE; array_run_container_intersection((const array_container_t *)c1,
(const run_container_t *)c2,
(array_container_t *)result);
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE):
result = array_container_create();
*result_type = ARRAY_CONTAINER_TYPE_CODE; array_run_container_intersection((const array_container_t *)c2,
(const run_container_t *)c1,
(array_container_t *)result);
return result;
default:
assert(false);
__builtin_unreachable();
return NULL;
}
}
static inline int container_and_cardinality(const void *c1, uint8_t type1,
const void *c2, uint8_t type2) {
c1 = container_unwrap_shared(c1, &type1);
c2 = container_unwrap_shared(c2, &type2);
switch (CONTAINER_PAIR(type1, type2)) {
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
return bitset_container_and_justcard(
(const bitset_container_t *)c1, (const bitset_container_t *)c2);
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
return array_container_intersection_cardinality(
(const array_container_t *)c1, (const array_container_t *)c2);
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
return run_container_intersection_cardinality(
(const run_container_t *)c1, (const run_container_t *)c2);
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
return array_bitset_container_intersection_cardinality(
(const array_container_t *)c2, (const bitset_container_t *)c1);
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
return array_bitset_container_intersection_cardinality(
(const array_container_t *)c1, (const bitset_container_t *)c2);
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
RUN_CONTAINER_TYPE_CODE):
return run_bitset_container_intersection_cardinality(
(const run_container_t *)c2, (const bitset_container_t *)c1);
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
return run_bitset_container_intersection_cardinality(
(const run_container_t *)c1, (const bitset_container_t *)c2);
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
return array_run_container_intersection_cardinality(
(const array_container_t *)c1, (const run_container_t *)c2);
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE):
return array_run_container_intersection_cardinality(
(const array_container_t *)c2, (const run_container_t *)c1);
default:
assert(false);
__builtin_unreachable();
return 0;
}
}
static inline bool container_intersect(const void *c1, uint8_t type1, const void *c2,
uint8_t type2) {
c1 = container_unwrap_shared(c1, &type1);
c2 = container_unwrap_shared(c2, &type2);
switch (CONTAINER_PAIR(type1, type2)) {
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
return bitset_container_intersect(
(const bitset_container_t *)c1,
(const bitset_container_t *)c2);
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
return array_container_intersect((const array_container_t *)c1,
(const array_container_t *)c2);
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
return run_container_intersect((const run_container_t *)c1,
(const run_container_t *)c2);
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
return array_bitset_container_intersect((const array_container_t *)c2,
(const bitset_container_t *)c1);
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
return array_bitset_container_intersect((const array_container_t *)c1,
(const bitset_container_t *)c2);
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
RUN_CONTAINER_TYPE_CODE):
return run_bitset_container_intersect(
(const run_container_t *)c2,
(const bitset_container_t *)c1);
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
return run_bitset_container_intersect(
(const run_container_t *)c1,
(const bitset_container_t *)c2);
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
return array_run_container_intersect((const array_container_t *)c1,
(const run_container_t *)c2);
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE):
return array_run_container_intersect((const array_container_t *)c2,
(const run_container_t *)c1);
default:
assert(false);
__builtin_unreachable();
return 0;
}
}
static inline void *container_iand(void *c1, uint8_t type1, const void *c2,
uint8_t type2, uint8_t *result_type) {
c1 = get_writable_copy_if_shared(c1, &type1);
c2 = container_unwrap_shared(c2, &type2);
void *result = NULL;
switch (CONTAINER_PAIR(type1, type2)) {
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
*result_type =
bitset_bitset_container_intersection_inplace(
(bitset_container_t *)c1, (const bitset_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
array_container_intersection_inplace((array_container_t *)c1,
(const array_container_t *)c2);
*result_type = ARRAY_CONTAINER_TYPE_CODE;
return c1;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
result = run_container_create();
run_container_intersection((const run_container_t *)c1,
(const run_container_t *)c2,
(run_container_t *)result);
return convert_run_to_efficient_container_and_free(
(run_container_t *)result, result_type);
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
result = array_container_create();
array_bitset_container_intersection((const array_container_t *)c2,
(const bitset_container_t *)c1,
(array_container_t *)result);
*result_type = ARRAY_CONTAINER_TYPE_CODE; return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
*result_type = ARRAY_CONTAINER_TYPE_CODE; array_bitset_container_intersection(
(const array_container_t *)c1, (const bitset_container_t *)c2,
(array_container_t *)c1); return c1;
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
RUN_CONTAINER_TYPE_CODE):
*result_type = run_bitset_container_intersection(
(const run_container_t *)c2,
(const bitset_container_t *)c1, &c1)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return c1;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
*result_type = run_bitset_container_intersection(
(const run_container_t *)c1,
(const bitset_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
result = array_container_create();
*result_type = ARRAY_CONTAINER_TYPE_CODE; array_run_container_intersection((const array_container_t *)c1,
(const run_container_t *)c2,
(array_container_t *)result);
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE):
result = array_container_create();
*result_type = ARRAY_CONTAINER_TYPE_CODE; array_run_container_intersection((const array_container_t *)c2,
(const run_container_t *)c1,
(array_container_t *)result);
return result;
default:
assert(false);
__builtin_unreachable();
return NULL;
}
}
static inline void *container_or(const void *c1, uint8_t type1, const void *c2,
uint8_t type2, uint8_t *result_type) {
c1 = container_unwrap_shared(c1, &type1);
c2 = container_unwrap_shared(c2, &type2);
void *result = NULL;
switch (CONTAINER_PAIR(type1, type2)) {
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
result = bitset_container_create();
bitset_container_or((const bitset_container_t *)c1,
(const bitset_container_t *)c2,
(bitset_container_t *)result);
*result_type = BITSET_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
*result_type = array_array_container_union(
(const array_container_t *)c1,
(const array_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
result = run_container_create();
run_container_union((const run_container_t *)c1,
(const run_container_t *)c2,
(run_container_t *)result);
*result_type = RUN_CONTAINER_TYPE_CODE;
result = convert_run_to_efficient_container_and_free(
(run_container_t *)result, (uint8_t *)result_type);
return result;
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
result = bitset_container_create();
array_bitset_container_union((const array_container_t *)c2,
(const bitset_container_t *)c1,
(bitset_container_t *)result);
*result_type = BITSET_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
result = bitset_container_create();
array_bitset_container_union((const array_container_t *)c1,
(const bitset_container_t *)c2,
(bitset_container_t *)result);
*result_type = BITSET_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
RUN_CONTAINER_TYPE_CODE):
if (run_container_is_full((const run_container_t *)c2)) {
result = run_container_create();
*result_type = RUN_CONTAINER_TYPE_CODE;
run_container_copy((const run_container_t *)c2,
(run_container_t *)result);
return result;
}
result = bitset_container_create();
run_bitset_container_union((const run_container_t *)c2,
(const bitset_container_t *)c1,
(bitset_container_t *)result);
*result_type = BITSET_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
if (run_container_is_full((const run_container_t *)c1)) {
result = run_container_create();
*result_type = RUN_CONTAINER_TYPE_CODE;
run_container_copy((const run_container_t *)c1,
(run_container_t *)result);
return result;
}
result = bitset_container_create();
run_bitset_container_union((const run_container_t *)c1,
(const bitset_container_t *)c2,
(bitset_container_t *)result);
*result_type = BITSET_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
result = run_container_create();
array_run_container_union((const array_container_t *)c1,
(const run_container_t *)c2,
(run_container_t *)result);
result = convert_run_to_efficient_container_and_free(
(run_container_t *)result, (uint8_t *)result_type);
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE):
result = run_container_create();
array_run_container_union((const array_container_t *)c2,
(const run_container_t *)c1,
(run_container_t *)result);
result = convert_run_to_efficient_container_and_free(
(run_container_t *)result, (uint8_t *)result_type);
return result;
default:
assert(false);
__builtin_unreachable();
return NULL; }
}
static inline void *container_lazy_or(const void *c1, uint8_t type1,
const void *c2, uint8_t type2,
uint8_t *result_type) {
c1 = container_unwrap_shared(c1, &type1);
c2 = container_unwrap_shared(c2, &type2);
void *result = NULL;
switch (CONTAINER_PAIR(type1, type2)) {
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
result = bitset_container_create();
bitset_container_or_nocard(
(const bitset_container_t *)c1, (const bitset_container_t *)c2,
(bitset_container_t *)result); *result_type = BITSET_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
*result_type = array_array_container_lazy_union(
(const array_container_t *)c1,
(const array_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
result = run_container_create();
run_container_union((const run_container_t *)c1,
(const run_container_t *)c2,
(run_container_t *)result);
*result_type = RUN_CONTAINER_TYPE_CODE;
result = convert_run_to_efficient_container(
(run_container_t *)result, result_type);
return result;
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
result = bitset_container_create();
array_bitset_container_lazy_union(
(const array_container_t *)c2, (const bitset_container_t *)c1,
(bitset_container_t *)result); *result_type = BITSET_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
result = bitset_container_create();
array_bitset_container_lazy_union(
(const array_container_t *)c1, (const bitset_container_t *)c2,
(bitset_container_t *)result); *result_type = BITSET_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
RUN_CONTAINER_TYPE_CODE):
if (run_container_is_full((const run_container_t *)c2)) {
result = run_container_create();
*result_type = RUN_CONTAINER_TYPE_CODE;
run_container_copy((const run_container_t *)c2,
(run_container_t *)result);
return result;
}
result = bitset_container_create();
run_bitset_container_lazy_union(
(const run_container_t *)c2, (const bitset_container_t *)c1,
(bitset_container_t *)result); *result_type = BITSET_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
if (run_container_is_full((const run_container_t *)c1)) {
result = run_container_create();
*result_type = RUN_CONTAINER_TYPE_CODE;
run_container_copy((const run_container_t *)c1,
(run_container_t *)result);
return result;
}
result = bitset_container_create();
run_bitset_container_lazy_union(
(const run_container_t *)c1, (const bitset_container_t *)c2,
(bitset_container_t *)result); *result_type = BITSET_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
result = run_container_create();
array_run_container_union((const array_container_t *)c1,
(const run_container_t *)c2,
(run_container_t *)result);
*result_type = RUN_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE):
result = run_container_create();
array_run_container_union(
(const array_container_t *)c2, (const run_container_t *)c1,
(run_container_t *)result); *result_type = RUN_CONTAINER_TYPE_CODE;
return result;
default:
assert(false);
__builtin_unreachable();
return NULL; }
}
static inline void *container_ior(void *c1, uint8_t type1, const void *c2,
uint8_t type2, uint8_t *result_type) {
c1 = get_writable_copy_if_shared(c1, &type1);
c2 = container_unwrap_shared(c2, &type2);
void *result = NULL;
switch (CONTAINER_PAIR(type1, type2)) {
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
bitset_container_or((const bitset_container_t *)c1,
(const bitset_container_t *)c2,
(bitset_container_t *)c1);
#ifdef OR_BITSET_CONVERSION_TO_FULL
if (((bitset_container_t *)c1)->cardinality ==
(1 << 16)) { result = run_container_create_range(0, (1 << 16));
*result_type = RUN_CONTAINER_TYPE_CODE;
return result;
}
#endif
*result_type = BITSET_CONTAINER_TYPE_CODE;
return c1;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
*result_type = array_array_container_inplace_union(
(array_container_t *)c1,
(const array_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
if((result == NULL)
&& (*result_type == ARRAY_CONTAINER_TYPE_CODE)) {
return c1; }
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
run_container_union_inplace((run_container_t *)c1,
(const run_container_t *)c2);
return convert_run_to_efficient_container((run_container_t *)c1,
result_type);
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
array_bitset_container_union((const array_container_t *)c2,
(const bitset_container_t *)c1,
(bitset_container_t *)c1);
*result_type = BITSET_CONTAINER_TYPE_CODE; return c1;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
result = bitset_container_create();
*result_type = BITSET_CONTAINER_TYPE_CODE;
array_bitset_container_union((const array_container_t *)c1,
(const bitset_container_t *)c2,
(bitset_container_t *)result);
return result;
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
RUN_CONTAINER_TYPE_CODE):
if (run_container_is_full((const run_container_t *)c2)) {
result = run_container_create();
*result_type = RUN_CONTAINER_TYPE_CODE;
run_container_copy((const run_container_t *)c2,
(run_container_t *)result);
return result;
}
run_bitset_container_union((const run_container_t *)c2,
(const bitset_container_t *)c1,
(bitset_container_t *)c1); *result_type = BITSET_CONTAINER_TYPE_CODE;
return c1;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
if (run_container_is_full((const run_container_t *)c1)) {
*result_type = RUN_CONTAINER_TYPE_CODE;
return c1;
}
result = bitset_container_create();
run_bitset_container_union((const run_container_t *)c1,
(const bitset_container_t *)c2,
(bitset_container_t *)result);
*result_type = BITSET_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
result = run_container_create();
array_run_container_union((const array_container_t *)c1,
(const run_container_t *)c2,
(run_container_t *)result);
result = convert_run_to_efficient_container_and_free(
(run_container_t *)result, result_type);
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE):
array_run_container_inplace_union((const array_container_t *)c2,
(run_container_t *)c1);
c1 = convert_run_to_efficient_container((run_container_t *)c1,
result_type);
return c1;
default:
assert(false);
__builtin_unreachable();
return NULL;
}
}
static inline void *container_lazy_ior(void *c1, uint8_t type1, const void *c2,
uint8_t type2, uint8_t *result_type) {
assert(type1 != SHARED_CONTAINER_TYPE_CODE);
c2 = container_unwrap_shared(c2, &type2);
void *result = NULL;
switch (CONTAINER_PAIR(type1, type2)) {
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
#ifdef LAZY_OR_BITSET_CONVERSION_TO_FULL
bitset_container_or((const bitset_container_t *)c1,
(const bitset_container_t *)c2,
(bitset_container_t *)c1);
if (((bitset_container_t *)c1)->cardinality ==
(1 << 16)) { result = run_container_create_range(0, (1 << 16));
*result_type = RUN_CONTAINER_TYPE_CODE;
return result;
}
#else
bitset_container_or_nocard((const bitset_container_t *)c1,
(const bitset_container_t *)c2,
(bitset_container_t *)c1);
#endif
*result_type = BITSET_CONTAINER_TYPE_CODE;
return c1;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
*result_type = array_array_container_lazy_inplace_union(
(array_container_t *)c1,
(const array_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
if((result == NULL)
&& (*result_type == ARRAY_CONTAINER_TYPE_CODE)) {
return c1; }
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
run_container_union_inplace((run_container_t *)c1,
(const run_container_t *)c2);
*result_type = RUN_CONTAINER_TYPE_CODE;
return convert_run_to_efficient_container((run_container_t *)c1,
result_type);
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
array_bitset_container_lazy_union(
(const array_container_t *)c2, (const bitset_container_t *)c1,
(bitset_container_t *)c1); *result_type = BITSET_CONTAINER_TYPE_CODE; return c1;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
result = bitset_container_create();
*result_type = BITSET_CONTAINER_TYPE_CODE;
array_bitset_container_lazy_union(
(const array_container_t *)c1, (const bitset_container_t *)c2,
(bitset_container_t *)result); return result;
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
RUN_CONTAINER_TYPE_CODE):
if (run_container_is_full((const run_container_t *)c2)) {
result = run_container_create();
*result_type = RUN_CONTAINER_TYPE_CODE;
run_container_copy((const run_container_t *)c2,
(run_container_t *)result);
return result;
}
run_bitset_container_lazy_union(
(const run_container_t *)c2, (const bitset_container_t *)c1,
(bitset_container_t *)c1); *result_type = BITSET_CONTAINER_TYPE_CODE;
return c1;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
if (run_container_is_full((const run_container_t *)c1)) {
*result_type = RUN_CONTAINER_TYPE_CODE;
return c1;
}
result = bitset_container_create();
run_bitset_container_lazy_union(
(const run_container_t *)c1, (const bitset_container_t *)c2,
(bitset_container_t *)result); *result_type = BITSET_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
result = run_container_create();
array_run_container_union((const array_container_t *)c1,
(const run_container_t *)c2,
(run_container_t *)result);
*result_type = RUN_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE):
array_run_container_inplace_union((const array_container_t *)c2,
(run_container_t *)c1);
*result_type = RUN_CONTAINER_TYPE_CODE;
return c1;
default:
assert(false);
__builtin_unreachable();
return NULL;
}
}
static inline void *container_xor(const void *c1, uint8_t type1, const void *c2,
uint8_t type2, uint8_t *result_type) {
c1 = container_unwrap_shared(c1, &type1);
c2 = container_unwrap_shared(c2, &type2);
void *result = NULL;
switch (CONTAINER_PAIR(type1, type2)) {
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
*result_type = bitset_bitset_container_xor(
(const bitset_container_t *)c1,
(const bitset_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
*result_type = array_array_container_xor(
(const array_container_t *)c1,
(const array_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
*result_type =
run_run_container_xor((const run_container_t *)c1,
(const run_container_t *)c2, &result);
return result;
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
*result_type = array_bitset_container_xor(
(const array_container_t *)c2,
(const bitset_container_t *)c1, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
*result_type = array_bitset_container_xor(
(const array_container_t *)c1,
(const bitset_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
RUN_CONTAINER_TYPE_CODE):
*result_type = run_bitset_container_xor(
(const run_container_t *)c2,
(const bitset_container_t *)c1, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
*result_type = run_bitset_container_xor(
(const run_container_t *)c1,
(const bitset_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
*result_type =
array_run_container_xor((const array_container_t *)c1,
(const run_container_t *)c2, &result);
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE):
*result_type =
array_run_container_xor((const array_container_t *)c2,
(const run_container_t *)c1, &result);
return result;
default:
assert(false);
__builtin_unreachable();
return NULL; }
}
static inline void *container_lazy_xor(const void *c1, uint8_t type1,
const void *c2, uint8_t type2,
uint8_t *result_type) {
c1 = container_unwrap_shared(c1, &type1);
c2 = container_unwrap_shared(c2, &type2);
void *result = NULL;
switch (CONTAINER_PAIR(type1, type2)) {
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
result = bitset_container_create();
bitset_container_xor_nocard(
(const bitset_container_t *)c1, (const bitset_container_t *)c2,
(bitset_container_t *)result); *result_type = BITSET_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
*result_type = array_array_container_lazy_xor(
(const array_container_t *)c1,
(const array_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
*result_type =
run_run_container_xor((const run_container_t *)c1,
(const run_container_t *)c2, &result);
return result;
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
result = bitset_container_create();
*result_type = BITSET_CONTAINER_TYPE_CODE;
array_bitset_container_lazy_xor((const array_container_t *)c2,
(const bitset_container_t *)c1,
(bitset_container_t *)result);
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
result = bitset_container_create();
*result_type = BITSET_CONTAINER_TYPE_CODE;
array_bitset_container_lazy_xor((const array_container_t *)c1,
(const bitset_container_t *)c2,
(bitset_container_t *)result);
return result;
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
RUN_CONTAINER_TYPE_CODE):
result = bitset_container_create();
run_bitset_container_lazy_xor((const run_container_t *)c2,
(const bitset_container_t *)c1,
(bitset_container_t *)result);
*result_type = BITSET_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
result = bitset_container_create();
run_bitset_container_lazy_xor((const run_container_t *)c1,
(const bitset_container_t *)c2,
(bitset_container_t *)result);
*result_type = BITSET_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
result = run_container_create();
array_run_container_lazy_xor((const array_container_t *)c1,
(const run_container_t *)c2,
(run_container_t *)result);
*result_type = RUN_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE):
result = run_container_create();
array_run_container_lazy_xor((const array_container_t *)c2,
(const run_container_t *)c1,
(run_container_t *)result);
*result_type = RUN_CONTAINER_TYPE_CODE;
return result;
default:
assert(false);
__builtin_unreachable();
return NULL; }
}
static inline void *container_ixor(void *c1, uint8_t type1, const void *c2,
uint8_t type2, uint8_t *result_type) {
c1 = get_writable_copy_if_shared(c1, &type1);
c2 = container_unwrap_shared(c2, &type2);
void *result = NULL;
switch (CONTAINER_PAIR(type1, type2)) {
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
*result_type = bitset_bitset_container_ixor(
(bitset_container_t *)c1,
(const bitset_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
*result_type = array_array_container_ixor(
(array_container_t *)c1,
(const array_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
*result_type = run_run_container_ixor(
(run_container_t *)c1, (const run_container_t *)c2, &result);
return result;
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
*result_type = bitset_array_container_ixor(
(bitset_container_t *)c1,
(const array_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
*result_type = array_bitset_container_ixor(
(array_container_t *)c1,
(const bitset_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
RUN_CONTAINER_TYPE_CODE):
*result_type =
bitset_run_container_ixor((bitset_container_t *)c1,
(const run_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
*result_type = run_bitset_container_ixor(
(run_container_t *)c1,
(const bitset_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
*result_type = array_run_container_ixor(
(array_container_t *)c1, (const run_container_t *)c2, &result);
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE):
*result_type = run_array_container_ixor(
(run_container_t *)c1, (const array_container_t *)c2, &result);
return result;
default:
assert(false);
__builtin_unreachable();
return NULL;
}
}
static inline void *container_lazy_ixor(void *c1, uint8_t type1, const void *c2,
uint8_t type2, uint8_t *result_type) {
assert(type1 != SHARED_CONTAINER_TYPE_CODE);
c2 = container_unwrap_shared(c2, &type2);
switch (CONTAINER_PAIR(type1, type2)) {
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
bitset_container_xor_nocard((bitset_container_t *)c1,
(const bitset_container_t *)c2,
(bitset_container_t *)c1); *result_type = BITSET_CONTAINER_TYPE_CODE;
return c1;
default:
if( (type1 == BITSET_CONTAINER_TYPE_CODE)
&& (((const bitset_container_t *)c1)->cardinality == BITSET_UNKNOWN_CARDINALITY)) {
((bitset_container_t *)c1)->cardinality = bitset_container_compute_cardinality((bitset_container_t *)c1);
}
return container_ixor(c1, type1, c2, type2, result_type);
}
}
static inline void *container_andnot(const void *c1, uint8_t type1,
const void *c2, uint8_t type2,
uint8_t *result_type) {
c1 = container_unwrap_shared(c1, &type1);
c2 = container_unwrap_shared(c2, &type2);
void *result = NULL;
switch (CONTAINER_PAIR(type1, type2)) {
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
*result_type = bitset_bitset_container_andnot(
(const bitset_container_t *)c1,
(const bitset_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
result = array_container_create();
array_array_container_andnot((const array_container_t *)c1,
(const array_container_t *)c2,
(array_container_t *)result);
*result_type = ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
if (run_container_is_full((const run_container_t *)c2)) {
result = array_container_create();
*result_type = ARRAY_CONTAINER_TYPE_CODE;
return result;
}
*result_type =
run_run_container_andnot((const run_container_t *)c1,
(const run_container_t *)c2, &result);
return result;
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
*result_type = bitset_array_container_andnot(
(const bitset_container_t *)c1,
(const array_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
result = array_container_create();
array_bitset_container_andnot((const array_container_t *)c1,
(const bitset_container_t *)c2,
(array_container_t *)result);
*result_type = ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
RUN_CONTAINER_TYPE_CODE):
if (run_container_is_full((const run_container_t *)c2)) {
result = array_container_create();
*result_type = ARRAY_CONTAINER_TYPE_CODE;
return result;
}
*result_type = bitset_run_container_andnot(
(const bitset_container_t *)c1,
(const run_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
*result_type = run_bitset_container_andnot(
(const run_container_t *)c1,
(const bitset_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
if (run_container_is_full((const run_container_t *)c2)) {
result = array_container_create();
*result_type = ARRAY_CONTAINER_TYPE_CODE;
return result;
}
result = array_container_create();
array_run_container_andnot((const array_container_t *)c1,
(const run_container_t *)c2,
(array_container_t *)result);
*result_type = ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE):
*result_type = run_array_container_andnot(
(const run_container_t *)c1, (const array_container_t *)c2,
&result);
return result;
default:
assert(false);
__builtin_unreachable();
return NULL; }
}
static inline void *container_iandnot(void *c1, uint8_t type1, const void *c2,
uint8_t type2, uint8_t *result_type) {
c1 = get_writable_copy_if_shared(c1, &type1);
c2 = container_unwrap_shared(c2, &type2);
void *result = NULL;
switch (CONTAINER_PAIR(type1, type2)) {
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
*result_type = bitset_bitset_container_iandnot(
(bitset_container_t *)c1,
(const bitset_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
array_array_container_iandnot((array_container_t *)c1,
(const array_container_t *)c2);
*result_type = ARRAY_CONTAINER_TYPE_CODE;
return c1;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
*result_type = run_run_container_iandnot(
(run_container_t *)c1, (const run_container_t *)c2, &result);
return result;
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
ARRAY_CONTAINER_TYPE_CODE):
*result_type = bitset_array_container_iandnot(
(bitset_container_t *)c1,
(const array_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
*result_type = ARRAY_CONTAINER_TYPE_CODE;
array_bitset_container_iandnot((array_container_t *)c1,
(const bitset_container_t *)c2);
return c1;
case CONTAINER_PAIR(BITSET_CONTAINER_TYPE_CODE,
RUN_CONTAINER_TYPE_CODE):
*result_type = bitset_run_container_iandnot(
(bitset_container_t *)c1,
(const run_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE,
BITSET_CONTAINER_TYPE_CODE):
*result_type = run_bitset_container_iandnot(
(run_container_t *)c1,
(const bitset_container_t *)c2, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case CONTAINER_PAIR(ARRAY_CONTAINER_TYPE_CODE, RUN_CONTAINER_TYPE_CODE):
*result_type = ARRAY_CONTAINER_TYPE_CODE;
array_run_container_iandnot((array_container_t *)c1,
(const run_container_t *)c2);
return c1;
case CONTAINER_PAIR(RUN_CONTAINER_TYPE_CODE, ARRAY_CONTAINER_TYPE_CODE):
*result_type = run_array_container_iandnot(
(run_container_t *)c1, (const array_container_t *)c2, &result);
return result;
default:
assert(false);
__builtin_unreachable();
return NULL;
}
}
static inline bool container_iterate(const void *container, uint8_t typecode,
uint32_t base, roaring_iterator iterator,
void *ptr) {
container = container_unwrap_shared(container, &typecode);
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
return bitset_container_iterate(
(const bitset_container_t *)container, base, iterator, ptr);
case ARRAY_CONTAINER_TYPE_CODE:
return array_container_iterate((const array_container_t *)container,
base, iterator, ptr);
case RUN_CONTAINER_TYPE_CODE:
return run_container_iterate((const run_container_t *)container,
base, iterator, ptr);
default:
assert(false);
__builtin_unreachable();
}
assert(false);
__builtin_unreachable();
return false;
}
static inline bool container_iterate64(const void *container, uint8_t typecode,
uint32_t base,
roaring_iterator64 iterator,
uint64_t high_bits, void *ptr) {
container = container_unwrap_shared(container, &typecode);
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
return bitset_container_iterate64(
(const bitset_container_t *)container, base, iterator,
high_bits, ptr);
case ARRAY_CONTAINER_TYPE_CODE:
return array_container_iterate64(
(const array_container_t *)container, base, iterator, high_bits,
ptr);
case RUN_CONTAINER_TYPE_CODE:
return run_container_iterate64((const run_container_t *)container,
base, iterator, high_bits, ptr);
default:
assert(false);
__builtin_unreachable();
}
assert(false);
__builtin_unreachable();
return false;
}
static inline void *container_not(const void *c, uint8_t typ,
uint8_t *result_type) {
c = container_unwrap_shared(c, &typ);
void *result = NULL;
switch (typ) {
case BITSET_CONTAINER_TYPE_CODE:
*result_type = bitset_container_negation(
(const bitset_container_t *)c, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case ARRAY_CONTAINER_TYPE_CODE:
result = bitset_container_create();
*result_type = BITSET_CONTAINER_TYPE_CODE;
array_container_negation((const array_container_t *)c,
(bitset_container_t *)result);
return result;
case RUN_CONTAINER_TYPE_CODE:
*result_type =
run_container_negation((const run_container_t *)c, &result);
return result;
default:
assert(false);
__builtin_unreachable();
}
assert(false);
__builtin_unreachable();
return NULL;
}
static inline void *container_not_range(const void *c, uint8_t typ,
uint32_t range_start,
uint32_t range_end,
uint8_t *result_type) {
c = container_unwrap_shared(c, &typ);
void *result = NULL;
switch (typ) {
case BITSET_CONTAINER_TYPE_CODE:
*result_type =
bitset_container_negation_range((const bitset_container_t *)c,
range_start, range_end, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case ARRAY_CONTAINER_TYPE_CODE:
*result_type =
array_container_negation_range((const array_container_t *)c,
range_start, range_end, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case RUN_CONTAINER_TYPE_CODE:
*result_type = run_container_negation_range(
(const run_container_t *)c, range_start, range_end, &result);
return result;
default:
assert(false);
__builtin_unreachable();
}
assert(false);
__builtin_unreachable();
return NULL;
}
static inline void *container_inot(void *c, uint8_t typ, uint8_t *result_type) {
c = get_writable_copy_if_shared(c, &typ);
void *result = NULL;
switch (typ) {
case BITSET_CONTAINER_TYPE_CODE:
*result_type = bitset_container_negation_inplace(
(bitset_container_t *)c, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case ARRAY_CONTAINER_TYPE_CODE:
result = bitset_container_create();
*result_type = BITSET_CONTAINER_TYPE_CODE;
array_container_negation((array_container_t *)c,
(bitset_container_t *)result);
array_container_free((array_container_t *)c);
return result;
case RUN_CONTAINER_TYPE_CODE:
*result_type =
run_container_negation_inplace((run_container_t *)c, &result);
return result;
default:
assert(false);
__builtin_unreachable();
}
assert(false);
__builtin_unreachable();
return NULL;
}
static inline void *container_inot_range(void *c, uint8_t typ,
uint32_t range_start,
uint32_t range_end,
uint8_t *result_type) {
c = get_writable_copy_if_shared(c, &typ);
void *result = NULL;
switch (typ) {
case BITSET_CONTAINER_TYPE_CODE:
*result_type =
bitset_container_negation_range_inplace(
(bitset_container_t *)c, range_start, range_end, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case ARRAY_CONTAINER_TYPE_CODE:
*result_type =
array_container_negation_range_inplace(
(array_container_t *)c, range_start, range_end, &result)
? BITSET_CONTAINER_TYPE_CODE
: ARRAY_CONTAINER_TYPE_CODE;
return result;
case RUN_CONTAINER_TYPE_CODE:
*result_type = run_container_negation_range_inplace(
(run_container_t *)c, range_start, range_end, &result);
return result;
default:
assert(false);
__builtin_unreachable();
}
assert(false);
__builtin_unreachable();
return NULL;
}
static inline bool container_select(const void *container, uint8_t typecode,
uint32_t *start_rank, uint32_t rank,
uint32_t *element) {
container = container_unwrap_shared(container, &typecode);
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
return bitset_container_select((const bitset_container_t *)container,
start_rank, rank, element);
case ARRAY_CONTAINER_TYPE_CODE:
return array_container_select((const array_container_t *)container,
start_rank, rank, element);
case RUN_CONTAINER_TYPE_CODE:
return run_container_select((const run_container_t *)container,
start_rank, rank, element);
default:
assert(false);
__builtin_unreachable();
}
assert(false);
__builtin_unreachable();
return false;
}
static inline uint16_t container_maximum(const void *container,
uint8_t typecode) {
container = container_unwrap_shared(container, &typecode);
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
return bitset_container_maximum((const bitset_container_t *)container);
case ARRAY_CONTAINER_TYPE_CODE:
return array_container_maximum((const array_container_t *)container);
case RUN_CONTAINER_TYPE_CODE:
return run_container_maximum((const run_container_t *)container);
default:
assert(false);
__builtin_unreachable();
}
assert(false);
__builtin_unreachable();
return false;
}
static inline uint16_t container_minimum(const void *container,
uint8_t typecode) {
container = container_unwrap_shared(container, &typecode);
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
return bitset_container_minimum((const bitset_container_t *)container);
case ARRAY_CONTAINER_TYPE_CODE:
return array_container_minimum((const array_container_t *)container);
case RUN_CONTAINER_TYPE_CODE:
return run_container_minimum((const run_container_t *)container);
default:
assert(false);
__builtin_unreachable();
}
assert(false);
__builtin_unreachable();
return false;
}
static inline int container_rank(const void *container, uint8_t typecode,
uint16_t x) {
container = container_unwrap_shared(container, &typecode);
switch (typecode) {
case BITSET_CONTAINER_TYPE_CODE:
return bitset_container_rank((const bitset_container_t *)container, x);
case ARRAY_CONTAINER_TYPE_CODE:
return array_container_rank((const array_container_t *)container, x);
case RUN_CONTAINER_TYPE_CODE:
return run_container_rank((const run_container_t *)container, x);
default:
assert(false);
__builtin_unreachable();
}
assert(false);
__builtin_unreachable();
return false;
}
static inline void *container_add_range(void *container, uint8_t type,
uint32_t min, uint32_t max,
uint8_t *result_type) {
switch (type) {
case BITSET_CONTAINER_TYPE_CODE: {
bitset_container_t *bitset = (bitset_container_t *) container;
int32_t union_cardinality = 0;
union_cardinality += bitset->cardinality;
union_cardinality += max - min + 1;
union_cardinality -= bitset_lenrange_cardinality(bitset->array, min, max-min);
if (union_cardinality == INT32_C(0x10000)) {
*result_type = RUN_CONTAINER_TYPE_CODE;
return run_container_create_range(0, INT32_C(0x10000));
} else {
*result_type = BITSET_CONTAINER_TYPE_CODE;
bitset_set_lenrange(bitset->array, min, max - min);
bitset->cardinality = union_cardinality;
return bitset;
}
}
case ARRAY_CONTAINER_TYPE_CODE: {
array_container_t *array = (array_container_t *) container;
int32_t nvals_greater = count_greater(array->array, array->cardinality, max);
int32_t nvals_less = count_less(array->array, array->cardinality - nvals_greater, min);
int32_t union_cardinality = nvals_less + (max - min + 1) + nvals_greater;
if (union_cardinality == INT32_C(0x10000)) {
*result_type = RUN_CONTAINER_TYPE_CODE;
return run_container_create_range(0, INT32_C(0x10000));
} else if (union_cardinality <= DEFAULT_MAX_SIZE) {
*result_type = ARRAY_CONTAINER_TYPE_CODE;
array_container_add_range_nvals(array, min, max, nvals_less, nvals_greater);
return array;
} else {
*result_type = BITSET_CONTAINER_TYPE_CODE;
bitset_container_t *bitset = bitset_container_from_array(array);
bitset_set_lenrange(bitset->array, min, max - min);
bitset->cardinality = union_cardinality;
return bitset;
}
}
case RUN_CONTAINER_TYPE_CODE: {
run_container_t *run = (run_container_t *) container;
int32_t nruns_greater = rle16_count_greater(run->runs, run->n_runs, max);
int32_t nruns_less = rle16_count_less(run->runs, run->n_runs - nruns_greater, min);
int32_t run_size_bytes = (nruns_less + 1 + nruns_greater) * sizeof(rle16_t);
int32_t bitset_size_bytes = BITSET_CONTAINER_SIZE_IN_WORDS * sizeof(uint64_t);
if (run_size_bytes <= bitset_size_bytes) {
run_container_add_range_nruns(run, min, max, nruns_less, nruns_greater);
*result_type = RUN_CONTAINER_TYPE_CODE;
return run;
} else {
*result_type = BITSET_CONTAINER_TYPE_CODE;
return bitset_container_from_run_range(run, min, max);
}
}
default:
__builtin_unreachable();
}
}
static inline void *container_remove_range(void *container, uint8_t type,
uint32_t min, uint32_t max,
uint8_t *result_type) {
switch (type) {
case BITSET_CONTAINER_TYPE_CODE: {
bitset_container_t *bitset = (bitset_container_t *) container;
int32_t result_cardinality = bitset->cardinality -
bitset_lenrange_cardinality(bitset->array, min, max-min);
if (result_cardinality == 0) {
return NULL;
} else if (result_cardinality < DEFAULT_MAX_SIZE) {
*result_type = ARRAY_CONTAINER_TYPE_CODE;
bitset_reset_range(bitset->array, min, max+1);
bitset->cardinality = result_cardinality;
return array_container_from_bitset(bitset);
} else {
*result_type = BITSET_CONTAINER_TYPE_CODE;
bitset_reset_range(bitset->array, min, max+1);
bitset->cardinality = result_cardinality;
return bitset;
}
}
case ARRAY_CONTAINER_TYPE_CODE: {
array_container_t *array = (array_container_t *) container;
int32_t nvals_greater = count_greater(array->array, array->cardinality, max);
int32_t nvals_less = count_less(array->array, array->cardinality - nvals_greater, min);
int32_t result_cardinality = nvals_less + nvals_greater;
if (result_cardinality == 0) {
return NULL;
} else {
*result_type = ARRAY_CONTAINER_TYPE_CODE;
array_container_remove_range(array, nvals_less,
array->cardinality - result_cardinality);
return array;
}
}
case RUN_CONTAINER_TYPE_CODE: {
run_container_t *run = (run_container_t *) container;
if (run->n_runs == 0) {
return NULL;
}
if (min <= run_container_minimum(run) && max >= run_container_maximum(run)) {
return NULL;
}
run_container_remove_range(run, min, max);
if (run_container_serialized_size_in_bytes(run->n_runs) <=
bitset_container_serialized_size_in_bytes()) {
*result_type = RUN_CONTAINER_TYPE_CODE;
return run;
} else {
*result_type = BITSET_CONTAINER_TYPE_CODE;
return bitset_container_from_run(run);
}
}
default:
__builtin_unreachable();
}
}
#endif
#ifndef INCLUDE_ROARING_ARRAY_H
#define INCLUDE_ROARING_ARRAY_H
#ifdef __cplusplus
extern "C" {
#endif
#include <assert.h>
#include <stdbool.h>
#include <stdint.h>
#define MAX_CONTAINERS 65536
#define SERIALIZATION_ARRAY_UINT32 1
#define SERIALIZATION_CONTAINER 2
#define ROARING_FLAG_COW UINT8_C(0x1)
#define ROARING_FLAG_FROZEN UINT8_C(0x2)
enum {
SERIAL_COOKIE_NO_RUNCONTAINER = 12346,
SERIAL_COOKIE = 12347,
FROZEN_COOKIE = 13766,
NO_OFFSET_THRESHOLD = 4
};
typedef struct roaring_array_s {
int32_t size;
int32_t allocation_size;
void **containers;
uint16_t *keys;
uint8_t *typecodes;
uint8_t flags;
} roaring_array_t;
roaring_array_t *ra_create(void);
bool ra_init_with_capacity(roaring_array_t *new_ra, uint32_t cap);
void ra_init(roaring_array_t *t);
bool ra_copy(const roaring_array_t *source, roaring_array_t *dest,
bool copy_on_write);
int ra_shrink_to_fit(roaring_array_t *ra);
bool ra_overwrite(const roaring_array_t *source, roaring_array_t *dest,
bool copy_on_write);
void ra_clear(roaring_array_t *r);
void ra_clear_without_containers(roaring_array_t *r);
void ra_clear_containers(roaring_array_t *ra);
inline int32_t ra_get_index(const roaring_array_t *ra, uint16_t x) {
if ((ra->size == 0) || ra->keys[ra->size - 1] == x) return ra->size - 1;
return binarySearch(ra->keys, (int32_t)ra->size, x);
}
inline void *ra_get_container_at_index(const roaring_array_t *ra, uint16_t i,
uint8_t *typecode) {
*typecode = ra->typecodes[i];
return ra->containers[i];
}
uint16_t ra_get_key_at_index(const roaring_array_t *ra, uint16_t i);
void ra_insert_new_key_value_at(roaring_array_t *ra, int32_t i, uint16_t key,
void *container, uint8_t typecode);
void ra_append(roaring_array_t *ra, uint16_t s, void *c, uint8_t typecode);
void ra_append_copy(roaring_array_t *ra, const roaring_array_t *sa,
uint16_t index, bool copy_on_write);
void ra_append_copy_range(roaring_array_t *ra, const roaring_array_t *sa,
int32_t start_index, int32_t end_index,
bool copy_on_write);
void ra_append_copies_until(roaring_array_t *ra, const roaring_array_t *sa,
uint16_t stopping_key, bool copy_on_write);
void ra_append_copies_after(roaring_array_t *ra, const roaring_array_t *sa,
uint16_t before_start, bool copy_on_write);
void ra_append_move_range(roaring_array_t *ra, roaring_array_t *sa,
int32_t start_index, int32_t end_index);
void ra_append_range(roaring_array_t *ra, roaring_array_t *sa,
int32_t start_index, int32_t end_index,
bool copy_on_write);
inline void ra_set_container_at_index(const roaring_array_t *ra, int32_t i,
void *c, uint8_t typecode) {
assert(i < ra->size);
ra->containers[i] = c;
ra->typecodes[i] = typecode;
}
bool extend_array(roaring_array_t *ra, int32_t k);
inline int32_t ra_get_size(const roaring_array_t *ra) { return ra->size; }
static inline int32_t ra_advance_until(const roaring_array_t *ra, uint16_t x,
int32_t pos) {
return advanceUntil(ra->keys, pos, ra->size, x);
}
int32_t ra_advance_until_freeing(roaring_array_t *ra, uint16_t x, int32_t pos);
void ra_downsize(roaring_array_t *ra, int32_t new_length);
inline void ra_replace_key_and_container_at_index(roaring_array_t *ra,
int32_t i, uint16_t key,
void *c, uint8_t typecode) {
assert(i < ra->size);
ra->keys[i] = key;
ra->containers[i] = c;
ra->typecodes[i] = typecode;
}
void ra_to_uint32_array(const roaring_array_t *ra, uint32_t *ans);
bool ra_range_uint32_array(const roaring_array_t *ra, size_t offset, size_t limit, uint32_t *ans);
size_t ra_portable_serialize(const roaring_array_t *ra, char *buf);
bool ra_portable_deserialize(roaring_array_t *ra, const char *buf, const size_t maxbytes, size_t * readbytes);
size_t ra_portable_deserialize_size(const char *buf, const size_t maxbytes);
size_t ra_portable_size_in_bytes(const roaring_array_t *ra);
bool ra_has_run_container(const roaring_array_t *ra);
uint32_t ra_portable_header_size(const roaring_array_t *ra);
static inline void ra_unshare_container_at_index(roaring_array_t *ra,
uint16_t i) {
assert(i < ra->size);
ra->containers[i] =
get_writable_copy_if_shared(ra->containers[i], &ra->typecodes[i]);
}
void ra_remove_at_index(roaring_array_t *ra, int32_t i);
void ra_reset(roaring_array_t *ra);
void ra_remove_at_index_and_free(roaring_array_t *ra, int32_t i);
void ra_copy_range(roaring_array_t *ra, uint32_t begin, uint32_t end,
uint32_t new_begin);
void ra_shift_tail(roaring_array_t *ra, int32_t count, int32_t distance);
#ifdef __cplusplus
}
#endif
#endif
#ifndef INCLUDE_MISC_CONFIGREPORT_H_
#define INCLUDE_MISC_CONFIGREPORT_H_
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#ifdef IS_X64
static inline void native_cpuid(unsigned int *eax, unsigned int *ebx,
unsigned int *ecx, unsigned int *edx) {
#ifdef ROARING_INLINE_ASM
__asm volatile("cpuid"
: "=a"(*eax), "=b"(*ebx), "=c"(*ecx), "=d"(*edx)
: "0"(*eax), "2"(*ecx));
#endif
}
static inline void cpuinfo(int code, int *eax, int *ebx, int *ecx, int *edx) {
#ifdef ROARING_INLINE_ASM
__asm__ volatile("cpuid;" : "=a"(*eax), "=b"(*ebx), "=c"(*ecx),
"=d"(*edx) : "a"(code) );
#endif
}
static inline int computecacheline() {
int eax = 0, ebx = 0, ecx = 0, edx = 0;
cpuinfo((int)0x80000006, &eax, &ebx, &ecx, &edx);
return ecx & 0xFF;
}
static inline const char *guessprocessor() {
unsigned eax = 1, ebx = 0, ecx = 0, edx = 0;
native_cpuid(&eax, &ebx, &ecx, &edx);
const char *codename;
switch (eax >> 4) {
case 0x506E:
codename = "Skylake";
break;
case 0x406C:
codename = "CherryTrail";
break;
case 0x306D:
codename = "Broadwell";
break;
case 0x306C:
codename = "Haswell";
break;
case 0x306A:
codename = "IvyBridge";
break;
case 0x206A:
case 0x206D:
codename = "SandyBridge";
break;
case 0x2065:
case 0x206C:
case 0x206F:
codename = "Westmere";
break;
case 0x106E:
case 0x106A:
case 0x206E:
codename = "Nehalem";
break;
case 0x1067:
case 0x106D:
codename = "Penryn";
break;
case 0x006F:
case 0x1066:
codename = "Merom";
break;
case 0x0066:
codename = "Presler";
break;
case 0x0063:
case 0x0064:
codename = "Prescott";
break;
case 0x006D:
codename = "Dothan";
break;
case 0x0366:
codename = "Cedarview";
break;
case 0x0266:
codename = "Lincroft";
break;
case 0x016C:
codename = "Pineview";
break;
default:
codename = "UNKNOWN";
break;
}
return codename;
}
static inline void tellmeall() {
printf("Intel processor: %s\t", guessprocessor());
#ifdef __VERSION__
printf(" compiler version: %s\t", __VERSION__);
#endif
printf("\tBuild option USEAVX ");
#ifdef USEAVX
printf("enabled\n");
#else
printf("disabled\n");
#endif
#ifndef __AVX2__
printf("AVX2 is NOT available.\n");
#endif
if ((sizeof(int) != 4) || (sizeof(long) != 8)) {
printf("number of bytes: int = %lu long = %lu \n",
(long unsigned int)sizeof(size_t),
(long unsigned int)sizeof(int));
}
#if __LITTLE_ENDIAN__
#endif
#if __BIG_ENDIAN__
printf("you have a big endian machine");
#endif
#if __CHAR_BIT__
if (__CHAR_BIT__ != 8) printf("on your machine, chars don't have 8bits???");
#endif
if (computecacheline() != 64)
printf("cache line: %d bytes\n", computecacheline());
}
#else
static inline void tellmeall() {
printf("Non-X64 processor\n");
#ifdef __arm__
printf("ARM processor detected\n");
#endif
#ifdef __VERSION__
printf(" compiler version: %s\t", __VERSION__);
#endif
if ((sizeof(int) != 4) || (sizeof(long) != 8)) {
printf("number of bytes: int = %lu long = %lu \n",
(long unsigned int)sizeof(size_t),
(long unsigned int)sizeof(int));
}
#if __LITTLE_ENDIAN__
#endif
#if __BIG_ENDIAN__
printf("you have a big endian machine");
#endif
#if __CHAR_BIT__
if (__CHAR_BIT__ != 8) printf("on your machine, chars don't have 8bits???");
#endif
}
#endif
#endif
#ifndef ROARING_H
#define ROARING_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdbool.h>
typedef struct roaring_bitmap_s {
roaring_array_t high_low_container;
} roaring_bitmap_t;
roaring_bitmap_t *roaring_bitmap_create(void);
roaring_bitmap_t *roaring_bitmap_from_range(uint64_t min, uint64_t max,
uint32_t step);
roaring_bitmap_t *roaring_bitmap_create_with_capacity(uint32_t cap);
roaring_bitmap_t *roaring_bitmap_of_ptr(size_t n_args, const uint32_t *vals);
inline bool roaring_bitmap_get_copy_on_write(const roaring_bitmap_t* r) {
return r->high_low_container.flags & ROARING_FLAG_COW;
}
inline void roaring_bitmap_set_copy_on_write(roaring_bitmap_t* r, bool cow) {
if (cow) {
r->high_low_container.flags |= ROARING_FLAG_COW;
} else {
r->high_low_container.flags &= ~ROARING_FLAG_COW;
}
}
void roaring_bitmap_printf_describe(const roaring_bitmap_t *ra);
roaring_bitmap_t *roaring_bitmap_of(size_t n, ...);
roaring_bitmap_t *roaring_bitmap_copy(const roaring_bitmap_t *r);
bool roaring_bitmap_overwrite(roaring_bitmap_t *dest,
const roaring_bitmap_t *src);
void roaring_bitmap_printf(const roaring_bitmap_t *ra);
roaring_bitmap_t *roaring_bitmap_and(const roaring_bitmap_t *x1,
const roaring_bitmap_t *x2);
uint64_t roaring_bitmap_and_cardinality(const roaring_bitmap_t *x1,
const roaring_bitmap_t *x2);
bool roaring_bitmap_intersect(const roaring_bitmap_t *x1,
const roaring_bitmap_t *x2);
double roaring_bitmap_jaccard_index(const roaring_bitmap_t *x1,
const roaring_bitmap_t *x2);
uint64_t roaring_bitmap_or_cardinality(const roaring_bitmap_t *x1,
const roaring_bitmap_t *x2);
uint64_t roaring_bitmap_andnot_cardinality(const roaring_bitmap_t *x1,
const roaring_bitmap_t *x2);
uint64_t roaring_bitmap_xor_cardinality(const roaring_bitmap_t *x1,
const roaring_bitmap_t *x2);
void roaring_bitmap_and_inplace(roaring_bitmap_t *x1,
const roaring_bitmap_t *x2);
roaring_bitmap_t *roaring_bitmap_or(const roaring_bitmap_t *x1,
const roaring_bitmap_t *x2);
void roaring_bitmap_or_inplace(roaring_bitmap_t *x1,
const roaring_bitmap_t *x2);
roaring_bitmap_t *roaring_bitmap_or_many(size_t number,
const roaring_bitmap_t **x);
roaring_bitmap_t *roaring_bitmap_or_many_heap(uint32_t number,
const roaring_bitmap_t **x);
roaring_bitmap_t *roaring_bitmap_xor(const roaring_bitmap_t *x1,
const roaring_bitmap_t *x2);
void roaring_bitmap_xor_inplace(roaring_bitmap_t *x1,
const roaring_bitmap_t *x2);
roaring_bitmap_t *roaring_bitmap_xor_many(size_t number,
const roaring_bitmap_t **x);
roaring_bitmap_t *roaring_bitmap_andnot(const roaring_bitmap_t *x1,
const roaring_bitmap_t *x2);
void roaring_bitmap_andnot_inplace(roaring_bitmap_t *x1,
const roaring_bitmap_t *x2);
void roaring_bitmap_free(const roaring_bitmap_t *r);
void roaring_bitmap_add_many(roaring_bitmap_t *r, size_t n_args,
const uint32_t *vals);
void roaring_bitmap_add(roaring_bitmap_t *r, uint32_t x);
bool roaring_bitmap_add_checked(roaring_bitmap_t *r, uint32_t x);
void roaring_bitmap_add_range_closed(roaring_bitmap_t *ra, uint32_t min, uint32_t max);
inline void roaring_bitmap_add_range(roaring_bitmap_t *ra, uint64_t min, uint64_t max) {
if(max == min) return;
roaring_bitmap_add_range_closed(ra, (uint32_t)min, (uint32_t)(max - 1));
}
void roaring_bitmap_remove(roaring_bitmap_t *r, uint32_t x);
void roaring_bitmap_remove_range_closed(roaring_bitmap_t *ra, uint32_t min, uint32_t max);
inline void roaring_bitmap_remove_range(roaring_bitmap_t *ra, uint64_t min, uint64_t max) {
if(max == min) return;
roaring_bitmap_remove_range_closed(ra, (uint32_t)min, (uint32_t)(max - 1));
}
void roaring_bitmap_remove_many(roaring_bitmap_t *r, size_t n_args,
const uint32_t *vals);
bool roaring_bitmap_remove_checked(roaring_bitmap_t *r, uint32_t x);
inline bool roaring_bitmap_contains(const roaring_bitmap_t *r, uint32_t val) {
const uint16_t hb = val >> 16;
int32_t i = ra_get_index(&r->high_low_container, hb);
if (i < 0) return false;
uint8_t typecode;
void *container =
ra_get_container_at_index(&r->high_low_container, i, &typecode);
return container_contains(container, val & 0xFFFF, typecode);
}
bool roaring_bitmap_contains_range(const roaring_bitmap_t *r, uint64_t range_start, uint64_t range_end);
uint64_t roaring_bitmap_get_cardinality(const roaring_bitmap_t *ra);
uint64_t roaring_bitmap_range_cardinality(const roaring_bitmap_t *ra,
uint64_t range_start, uint64_t range_end);
bool roaring_bitmap_is_empty(const roaring_bitmap_t *ra);
void roaring_bitmap_clear(roaring_bitmap_t *ra);
void roaring_bitmap_to_uint32_array(const roaring_bitmap_t *ra, uint32_t *ans);
bool roaring_bitmap_range_uint32_array(const roaring_bitmap_t *ra, size_t offset, size_t limit, uint32_t *ans);
bool roaring_bitmap_remove_run_compression(roaring_bitmap_t *r);
bool roaring_bitmap_run_optimize(roaring_bitmap_t *r);
size_t roaring_bitmap_shrink_to_fit(roaring_bitmap_t *r);
size_t roaring_bitmap_serialize(const roaring_bitmap_t *ra, char *buf);
roaring_bitmap_t *roaring_bitmap_deserialize(const void *buf);
size_t roaring_bitmap_size_in_bytes(const roaring_bitmap_t *ra);
roaring_bitmap_t *roaring_bitmap_portable_deserialize(const char *buf);
roaring_bitmap_t *roaring_bitmap_portable_deserialize_safe(const char *buf, size_t maxbytes);
size_t roaring_bitmap_portable_deserialize_size(const char *buf, size_t maxbytes);
size_t roaring_bitmap_portable_size_in_bytes(const roaring_bitmap_t *ra);
size_t roaring_bitmap_portable_serialize(const roaring_bitmap_t *ra, char *buf);
size_t roaring_bitmap_frozen_size_in_bytes(const roaring_bitmap_t *ra);
void roaring_bitmap_frozen_serialize(const roaring_bitmap_t *ra, char *buf);
const roaring_bitmap_t *roaring_bitmap_frozen_view(const char *buf, size_t length);
bool roaring_iterate(const roaring_bitmap_t *ra, roaring_iterator iterator,
void *ptr);
bool roaring_iterate64(const roaring_bitmap_t *ra, roaring_iterator64 iterator,
uint64_t high_bits, void *ptr);
bool roaring_bitmap_equals(const roaring_bitmap_t *ra1,
const roaring_bitmap_t *ra2);
bool roaring_bitmap_is_subset(const roaring_bitmap_t *ra1,
const roaring_bitmap_t *ra2);
bool roaring_bitmap_is_strict_subset(const roaring_bitmap_t *ra1,
const roaring_bitmap_t *ra2);
roaring_bitmap_t *roaring_bitmap_lazy_or(const roaring_bitmap_t *x1,
const roaring_bitmap_t *x2,
const bool bitsetconversion);
void roaring_bitmap_lazy_or_inplace(roaring_bitmap_t *x1,
const roaring_bitmap_t *x2,
const bool bitsetconversion);
void roaring_bitmap_repair_after_lazy(roaring_bitmap_t *x1);
roaring_bitmap_t *roaring_bitmap_lazy_xor(const roaring_bitmap_t *x1,
const roaring_bitmap_t *x2);
void roaring_bitmap_lazy_xor_inplace(roaring_bitmap_t *x1,
const roaring_bitmap_t *x2);
roaring_bitmap_t *roaring_bitmap_flip(const roaring_bitmap_t *x1,
uint64_t range_start, uint64_t range_end);
void roaring_bitmap_flip_inplace(roaring_bitmap_t *x1, uint64_t range_start,
uint64_t range_end);
bool roaring_bitmap_select(const roaring_bitmap_t *ra, uint32_t rank,
uint32_t *element);
uint64_t roaring_bitmap_rank(const roaring_bitmap_t *bm, uint32_t x);
uint32_t roaring_bitmap_minimum(const roaring_bitmap_t *bm);
uint32_t roaring_bitmap_maximum(const roaring_bitmap_t *bm);
void roaring_bitmap_statistics(const roaring_bitmap_t *ra,
roaring_statistics_t *stat);
typedef struct roaring_uint32_iterator_s {
const roaring_bitmap_t *parent; int32_t container_index; int32_t in_container_index; int32_t run_index;
uint32_t current_value;
bool has_value;
const void
*container; uint8_t typecode; uint32_t highbits;
} roaring_uint32_iterator_t;
void roaring_init_iterator(const roaring_bitmap_t *ra,
roaring_uint32_iterator_t *newit);
void roaring_init_iterator_last(const roaring_bitmap_t *ra,
roaring_uint32_iterator_t *newit);
roaring_uint32_iterator_t *roaring_create_iterator(const roaring_bitmap_t *ra);
bool roaring_advance_uint32_iterator(roaring_uint32_iterator_t *it);
bool roaring_previous_uint32_iterator(roaring_uint32_iterator_t *it);
bool roaring_move_uint32_iterator_equalorlarger(roaring_uint32_iterator_t *it, uint32_t val) ;
roaring_uint32_iterator_t *roaring_copy_uint32_iterator(
const roaring_uint32_iterator_t *it);
void roaring_free_uint32_iterator(roaring_uint32_iterator_t *it);
uint32_t roaring_read_uint32_iterator(roaring_uint32_iterator_t *it, uint32_t* buf, uint32_t count);
#ifdef __cplusplus
}
#endif
#endif