bool array_array_container_union(const array_container_t *src_1,
const array_container_t *src_2, void **dst) {
int totalCardinality = src_1->cardinality + src_2->cardinality;
if (totalCardinality <= DEFAULT_MAX_SIZE) {
*dst = array_container_create_given_capacity(totalCardinality);
if (*dst != NULL)
array_container_union(src_1, src_2, (array_container_t *)*dst);
return false; // not a bitset
}
*dst = bitset_container_create();
bool returnval = true; // expect a bitset
if (*dst != NULL) {
bitset_container_t *ourbitset = (bitset_container_t *)*dst;
bitset_set_list(ourbitset->array, src_1->array, src_1->cardinality);
ourbitset->cardinality =
bitset_set_list_withcard(ourbitset->array, src_1->cardinality,
src_2->array, src_2->cardinality);
if (ourbitset->cardinality <= DEFAULT_MAX_SIZE) {
// need to convert!
*dst = array_container_from_bitset(ourbitset);
bitset_container_free(ourbitset);
returnval = false; // not going to be a bitset
}
}
return returnval;
}
/*
* Same as bitset_container_negation except that if the output is to
* be a
* bitset_container_t, then src is modified and no allocation is made.
* If the output is to be an array_container_t, then caller is responsible
* to free the container.
* In all cases, the result is in *dst.
*/
bool bitset_container_negation_range_inplace(bitset_container_t *src,
const int range_start,
const int range_end, void **dst) {
bitset_flip_range(src->array, (uint32_t)range_start, (uint32_t)range_end);
src->cardinality = bitset_container_compute_cardinality(src);
if (src->cardinality > DEFAULT_MAX_SIZE) {
*dst = src;
return true;
}
*dst = array_container_from_bitset(src);
bitset_container_free(src);
return false;
}
bool bitset_array_container_iandnot(bitset_container_t *src_1,
const array_container_t *src_2,
void **dst) {
*dst = src_1;
src_1->cardinality = bitset_clear_list(src_1->array, src_1->cardinality,
src_2->array, src_2->cardinality);
if (src_1->cardinality <= DEFAULT_MAX_SIZE) {
*dst = array_container_from_bitset(src_1);
bitset_container_free(src_1);
return false; // not bitset
} else
return true;
}
bool run_bitset_container_andnot(const run_container_t *src_1,
const bitset_container_t *src_2, void **dst) {
// follows the Java implementation as of June 2016
int card = run_container_cardinality(src_1);
if (card <= DEFAULT_MAX_SIZE) {
// must be an array
array_container_t *answer = array_container_create_given_capacity(card);
answer->cardinality = 0;
for (int32_t rlepos = 0; rlepos < src_1->n_runs; ++rlepos) {
rle16_t rle = src_1->runs[rlepos];
for (int run_value = rle.value; run_value <= rle.value + rle.length;
++run_value) {
if (!bitset_container_get(src_2, (uint16_t)run_value)) {
answer->array[answer->cardinality++] = (uint16_t)run_value;
}
}
}
*dst = answer;
return false;
} else { // we guess it will be a bitset, though have to check guess when
// done
bitset_container_t *answer = bitset_container_clone(src_2);
uint32_t last_pos = 0;
for (int32_t rlepos = 0; rlepos < src_1->n_runs; ++rlepos) {
rle16_t rle = src_1->runs[rlepos];
uint32_t start = rle.value;
uint32_t end = start + rle.length + 1;
bitset_reset_range(answer->array, last_pos, start);
bitset_flip_range(answer->array, start, end);
last_pos = end;
}
bitset_reset_range(answer->array, last_pos, (uint32_t)(1 << 16));
answer->cardinality = bitset_container_compute_cardinality(answer);
if (answer->cardinality <= DEFAULT_MAX_SIZE) {
*dst = array_container_from_bitset(answer);
bitset_container_free(answer);
return false; // not bitset
}
*dst = answer;
return true; // bitset
}
}
bool bitset_array_container_andnot(const bitset_container_t *src_1,
const array_container_t *src_2, void **dst) {
// Java did this directly, but we have option of asm or avx
bitset_container_t *result = bitset_container_create();
bitset_container_copy(src_1, result);
result->cardinality = bitset_clear_list(result->array, result->cardinality,
src_2->array, src_2->cardinality);
// do required type conversions.
if (result->cardinality <= DEFAULT_MAX_SIZE) {
*dst = array_container_from_bitset(result);
bitset_container_free(result);
return false;
}
*dst = result;
return true;
}
bool bitset_run_container_iandnot(bitset_container_t *src_1,
const run_container_t *src_2, void **dst) {
*dst = src_1;
for (int32_t rlepos = 0; rlepos < src_2->n_runs; ++rlepos) {
rle16_t rle = src_2->runs[rlepos];
bitset_reset_range(src_1->array, rle.value,
rle.value + rle.length + UINT32_C(1));
}
src_1->cardinality = bitset_container_compute_cardinality(src_1);
if (src_1->cardinality <= DEFAULT_MAX_SIZE) {
*dst = array_container_from_bitset(src_1);
bitset_container_free(src_1);
return false; // not bitset
} else
return true;
}
bool bitset_run_container_andnot(const bitset_container_t *src_1,
const run_container_t *src_2, void **dst) {
// follows Java implementation
bitset_container_t *result = bitset_container_create();
bitset_container_copy(src_1, result);
for (int32_t rlepos = 0; rlepos < src_2->n_runs; ++rlepos) {
rle16_t rle = src_2->runs[rlepos];
bitset_reset_range(result->array, rle.value,
rle.value + rle.length + UINT32_C(1));
}
result->cardinality = bitset_container_compute_cardinality(result);
if (result->cardinality <= DEFAULT_MAX_SIZE) {
*dst = array_container_from_bitset(result);
bitset_container_free(result);
return false; // not bitset
}
*dst = result;
return true; // bitset
}
/* Negation across a range of the container
* Compute the negation of src and write the result
* to *dst. A true return value indicates a bitset result,
* otherwise the result is an array container.
* We assume that dst is not pre-allocated. In
* case of failure, *dst will be NULL.
*/
bool bitset_container_negation_range(const bitset_container_t *src,
const int range_start, const int range_end,
void **dst) {
// TODO maybe consider density-based estimate
// and sometimes build result directly as array, with
// conversion back to bitset if wrong. Or determine
// actual result cardinality, then go directly for the known final cont.
// keep computation using bitsets as long as possible.
bitset_container_t *t = bitset_container_clone(src);
bitset_flip_range(t->array, (uint32_t)range_start, (uint32_t)range_end);
t->cardinality = bitset_container_compute_cardinality(t);
if (t->cardinality > DEFAULT_MAX_SIZE) {
*dst = t;
return true;
} else {
*dst = array_container_from_bitset(t);
bitset_container_free(t);
return false;
}
}
/* Compute the intersection of src_1 and src_2 and write the result to
* *dst. If the result is true then the result is a bitset_container_t
* otherwise is a array_container_t. */
bool run_bitset_container_intersection(const run_container_t *src_1,
const bitset_container_t *src_2,
void **dst) {
int32_t card = run_container_cardinality(src_1);
if (card <= DEFAULT_MAX_SIZE) {
// result can only be an array (assuming that we never make a
// RunContainer)
if (card > src_2->cardinality) {
card = src_2->cardinality;
}
array_container_t *answer = array_container_create_given_capacity(card);
*dst = answer;
if (*dst == NULL) {
return false;
}
for (int32_t rlepos = 0; rlepos < src_1->n_runs; ++rlepos) {
rle16_t rle = src_1->runs[rlepos];
uint32_t endofrun = (uint32_t)rle.value + rle.length;
for (uint32_t runValue = rle.value; runValue <= endofrun;
++runValue) {
if (bitset_container_contains(src_2, runValue)) {
answer->array[answer->cardinality++] = (uint16_t)runValue;
}
}
}
return false;
}
if (*dst == src_2) { // we attempt in-place
bitset_container_t *answer = (bitset_container_t *)*dst;
uint32_t start = 0;
for (int32_t rlepos = 0; rlepos < src_1->n_runs; ++rlepos) {
const rle16_t rle = src_1->runs[rlepos];
uint32_t end = rle.value;
bitset_reset_range(src_2->array, start, end);
start = end + rle.length + 1;
}
bitset_reset_range(src_2->array, start, UINT32_C(1) << 16);
answer->cardinality = bitset_container_compute_cardinality(answer);
if (src_2->cardinality > DEFAULT_MAX_SIZE) {
return true;
} else {
array_container_t *newanswer = array_container_from_bitset(src_2);
if (newanswer == NULL) {
*dst = NULL;
return false;
}
*dst = newanswer;
return false;
}
} else { // no inplace
// we expect the answer to be a bitmap (if we are lucky)
bitset_container_t *answer = bitset_container_clone(src_2);
*dst = answer;
if (answer == NULL) {
return true;
}
uint32_t start = 0;
for (int32_t rlepos = 0; rlepos < src_1->n_runs; ++rlepos) {
const rle16_t rle = src_1->runs[rlepos];
uint32_t end = rle.value;
bitset_reset_range(answer->array, start, end);
start = end + rle.length + 1;
}
bitset_reset_range(answer->array, start, UINT32_C(1) << 16);
answer->cardinality = bitset_container_compute_cardinality(answer);
if (answer->cardinality > DEFAULT_MAX_SIZE) {
return true;
} else {
array_container_t *newanswer = array_container_from_bitset(answer);
bitset_container_free(*dst);
if (newanswer == NULL) {
*dst = NULL;
return false;
}
*dst = newanswer;
return false;
}
}
}
// used to benchmark array_container_from_bitset
int get_cardinality_through_conversion_to_array(bitset_container_t* B) {
array_container_t* conv = array_container_from_bitset(B);
int card = conv->cardinality;
array_container_free(conv);
return card;
}
