コード例 #1
0
/**
 * Compute the union of 'number' bitmaps using a heap. This can
 * sometimes be faster than roaring_bitmap_or_many which uses
 * a naive algorithm. Caller is responsible for freeing the
 * result.
 */
roaring_bitmap_t *roaring_bitmap_or_many_heap(uint32_t number,
		const roaring_bitmap_t **x) {
	if (number == 0) {
		return roaring_bitmap_create();
	}
	if (number == 1) {
		return roaring_bitmap_copy(x[0]);
	}
	roaring_pq_t *pq = create_pq(x, number);
	while (pq->size > 1) {
		roaring_pq_element_t x1 = pq_poll(pq);
		roaring_pq_element_t x2 = pq_poll(pq);

		if (x1.is_temporary && x2.is_temporary) {
                        roaring_bitmap_t *newb =lazy_or_from_lazy_inputs(x1.bitmap,
					x2.bitmap);
			uint64_t bsize = roaring_bitmap_portable_size_in_bytes(newb);
			roaring_pq_element_t newelement = { .size = bsize, .is_temporary =
					true, .bitmap = newb };
			pq_add(pq, &newelement);
		} else if (x2.is_temporary) {
                        roaring_bitmap_lazy_or_inplace(x2.bitmap, x1.bitmap);
			x2.size = roaring_bitmap_portable_size_in_bytes(x2.bitmap);
			pq_add(pq, &x2);
		} else if (x1.is_temporary) {
			roaring_bitmap_lazy_or_inplace(x1.bitmap, x2.bitmap);
			x1.size = roaring_bitmap_portable_size_in_bytes(x1.bitmap);

			pq_add(pq, &x1);
		} else {
		  roaring_bitmap_t *newb = roaring_bitmap_lazy_or(x1.bitmap,
					x2.bitmap);
			uint64_t bsize = roaring_bitmap_portable_size_in_bytes(newb);
			roaring_pq_element_t newelement = { .size = bsize, .is_temporary =
					true, .bitmap = newb };

			pq_add(pq, &newelement);
		}

	}
	roaring_pq_element_t X = pq_poll(pq);
	roaring_bitmap_t *answer = X.bitmap;
	roaring_bitmap_repair_after_lazy(answer);
	pq_free(pq);
	return answer;
}
コード例 #2
0
/**
 * Compute the union of 'number' bitmaps using a heap. This can
 * sometimes be faster than roaring_bitmap_or_many which uses
 * a naive algorithm. Caller is responsible for freeing the
 * result.
 */
roaring_bitmap_t *roaring_bitmap_or_many_heap(uint32_t number,
                                              const roaring_bitmap_t **x) {
    if (number == 0) {
        return roaring_bitmap_create();
    }
    if (number == 1) {
        return roaring_bitmap_copy(x[0]);
    }
    roaring_pq_t *pq = create_pq(x, number);
    while (pq->size > 1) {
        roaring_pq_element_t x1 = pq_poll(pq);
        roaring_pq_element_t x2 = pq_poll(pq);

        if (x1.is_temporary && x2.is_temporary) {
            roaring_bitmap_t *newb =
                lazy_or_from_lazy_inputs(x1.bitmap, x2.bitmap);
            // should normally return a fresh new bitmap *except* that
            // it can return x1.bitmap or x2.bitmap in degenerate cases
            bool temporary = !((newb == x1.bitmap) && (newb == x2.bitmap));
            uint64_t bsize = roaring_bitmap_portable_size_in_bytes(newb);
            roaring_pq_element_t newelement = {
                .size = bsize, .is_temporary = temporary, .bitmap = newb};
            pq_add(pq, &newelement);
        } else if (x2.is_temporary) {