bool serialize_correctly(roaring_bitmap_t *r) { uint32_t expectedsize = roaring_bitmap_portable_size_in_bytes(r); char *serialized = malloc(expectedsize); if (serialized == NULL) { printf("failure to allocate memory!\n"); return false; } uint32_t serialize_len = roaring_bitmap_portable_serialize(r, serialized); if (serialize_len != expectedsize) { printf("Bad serialized size!\n"); free(serialized); return false; } roaring_bitmap_t *r2 = roaring_bitmap_portable_deserialize(serialized); free(serialized); if (!roaring_bitmap_equals(r, r2)) { printf("Won't recover original bitmap!\n"); roaring_bitmap_free(r2); return false; } if (!roaring_bitmap_equals(r2, r)) { printf("Won't recover original bitmap!\n"); roaring_bitmap_free(r2); return false; } roaring_bitmap_free(r2); return true; }
bool compare_andnots(roaring_bitmap_t **rnorun, roaring_bitmap_t **rruns, size_t count) { roaring_bitmap_t *tempornorun; roaring_bitmap_t *temporruns; for (size_t i = 0; i + 1 < count; ++i) { tempornorun = roaring_bitmap_andnot(rnorun[i], rnorun[i + 1]); if (!is_andnot_correct(rnorun[i], rnorun[i + 1])) { printf("no-run andnot incorrect\n"); return false; } temporruns = roaring_bitmap_andnot(rruns[i], rruns[i + 1]); if (!is_andnot_correct(rruns[i], rruns[i + 1])) { printf("runs andnots incorrect\n"); return false; } if (!slow_bitmap_equals(tempornorun, temporruns)) { printf("Andnots don't agree! (slow) \n"); return false; } if (!roaring_bitmap_equals(tempornorun, temporruns)) { printf("Andnots don't agree!\n"); printf("\n\nbitmap1:\n"); show_structure(tempornorun->high_low_container); // debug printf("\n\nbitmap2:\n"); show_structure(temporruns->high_low_container); // debug return false; } roaring_bitmap_free(tempornorun); roaring_bitmap_free(temporruns); tempornorun = inplace_andnot(rnorun[i], rnorun[i + 1]); if (!is_andnot_correct(rnorun[i], rnorun[i + 1])) { printf("[inplace] no-run andnot incorrect\n"); return false; } temporruns = inplace_andnot(rruns[i], rruns[i + 1]); if (!is_andnot_correct(rruns[i], rruns[i + 1])) { printf("[inplace] runs andnots incorrect\n"); return false; } if (!slow_bitmap_equals(tempornorun, temporruns)) { printf("[inplace] Andnots don't agree! (slow) \n"); return false; } if (!roaring_bitmap_equals(tempornorun, temporruns)) { printf("[inplace] Andnots don't agree!\n"); printf("\n\nbitmap1:\n"); show_structure(tempornorun->high_low_container); // debug printf("\n\nbitmap2:\n"); show_structure(temporruns->high_low_container); // debug return false; } roaring_bitmap_free(tempornorun); roaring_bitmap_free(temporruns); } return true; }
bool is_negation_correct(roaring_bitmap_t *bitmap) { roaring_statistics_t stats; bool answer = true; roaring_bitmap_statistics(bitmap, &stats); unsigned universe_size = stats.max_value + 1; roaring_bitmap_t *inverted = roaring_bitmap_flip(bitmap, 0U, universe_size); roaring_bitmap_t *double_inverted = roaring_bitmap_flip(inverted, 0U, universe_size); answer = (roaring_bitmap_get_cardinality(inverted) + roaring_bitmap_get_cardinality(bitmap) == universe_size); if (answer) answer = roaring_bitmap_equals(bitmap, double_inverted); if (!answer) { printf("Bad flip\n\nbitmap1:\n"); show_structure(bitmap->high_low_container); // debug printf("\n\nflipped:\n"); show_structure(inverted->high_low_container); // debug } roaring_bitmap_free(double_inverted); roaring_bitmap_free(inverted); return answer; }
bool compare_wide_xors(roaring_bitmap_t **rnorun, roaring_bitmap_t **rruns, size_t count) { roaring_bitmap_t *tempornorun = roaring_bitmap_xor_many(count, (const roaring_bitmap_t **)rnorun); roaring_bitmap_t *temporruns = roaring_bitmap_xor_many(count, (const roaring_bitmap_t **)rruns); if (!slow_bitmap_equals(tempornorun, temporruns)) { printf("[compare_wide_xors] Xors don't agree! (fast run-norun) \n"); return false; } assert(roaring_bitmap_equals(tempornorun, temporruns)); roaring_bitmap_t *longtempornorun; roaring_bitmap_t *longtemporruns; if (count == 1) { longtempornorun = rnorun[0]; longtemporruns = rruns[0]; } else { assert(roaring_bitmap_equals(rnorun[0], rruns[0])); assert(roaring_bitmap_equals(rnorun[1], rruns[1])); longtempornorun = roaring_bitmap_xor(rnorun[0], rnorun[1]); longtemporruns = roaring_bitmap_xor(rruns[0], rruns[1]); assert(roaring_bitmap_equals(longtempornorun, longtemporruns)); for (int i = 2; i < (int)count; ++i) { assert(roaring_bitmap_equals(rnorun[i], rruns[i])); assert(roaring_bitmap_equals(longtempornorun, longtemporruns)); roaring_bitmap_t *t1 = roaring_bitmap_xor(rnorun[i], longtempornorun); roaring_bitmap_t *t2 = roaring_bitmap_xor(rruns[i], longtemporruns); assert(roaring_bitmap_equals(t1, t2)); roaring_bitmap_free(longtempornorun); longtempornorun = t1; roaring_bitmap_free(longtemporruns); longtemporruns = t2; assert(roaring_bitmap_equals(longtempornorun, longtemporruns)); } } if (!slow_bitmap_equals(longtempornorun, tempornorun)) { printf("[compare_wide_xors] Xors don't agree! (regular) \n"); return false; } if (!slow_bitmap_equals(temporruns, longtemporruns)) { printf("[compare_wide_xors] Xors don't agree! (runs) \n"); return false; } roaring_bitmap_free(tempornorun); roaring_bitmap_free(temporruns); roaring_bitmap_free(longtempornorun); roaring_bitmap_free(longtemporruns); return true; }
bool is_xor_correct(roaring_bitmap_t *bitmap1, roaring_bitmap_t *bitmap2) { roaring_bitmap_t *temp = roaring_bitmap_xor(bitmap1, bitmap2); roaring_bitmap_t *expected = synthesized_xor(bitmap1, bitmap2); bool answer = roaring_bitmap_equals(temp, expected); if (!answer) { printf("Bad XOR\n\nbitmap1:\n"); show_structure(bitmap1->high_low_container); // debug printf("\n\nbitmap2:\n"); show_structure(bitmap2->high_low_container); // debug printf("\n\nresult:\n"); show_structure(temp->high_low_container); // debug printf("\n\ncorrect result:\n"); show_structure(expected->high_low_container); // debug } roaring_bitmap_free(temp); roaring_bitmap_free(expected); return answer; }
bool is_andnot_correct(roaring_bitmap_t *bitmap1, roaring_bitmap_t *bitmap2) { roaring_bitmap_t *temp = roaring_bitmap_andnot(bitmap1, bitmap2); roaring_bitmap_t *expected = synthesized_andnot(bitmap1, bitmap2); bool answer = roaring_bitmap_equals(temp, expected); if (!answer) { printf("Bad ANDNOT\n\nbitmap1:\n"); show_structure(bitmap1->high_low_container); // debug // print_container(3, bitmap1); printf("\n\nbitmap2:\n"); show_structure(bitmap2->high_low_container); // debug printf("\n\nresult:\n"); show_structure(temp->high_low_container); // debug printf("\n\ncorrect result:\n"); show_structure(expected->high_low_container); // debug printf("difference is "); roaring_bitmap_printf(roaring_bitmap_xor(temp, expected)); } roaring_bitmap_free(temp); roaring_bitmap_free(expected); return answer; }
void test_example(bool copy_on_write) { // create a new empty bitmap roaring_bitmap_t *r1 = roaring_bitmap_create(); r1->copy_on_write = copy_on_write; assert_ptr_not_equal(r1, NULL); // then we can add values for (uint32_t i = 100; i < 1000; i++) { roaring_bitmap_add(r1, i); } // check whether a value is contained assert_true(roaring_bitmap_contains(r1, 500)); // compute how many bits there are: uint32_t cardinality = roaring_bitmap_get_cardinality(r1); printf("Cardinality = %d \n", cardinality); assert_int_equal(900, cardinality); // if your bitmaps have long runs, you can compress them by calling // run_optimize uint32_t size = roaring_bitmap_portable_size_in_bytes(r1); roaring_bitmap_run_optimize(r1); uint32_t compact_size = roaring_bitmap_portable_size_in_bytes(r1); printf("size before run optimize %d bytes, and after %d bytes\n", size, compact_size); // create a new bitmap with varargs roaring_bitmap_t *r2 = roaring_bitmap_of(5, 1, 2, 3, 5, 6); assert_ptr_not_equal(r2, NULL); roaring_bitmap_printf(r2); printf("\n"); // we can also create a bitmap from a pointer to 32-bit integers const uint32_t values[] = {2, 3, 4}; roaring_bitmap_t *r3 = roaring_bitmap_of_ptr(3, values); r3->copy_on_write = copy_on_write; // we can also go in reverse and go from arrays to bitmaps uint64_t card1 = roaring_bitmap_get_cardinality(r1); uint32_t *arr1 = new uint32_t[card1]; assert_ptr_not_equal(arr1, NULL); roaring_bitmap_to_uint32_array(r1, arr1); roaring_bitmap_t *r1f = roaring_bitmap_of_ptr(card1, arr1); delete[] arr1; assert_ptr_not_equal(r1f, NULL); // bitmaps shall be equal assert_true(roaring_bitmap_equals(r1, r1f)); roaring_bitmap_free(r1f); // we can copy and compare bitmaps roaring_bitmap_t *z = roaring_bitmap_copy(r3); z->copy_on_write = copy_on_write; assert_true(roaring_bitmap_equals(r3, z)); roaring_bitmap_free(z); // we can compute union two-by-two roaring_bitmap_t *r1_2_3 = roaring_bitmap_or(r1, r2); r1_2_3->copy_on_write = copy_on_write; roaring_bitmap_or_inplace(r1_2_3, r3); // we can compute a big union const roaring_bitmap_t *allmybitmaps[] = {r1, r2, r3}; roaring_bitmap_t *bigunion = roaring_bitmap_or_many(3, allmybitmaps); assert_true(roaring_bitmap_equals(r1_2_3, bigunion)); roaring_bitmap_t *bigunionheap = roaring_bitmap_or_many_heap(3, allmybitmaps); assert_true(roaring_bitmap_equals(r1_2_3, bigunionheap)); roaring_bitmap_free(r1_2_3); roaring_bitmap_free(bigunion); roaring_bitmap_free(bigunionheap); // we can compute intersection two-by-two roaring_bitmap_t *i1_2 = roaring_bitmap_and(r1, r2); roaring_bitmap_free(i1_2); // we can write a bitmap to a pointer and recover it later uint32_t expectedsize = roaring_bitmap_portable_size_in_bytes(r1); char *serializedbytes = (char *)malloc(expectedsize); roaring_bitmap_portable_serialize(r1, serializedbytes); roaring_bitmap_t *t = roaring_bitmap_portable_deserialize(serializedbytes); assert_true(expectedsize == roaring_bitmap_portable_size_in_bytes(t)); assert_true(roaring_bitmap_equals(r1, t)); roaring_bitmap_free(t); free(serializedbytes); // we can iterate over all values using custom functions uint32_t counter = 0; roaring_iterate(r1, roaring_iterator_sumall, &counter); /** * void roaring_iterator_sumall(uint32_t value, void *param) { * *(uint32_t *) param += value; * } * */ roaring_bitmap_free(r1); roaring_bitmap_free(r2); roaring_bitmap_free(r3); }