[][src]Crate croaring_sys

Structs

_G_fpos64_t
_G_fpos_t
_IO_FILE
_IO_FILE_plus
_IO_cookie_file
_IO_cookie_io_functions_t
_IO_jump_t
_IO_marker
__fsid_t
__locale_data
__locale_struct
__mbstate_t
__pthread_internal_list
__sigset_t
__va_list_tag
array_container_s
bitset_container_s
div_t
drand48_data
fd_set
ldiv_t
lldiv_t
mallinfo
obstack
pthread_cond_t__bindgen_ty_1
pthread_mutex_t___pthread_mutex_s
pthread_rwlock_t__bindgen_ty_1
random_data
rle16_s
roaring_array_s

Roaring arrays are array-based key-value pairs having containers as values and 16-bit integer keys. A roaring bitmap might be implemented as such.

roaring_bitmap_s
roaring_statistics_s

(For advanced users.) The roaring_statistics_t can be used to collect detailed statistics about the composition of a roaring bitmap.

roaring_uint32_iterator_s

What follows is code use to iterate through values in a roaring bitmap

run_container_s
shared_container_s

A shared container is a wrapper around a container with reference counting.

timespec
timeval

Constants

ARRAY_CONTAINER_TYPE_CODE
ARRAY_DEFAULT_INIT_SIZE
ARRAY_LAZY_LOWERBOUND
BIG_ENDIAN
BITSET_CONTAINER_SIZE_IN_WORDS
BITSET_CONTAINER_TYPE_CODE
BITSET_UNKNOWN_CARDINALITY
BUFSIZ
BYTE_ORDER
DEFAULT_MAX_SIZE
EOF
EXIT_FAILURE
EXIT_SUCCESS
FD_SETSIZE
FILENAME_MAX
FOPEN_MAX
INT8_MIN
INT8_MAX
INT16_MIN
INT16_MAX
INT32_MIN
INT32_MAX
INTPTR_MAX
INTPTR_MIN
INT_FAST8_MIN
INT_FAST8_MAX
INT_FAST16_MIN
INT_FAST16_MAX
INT_FAST32_MIN
INT_FAST32_MAX
INT_LEAST8_MIN
INT_LEAST8_MAX
INT_LEAST16_MIN
INT_LEAST16_MAX
INT_LEAST32_MIN
INT_LEAST32_MAX
LAZY_OR_BITSET_CONVERSION
LAZY_OR_BITSET_CONVERSION_TO_FULL
LITTLE_ENDIAN
L_ctermid
L_cuserid
L_tmpnam
MAX_CONTAINERS
M_ARENA_MAX
M_ARENA_TEST
M_CHECK_ACTION
M_GRAIN
M_KEEP
M_MMAP_MAX
M_MMAP_THRESHOLD
M_MXFAST
M_NLBLKS
M_PERTURB
M_TOP_PAD
M_TRIM_THRESHOLD
NO_OFFSET_THRESHOLD
OR_BITSET_CONVERSION_TO_FULL
PDP_ENDIAN
PTRDIFF_MAX
PTRDIFF_MIN
P_tmpdir
RAND_MAX
ROARING_VERSION_MAJOR
ROARING_VERSION_MINOR
ROARING_VERSION_REVISION
RUN_CONTAINER_TYPE_CODE
RUN_DEFAULT_INIT_SIZE
SEEK_CUR
SEEK_DATA
SEEK_END
SEEK_HOLE
SEEK_SET
SERIALIZATION_ARRAY_UINT32
SERIALIZATION_CONTAINER
SERIAL_COOKIE
SERIAL_COOKIE_NO_RUNCONTAINER
SHARED_CONTAINER_TYPE_CODE
SIG_ATOMIC_MAX
SIG_ATOMIC_MIN
SIZE_MAX
TMP_MAX
UINT8_MAX
UINT16_MAX
UINT32_MAX
UINTPTR_MAX
UINT_FAST8_MAX
UINT_FAST16_MAX
UINT_FAST32_MAX
UINT_LEAST8_MAX
UINT_LEAST16_MAX
UINT_LEAST32_MAX
WCONTINUED
WEXITED
WINT_MAX
WINT_MIN
WNOHANG
WNOWAIT
WSTOPPED
WUNTRACED
_ALLOCA_H
_ASSERT_H
_ATFILE_SOURCE
_BITS_BYTESWAP_H
_BITS_PTHREADTYPES_H
_BITS_TYPESIZES_H
_BITS_TYPES_H
_BITS_WCHAR_H
_CMP_EQ_OQ
_CMP_EQ_OS
_CMP_EQ_UQ
_CMP_EQ_US
_CMP_FALSE_OQ
_CMP_FALSE_OS
_CMP_GE_OQ
_CMP_GE_OS
_CMP_GT_OQ
_CMP_GT_OS
_CMP_LE_OQ
_CMP_LE_OS
_CMP_LT_OQ
_CMP_LT_OS
_CMP_NEQ_OQ
_CMP_NEQ_OS
_CMP_NEQ_UQ
_CMP_NEQ_US
_CMP_NGE_UQ
_CMP_NGE_US
_CMP_NGT_UQ
_CMP_NGT_US
_CMP_NLE_UQ
_CMP_NLE_US
_CMP_NLT_UQ
_CMP_NLT_US
_CMP_ORD_Q
_CMP_ORD_S
_CMP_TRUE_UQ
_CMP_TRUE_US
_CMP_UNORD_Q
_CMP_UNORD_S
_DEFAULT_SOURCE
_ENDIAN_H
_FEATURES_H
_G_BUFSIZ
_G_HAVE_MMAP
_G_HAVE_MREMAP
_G_IO_IO_FILE_VERSION
_G_config_h
_IOFBF
_IOLBF
_IONBF
_IOS_APPEND
_IOS_ATEND
_IOS_BIN
_IOS_INPUT
_IOS_NOCREATE
_IOS_NOREPLACE
_IOS_OUTPUT
_IOS_TRUNC
_IO_BAD_SEEN
_IO_BOOLALPHA
_IO_BUFSIZ
_IO_CURRENTLY_PUTTING
_IO_DEC
_IO_DELETE_DONT_CLOSE
_IO_DONT_CLOSE
_IO_EOF_SEEN
_IO_ERR_SEEN
_IO_FIXED
_IO_FLAGS2_MMAP
_IO_FLAGS2_NOTCANCEL
_IO_FLAGS2_USER_WBUF
_IO_HEX
_IO_INTERNAL
_IO_IN_BACKUP
_IO_IS_APPENDING
_IO_IS_FILEBUF
_IO_LEFT
_IO_LINE_BUF
_IO_LINKED
_IO_MAGIC
_IO_MAGIC_MASK
_IO_NO_READS
_IO_NO_WRITES
_IO_OCT
_IO_RIGHT
_IO_SCIENTIFIC
_IO_SHOWBASE
_IO_SHOWPOINT
_IO_SHOWPOS
_IO_SKIPWS
_IO_STDIO
_IO_TIED_PUT_GET
_IO_UNBUFFERED
_IO_UNIFIED_JUMPTABLES
_IO_UNITBUF
_IO_UPPERCASE
_IO_USER_BUF
_IO_USER_LOCK
_ISOC11_SOURCE
_ISOC95_SOURCE
_ISOC99_SOURCE
_LARGEFILE64_SOURCE
_LARGEFILE_SOURCE
_MALLOC_H
_MM_DENORMALS_ZERO_MASK
_MM_DENORMALS_ZERO_OFF
_MM_DENORMALS_ZERO_ON
_MM_EXCEPT_DENORM
_MM_EXCEPT_DIV_ZERO
_MM_EXCEPT_INEXACT
_MM_EXCEPT_INVALID
_MM_EXCEPT_MASK
_MM_EXCEPT_OVERFLOW
_MM_EXCEPT_UNDERFLOW
_MM_FLUSH_ZERO_MASK
_MM_FLUSH_ZERO_OFF
_MM_FLUSH_ZERO_ON
_MM_FROUND_CEIL
_MM_FROUND_CUR_DIRECTION
_MM_FROUND_FLOOR
_MM_FROUND_NEARBYINT
_MM_FROUND_NINT
_MM_FROUND_NO_EXC
_MM_FROUND_RAISE_EXC
_MM_FROUND_RINT
_MM_FROUND_TO_NEAREST_INT
_MM_FROUND_TO_NEG_INF
_MM_FROUND_TO_POS_INF
_MM_FROUND_TO_ZERO
_MM_FROUND_TRUNC
_MM_HINT_NTA
_MM_HINT_T0
_MM_HINT_T1
_MM_HINT_T2
_MM_MASK_DENORM
_MM_MASK_DIV_ZERO
_MM_MASK_INEXACT
_MM_MASK_INVALID
_MM_MASK_MASK
_MM_MASK_OVERFLOW
_MM_MASK_UNDERFLOW
_MM_PCOMCTRL_EQ
_MM_PCOMCTRL_FALSE
_MM_PCOMCTRL_GE
_MM_PCOMCTRL_GT
_MM_PCOMCTRL_LE
_MM_PCOMCTRL_LT
_MM_PCOMCTRL_NEQ
_MM_PCOMCTRL_TRUE
_MM_ROUND_DOWN
_MM_ROUND_MASK
_MM_ROUND_NEAREST
_MM_ROUND_TOWARD_ZERO
_MM_ROUND_UP
_OLD_STDIO_MAGIC
_POSIX_C_SOURCE
_POSIX_SOURCE
_SIDD_BIT_MASK
_SIDD_CMP_EQUAL_ANY
_SIDD_CMP_EQUAL_EACH
_SIDD_CMP_EQUAL_ORDERED
_SIDD_CMP_RANGES
_SIDD_LEAST_SIGNIFICANT
_SIDD_MASKED_NEGATIVE_POLARITY
_SIDD_MASKED_POSITIVE_POLARITY
_SIDD_MOST_SIGNIFICANT
_SIDD_NEGATIVE_POLARITY
_SIDD_POSITIVE_POLARITY
_SIDD_SBYTE_OPS
_SIDD_SWORD_OPS
_SIDD_UBYTE_OPS
_SIDD_UNIT_MASK
_SIDD_UWORD_OPS
_SIGSET_H_types
_STDC_PREDEF_H
_STDINT_H
_STDIO_H
_STDLIB_H
_STRING_H
_STRUCT_TIMEVAL
_SYS_CDEFS_H
_SYS_SELECT_H
_SYS_SYSMACROS_H
_SYS_TYPES_H
_XABORT_CAPACITY
_XABORT_CONFLICT
_XABORT_DEBUG
_XABORT_EXPLICIT
_XABORT_NESTED
_XABORT_RETRY
_XBEGIN_STARTED
_XLOCALE_H
_XOPEN_SOURCE
_XOPEN_SOURCE_EXTENDED
__BIG_ENDIAN
__BIT_TYPES_DEFINED__
__BYTE_ORDER
__ENUM_IDTYPE_T
__FD_SETSIZE
__FD_ZERO_STOS
__FILE_defined
__FLOAT_WORD_ORDER
__GLIBC_MINOR__
__GLIBC__
__GNUC_VA_LIST
__GNU_LIBRARY__
__INO_T_MATCHES_INO64_T
__LITTLE_ENDIAN
__OFF_T_MATCHES_OFF64_T
__PDP_ENDIAN
__PTHREAD_MUTEX_HAVE_PREV
__PTHREAD_RWLOCK_INT_FLAGS_SHARED
__SIZEOF_PTHREAD_ATTR_T
__SIZEOF_PTHREAD_BARRIERATTR_T
__SIZEOF_PTHREAD_BARRIER_T
__SIZEOF_PTHREAD_CONDATTR_T
__SIZEOF_PTHREAD_COND_T
__SIZEOF_PTHREAD_MUTEXATTR_T
__SIZEOF_PTHREAD_MUTEX_T
__SIZEOF_PTHREAD_RWLOCKATTR_T
__SIZEOF_PTHREAD_RWLOCK_T
__STDC_FORMAT_MACROS
__STDC_IEC_559__
__STDC_IEC_559_COMPLEX__
__STDC_ISO_10646__
__STDC_NO_THREADS__
__SYSCALL_WORDSIZE
__USE_ATFILE
__USE_FORTIFY_LEVEL
__USE_GNU
__USE_ISOC11
__USE_ISOC95
__USE_ISOC99
__USE_LARGEFILE
__USE_LARGEFILE64
__USE_MISC
__USE_POSIX
__USE_POSIX2
__USE_POSIX199309
__USE_POSIX199506
__USE_UNIX98
__USE_XOPEN
__USE_XOPEN2K
__USE_XOPEN2KXSI
__USE_XOPEN2K8
__USE_XOPEN2K8XSI
__USE_XOPEN_EXTENDED
__WALL
__WCLONE
__WCOREFLAG
__WNOTHREAD
__WORDSIZE
__WORDSIZE_TIME64_COMPAT32
__W_CONTINUED
____FILE_defined
____mbstate_t_defined
__bool_true_false_are_defined
__clock_t_defined
__clockid_t_defined
__codecvt_result___codecvt_error
__codecvt_result___codecvt_noconv
__codecvt_result___codecvt_ok
__codecvt_result___codecvt_partial
__have_pthread_attr_t
__ldiv_t_defined
__lldiv_t_defined
__time_t_defined
__timer_t_defined
__timespec_defined
false_
idtype_t_P_ALL
idtype_t_P_PGID
idtype_t_P_PID
true_

Statics

_IO_2_1_stdin_
_IO_2_1_stdout_
_IO_2_1_stderr_
__after_morecore_hook
__free_hook
__malloc_hook
__memalign_hook
__morecore
__realloc_hook
_sys_errlist
_sys_nerr
container_names
shared_container_names
stderr
stdin
stdout
sys_errlist
sys_nerr

Functions

_Exit
_IO_cookie_init
_IO_feof
_IO_ferror
_IO_flockfile
_IO_free_backup_area
_IO_ftrylockfile
_IO_funlockfile
_IO_getc
_IO_padn
_IO_peekc_locked
_IO_putc
_IO_seekoff
_IO_seekpos
_IO_sgetn
_IO_vfprintf
_IO_vfscanf
__asprintf
__assert
__assert_fail
__assert_perror_fail
__bzero
__ctype_get_mb_cur_max
__default_morecore
__getdelim
__malloc_check_init
__mempcpy
__overflow
__stpcpy
__stpncpy
__strtok_r
__uflow
__underflow
a64l
abort
abs
aligned_alloc
alloca
array_array_container_andnot
array_array_container_iandnot
array_array_container_inplace_union
array_array_container_ixor
array_array_container_lazy_inplace_union
array_array_container_lazy_union
array_array_container_lazy_xor
array_array_container_union
array_array_container_xor
array_bitset_container_andnot
array_bitset_container_iandnot
array_bitset_container_intersect
array_bitset_container_intersection
array_bitset_container_intersection_cardinality
array_bitset_container_ixor
array_bitset_container_lazy_union
array_bitset_container_lazy_xor
array_bitset_container_union
array_bitset_container_xor
array_container_add_from_range
array_container_andnot
array_container_clone
array_container_contains
array_container_copy
array_container_create
array_container_create_given_capacity
array_container_create_range
array_container_deserialize
array_container_equal_bitset

Return true if the two containers have the same content.

array_container_equals

Return true if the two arrays have the same content.

array_container_free
array_container_from_bitset
array_container_from_run
array_container_grow

Increase capacity to at least min. Whether the existing data needs to be copied over depends on the "preserve" parameter. If preserve is false, then the new content will be uninitialized, otherwise the old content is copied.

array_container_index_equalorlarger
array_container_intersect
array_container_intersection
array_container_intersection_cardinality
array_container_intersection_inplace
array_container_is_subset

Return true if container1 is a subset of container2.

array_container_is_subset_bitset

Return true if container1 is a subset of container2.

array_container_is_subset_run

Return true if container1 is a subset of container2.

array_container_iterate
array_container_iterate64
array_container_maximum
array_container_minimum
array_container_negation
array_container_negation_range
array_container_negation_range_inplace
array_container_number_of_runs
array_container_printf
array_container_printf_as_uint32_array
array_container_rank
array_container_read

Reads the instance from buf, outputs how many bytes were read. This is meant to be byte-by-byte compatible with the Java and Go versions of Roaring. The number of bytes read should be array_container_size_in_bytes(container). You need to provide the (known) cardinality.

array_container_serialization_len
array_container_serialize
array_container_shrink_to_fit
array_container_to_uint32_array
array_container_union
array_container_write

Writes the underlying array to buf, outputs how many bytes were written. This is meant to be byte-by-byte compatible with the Java and Go versions of Roaring. The number of bytes written should be array_container_size_in_bytes(container).

array_container_xor
array_run_container_andnot
array_run_container_iandnot
array_run_container_inplace_union
array_run_container_intersect
array_run_container_intersection
array_run_container_intersection_cardinality
array_run_container_ixor
array_run_container_lazy_xor
array_run_container_union
array_run_container_xor
asprintf
at_quick_exit
atexit
atof
atoi
atol
atoll
basename
bcmp
bcopy
binarySearch
bitset_array_container_andnot
bitset_array_container_iandnot
bitset_array_container_ixor
bitset_bitset_container_andnot
bitset_bitset_container_iandnot
bitset_bitset_container_intersection
bitset_bitset_container_intersection_inplace
bitset_bitset_container_ixor
bitset_bitset_container_xor
bitset_clear_list
bitset_container_add_from_range
bitset_container_and
bitset_container_and_justcard
bitset_container_and_nocard
bitset_container_andnot
bitset_container_andnot_justcard
bitset_container_andnot_nocard
bitset_container_clear
bitset_container_clone
bitset_container_compute_cardinality
bitset_container_contains
bitset_container_copy
bitset_container_create
bitset_container_deserialize
bitset_container_equals

Return true if the two containers have the same content.

bitset_container_free
bitset_container_from_array
bitset_container_from_run
bitset_container_from_run_range

Create new bitset container which is a union of run container and range [min, max]. Caller is responsible for freeing run container.

bitset_container_get
bitset_container_index_equalorlarger
bitset_container_intersect
bitset_container_intersection
bitset_container_intersection_justcard
bitset_container_is_subset

Return true if container1 is a subset of container2.

bitset_container_is_subset_run

Return true if container1 is a subset of container2.

bitset_container_iterate
bitset_container_iterate64
bitset_container_maximum
bitset_container_minimum
bitset_container_negation
bitset_container_negation_inplace
bitset_container_negation_range
bitset_container_negation_range_inplace
bitset_container_number_of_runs

Return the the number of runs.

bitset_container_or
bitset_container_or_justcard
bitset_container_or_nocard
bitset_container_printf
bitset_container_printf_as_uint32_array
bitset_container_rank
bitset_container_read

Reads the instance from buf, outputs how many bytes were read. This is meant to be byte-by-byte compatible with the Java and Go versions of Roaring. The number of bytes read should be bitset_container_size_in_bytes(container). You need to provide the (known) cardinality.

bitset_container_select

If the element of given rank is in this container, supposing that the first element has rank start_rank, then the function returns true and sets element accordingly. Otherwise, it returns false and update start_rank.

bitset_container_serialization_len
bitset_container_serialize
bitset_container_set_all
bitset_container_set_range
bitset_container_to_uint32_array
bitset_container_union
bitset_container_union_justcard
bitset_container_write

Writes the underlying array to buf, outputs how many bytes were written. This is meant to be byte-by-byte compatible with the Java and Go versions of Roaring. The number of bytes written should be bitset_container_size_in_bytes(container).

bitset_container_xor
bitset_container_xor_justcard
bitset_container_xor_nocard
bitset_extract_intersection_setbits_uint16
bitset_extract_setbits
bitset_extract_setbits_avx2
bitset_extract_setbits_sse_uint16
bitset_extract_setbits_uint16
bitset_flip_list
bitset_flip_list_withcard
bitset_run_container_andnot
bitset_run_container_iandnot
bitset_run_container_ixor
bitset_set_list
bitset_set_list_withcard
bsearch
bzero
calloc
canonicalize_file_name
cfree
clearenv
clearerr
clearerr_unlocked
container_clone

Copies a container, requires a typecode. This allocates new memory, caller is responsible for deallocation. If the container is not shared, then it is physically cloned. Sharable containers are not cloneable.

container_contains

Check whether a value is in a container, requires a typecode

container_deserialize
container_free

Recover memory from a container, requires a typecode

container_mutable_unwrap_shared
container_printf

print the container (useful for debugging), requires a typecode

container_printf_as_uint32_array

print the content of the container as a comma-separated list of 32-bit values starting at base, requires a typecode

container_serialization_len
container_serialize
container_unwrap_shared
convert_run_optimize
convert_run_to_efficient_container
convert_run_to_efficient_container_and_free
convert_to_bitset_or_array_container
ctermid
cuserid
difference_uint16

Generic difference function (ANDNOT).

difference_vector16

A fast SSE-based difference function.

div
dprintf
drand48
drand48_r
ecvt
ecvt_r
erand48
erand48_r
exit
extend_array

If needed, increase the capacity of the array so that it can fit k values (at least);

fast_union_uint16

combines union_uint16 and union_vector16 optimally

fclose
fcloseall
fcvt
fcvt_r
fdopen
feof
feof_unlocked
ferror
ferror_unlocked
fflush
fflush_unlocked
ffs
ffsl
ffsll
fgetc
fgetc_unlocked
fgetpos
fgetpos64
fgets
fgets_unlocked
fileno
fileno_unlocked
flockfile
fmemopen
fopen
fopen64
fopencookie
fprintf
fputc
fputc_unlocked
fputs
fputs_unlocked
fread
fread_unlocked
free
freopen
freopen64
fscanf
fseek
fseeko
fseeko64
fsetpos
fsetpos64
ftell
ftello
ftello64
ftrylockfile
funlockfile
fwrite
fwrite_unlocked
gcvt
get_copy_of_container
getc
getc_unlocked
getchar
getchar_unlocked
getdelim
getenv
getline
getloadavg
getpt
getsubopt
getw
gnu_dev_major
gnu_dev_makedev
gnu_dev_minor
grantpt
index
initstate
initstate_r
interleavedBinarySearch

Good old binary search through rle data

intersect_skewed_uint16
intersect_skewed_uint16_cardinality
intersect_skewed_uint16_nonempty
intersect_uint16

Generic intersection function.

intersect_uint16_cardinality

Compute the size of the intersection (generic).

intersect_uint16_nonempty

Checking whether the size of the intersection is non-zero.

intersect_vector16

From Schlegel et al., Fast Sorted-Set Intersection using SIMD Instructions Optimized by D. Lemire on May 3rd 2013

intersect_vector16_cardinality

Compute the cardinality of the intersection using SSE4 instructions

intersection_uint32

Generic intersection function.

intersection_uint32_card

Generic intersection function, returns just the cardinality.

jrand48
jrand48_r
l64a
labs
lcong48
lcong48_r
ldiv
llabs
lldiv
lrand48
lrand48_r
mallinfo
malloc
malloc_get_state
malloc_info
malloc_set_state
malloc_stats
malloc_trim
malloc_usable_size
mallopt
mblen
mbstowcs
mbtowc
memalign
memccpy
memchr
memcmp
memcpy
memfrob
memmem
memmove
mempcpy
memrchr
memset
mkdtemp
mkostemp
mkostemp64
mkostemps
mkostemps64
mkstemp
mkstemp64
mkstemps
mkstemps64
mktemp
mrand48
mrand48_r
nrand48
nrand48_r
obstack_printf
obstack_vprintf
on_exit
open_memstream
pclose
perror
popen
posix_memalign
posix_openpt
printf
pselect
ptsname
ptsname_r
putc
putc_unlocked
putchar
putchar_unlocked
putenv
puts
putw
pvalloc
qecvt
qecvt_r
qfcvt
qfcvt_r
qgcvt
qsort
qsort_r
quick_exit
ra_advance_until_freeing
ra_append

Append a new key-value pair

ra_append_copies_after

appends from sa to ra, starting with the smallest key that is is strictly greater than before_start

ra_append_copies_until

appends from sa to ra, ending with the greatest key that is is less or equal stopping_key

ra_append_copy

Append a new key-value pair to ra, cloning (in COW sense) a value from sa at index index

ra_append_copy_range

Append new key-value pairs to ra, cloning (in COW sense) values from sa at indexes [start_index, end_index)

ra_append_move_range

Move the key-value pairs to ra from sa at indexes [start_index, end_index), old array should not be freed (use ra_clear_without_containers)

ra_append_range

Append new key-value pairs to ra, from sa at indexes [start_index, end_index)

ra_clear

Frees the memory used by a roaring array

ra_clear_containers

Frees just the containers

ra_clear_without_containers

Frees the memory used by a roaring array, but does not free the containers

ra_copy

Copies this roaring array, we assume that dest is not initialized

ra_copy_range
ra_create

Create a new roaring array

ra_downsize
ra_get_container_at_index

Retrieves the container at index i, filling in the typecode

ra_get_index

Get the index corresponding to a 16-bit key

ra_get_key_at_index

Retrieves the key at index i

ra_get_size
ra_has_run_container

return true if it contains at least one run container.

ra_init

Initialize with default capacity

ra_init_with_capacity

Initialize an existing roaring array with the specified capacity (in number of containers)

ra_insert_new_key_value_at

Add a new key-value pair at index i

ra_overwrite

Copies this roaring array, we assume that dest is initialized

ra_portable_deserialize

read a bitmap from a serialized version. This is meant to be compatible with the Java and Go versions. maxbytes indicates how many bytes available from buf. When the function returns true, roaring_array_t is populated with the data and *readbytes indicates how many bytes were read. In all cases, if the function returns true, then maxbytes >= *readbytes.

ra_portable_deserialize_size

Quickly checks whether there is a serialized bitmap at the pointer, not exceeding size "maxbytes" in bytes. This function does not allocate memory dynamically.

ra_portable_header_size

Size of the header when serializing (meant to be compatible with Java and Go versions)

ra_portable_serialize

write a bitmap to a buffer. This is meant to be compatible with the Java and Go versions. Return the size in bytes of the serialized output (which should be ra_portable_size_in_bytes(ra)).

ra_portable_size_in_bytes

How many bytes are required to serialize this bitmap (meant to be compatible with Java and Go versions)

ra_range_uint32_array
ra_remove_at_index

remove at index i, sliding over all entries after i

ra_remove_at_index_and_free

remove at index i, sliding over all entries after i. Free removed container.

ra_replace_key_and_container_at_index
ra_reset

clears all containers, sets the size at 0 and shrinks the memory usage.

ra_set_container_at_index

Set the container at the corresponding index using the specified typecode.

ra_shift_tail

Shifts rightmost $count containers to the left (distance < 0) or to the right (distance > 0). Allocates memory if necessary. This function doesn't free or create new containers. Caller is responsible for that.

ra_shrink_to_fit
ra_to_uint32_array
rand
rand_r
random
random_r
rawmemchr
realloc
realpath
remove
rename
renameat
rewind
rindex
roaring_advance_uint32_iterator

Advance the iterator. If there is a new value, then it->has_value is true. The new value is in it->current_value. Values are traversed in increasing orders. For convenience, returns it->has_value.

roaring_bitmap_add

Add value x

roaring_bitmap_add_checked

Add value x Returns true if a new value was added, false if the value was already existing.

roaring_bitmap_add_many

Add value n_args from pointer vals, faster than repeatedly calling roaring_bitmap_add

roaring_bitmap_add_range

Add all values in range [min, max)

roaring_bitmap_add_range_closed

Add all values in range [min, max]

roaring_bitmap_and

Computes the intersection between two bitmaps and returns new bitmap. The caller is responsible for memory management.

roaring_bitmap_and_cardinality

Computes the size of the intersection between two bitmaps.

roaring_bitmap_and_inplace

Inplace version modifies x1, x1 == x2 is allowed

roaring_bitmap_andnot

Computes the difference (andnot) between two bitmaps and returns new bitmap. The caller is responsible for memory management.

roaring_bitmap_andnot_cardinality

Computes the size of the difference (andnot) between two bitmaps.

roaring_bitmap_andnot_inplace

Inplace version of roaring_bitmap_andnot, modifies x1. x1 != x2.

roaring_bitmap_clear

Empties the bitmap

roaring_bitmap_contains

Check if value x is present

roaring_bitmap_contains_range

Check whether a range of values from range_start (included) to range_end (excluded) is present

roaring_bitmap_copy

Copies a bitmap. This does memory allocation. The caller is responsible for memory management.

roaring_bitmap_create

Creates a new bitmap (initially empty)

roaring_bitmap_create_with_capacity

Creates a new bitmap (initially empty) with a provided container-storage capacity (it is a performance hint).

roaring_bitmap_deserialize

use with roaring_bitmap_serialize see roaring_bitmap_portable_deserialize if you want a format that's compatible with Java and Go implementations

roaring_bitmap_equals

Return true if the two bitmaps contain the same elements.

roaring_bitmap_flip

compute the negation of the roaring bitmap within a specified interval: [range_start, range_end). The number of negated values is range_end - range_start. Areas outside the range are passed through unchanged.

roaring_bitmap_flip_inplace

compute (in place) the negation of the roaring bitmap within a specified interval: [range_start, range_end). The number of negated values is range_end - range_start. Areas outside the range are passed through unchanged.

roaring_bitmap_free

Frees the memory.

roaring_bitmap_from_range

Add all the values between min (included) and max (excluded) that are at a distance k*step from min.

roaring_bitmap_get_cardinality

Get the cardinality of the bitmap (number of elements).

roaring_bitmap_intersect

Check whether two bitmaps intersect.

roaring_bitmap_is_empty

Returns true if the bitmap is empty (cardinality is zero).

roaring_bitmap_is_strict_subset

Return true if all the elements of ra1 are also in ra2 and ra2 is strictly greater than ra1.

roaring_bitmap_is_subset

Return true if all the elements of ra1 are also in ra2.

roaring_bitmap_jaccard_index

Computes the Jaccard index between two bitmaps. (Also known as the Tanimoto distance, or the Jaccard similarity coefficient)

roaring_bitmap_lazy_or

(For expert users who seek high performance.)

roaring_bitmap_lazy_or_inplace

(For expert users who seek high performance.) Inplace version of roaring_bitmap_lazy_or, modifies x1 The bitsetconversion conversion is a flag which determines whether container-container operations force a bitset conversion.

roaring_bitmap_lazy_xor

Computes the symmetric difference between two bitmaps and returns new bitmap. The caller is responsible for memory management.

roaring_bitmap_lazy_xor_inplace

(For expert users who seek high performance.) Inplace version of roaring_bitmap_lazy_xor, modifies x1. x1 != x2

roaring_bitmap_maximum

roaring_bitmap_smallest returns the greatest value in the set. Returns 0 if the set is empty.

roaring_bitmap_minimum

roaring_bitmap_smallest returns the smallest value in the set. Returns UINT32_MAX if the set is empty.

roaring_bitmap_of

Creates a new bitmap from a list of uint32_t integers

roaring_bitmap_of_ptr

Creates a new bitmap from a pointer of uint32_t integers

roaring_bitmap_or

Computes the union between two bitmaps and returns new bitmap. The caller is responsible for memory management.

roaring_bitmap_or_cardinality

Computes the size of the union between two bitmaps.

roaring_bitmap_or_inplace

Inplace version of roaring_bitmap_or, modifies x1. TDOO: decide whether x1 == x2 ok

roaring_bitmap_or_many

Compute the union of 'number' bitmaps. See also roaring_bitmap_or_many_heap. Caller is responsible for freeing the result.

roaring_bitmap_or_many_heap

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_overwrite

Copies a bitmap from src to dest. It is assumed that the pointer dest is to an already allocated bitmap. The content of the dest bitmap is freed/deleted.

roaring_bitmap_portable_deserialize

read a bitmap from a serialized version. This is meant to be compatible with the Java and Go versions. See format specification at https://github.com/RoaringBitmap/RoaringFormatSpec In case of failure, a null pointer is returned. This function is unsafe in the sense that if there is no valid serialized bitmap at the pointer, then many bytes could be read, possibly causing a buffer overflow. For a safer approach, call roaring_bitmap_portable_deserialize_safe.

roaring_bitmap_portable_deserialize_safe

read a bitmap from a serialized version in a safe manner (reading up to maxbytes). This is meant to be compatible with the Java and Go versions. See format specification at https://github.com/RoaringBitmap/RoaringFormatSpec In case of failure, a null pointer is returned.

roaring_bitmap_portable_deserialize_size

Check how many bytes would be read (up to maxbytes) at this pointer if there is a bitmap, returns zero if there is no valid bitmap. This is meant to be compatible with the Java and Go versions. See format specification at https://github.com/RoaringBitmap/RoaringFormatSpec

roaring_bitmap_portable_serialize

write a bitmap to a char buffer. The output buffer should refer to at least roaring_bitmap_portable_size_in_bytes(ra) bytes of allocated memory. This is meant to be compatible with the Java and Go versions. Returns how many bytes were written which should be roaring_bitmap_portable_size_in_bytes(ra). See format specification at https://github.com/RoaringBitmap/RoaringFormatSpec

roaring_bitmap_portable_size_in_bytes

How many bytes are required to serialize this bitmap (meant to be compatible with Java and Go versions). See format specification at https://github.com/RoaringBitmap/RoaringFormatSpec

roaring_bitmap_printf

Print the content of the bitmap.

roaring_bitmap_printf_describe

Describe the inner structure of the bitmap.

roaring_bitmap_range_cardinality

Returns number of elements in range [range_start, range_end).

roaring_bitmap_range_uint32_array

Convert the bitmap to an array from "offset" by "limit". Write the output to "ans". so, you can get data in paging. caller is responsible to ensure that there is enough memory allocated (e.g., ans = malloc(roaring_bitmap_get_cardinality(limit)

roaring_bitmap_rank

roaring_bitmap_rank returns the number of integers that are smaller or equal to x.

roaring_bitmap_remove

Remove value x

roaring_bitmap_remove_checked

Remove value x Returns true if a new value was removed, false if the value was not existing.

roaring_bitmap_remove_many

Remove multiple values

roaring_bitmap_remove_range

Remove all values in range [min, max)

roaring_bitmap_remove_range_closed

Remove all values in range [min, max]

roaring_bitmap_remove_run_compression

Remove run-length encoding even when it is more space efficient return whether a change was applied

roaring_bitmap_repair_after_lazy

(For expert users who seek high performance.)

roaring_bitmap_run_optimize

convert array and bitmap containers to run containers when it is more efficient; also convert from run containers when more space efficient. Returns true if the result has at least one run container. Additional savings might be possible by calling shrinkToFit().

roaring_bitmap_select

If the size of the roaring bitmap is strictly greater than rank, then this function returns true and set element to the element of given rank. Otherwise, it returns false.

roaring_bitmap_serialize

write the bitmap to an output pointer, this output buffer should refer to at least roaring_bitmap_size_in_bytes(ra) allocated bytes.

roaring_bitmap_shrink_to_fit

If needed, reallocate memory to shrink the memory usage. Returns the number of bytes saved.

roaring_bitmap_size_in_bytes

How many bytes are required to serialize this bitmap (NOT compatible with Java and Go versions)

roaring_bitmap_statistics

(For advanced users.) Collect statistics about the bitmap, see roaring_types.h for a description of roaring_statistics_t

roaring_bitmap_to_uint32_array

Convert the bitmap to an array. Write the output to "ans", caller is responsible to ensure that there is enough memory allocated (e.g., ans = malloc(roaring_bitmap_get_cardinality(mybitmap)

roaring_bitmap_xor

Computes the symmetric difference (xor) between two bitmaps and returns new bitmap. The caller is responsible for memory management.

roaring_bitmap_xor_cardinality

Computes the size of the symmetric difference (andnot) between two bitmaps.

roaring_bitmap_xor_inplace

Inplace version of roaring_bitmap_xor, modifies x1. x1 != x2.

roaring_bitmap_xor_many

Compute the xor of 'number' bitmaps. Caller is responsible for freeing the result.

roaring_copy_uint32_iterator

Creates a copy of an iterator. Caller must free it.

roaring_create_iterator

Create an iterator object that can be used to iterate through the values. Caller is responsible for calling roaring_free_iterator. The iterator is initialized. If there is a value, then it->has_value is true. The first value is in it->current_value. The iterator traverses the values in increasing order.

roaring_free_uint32_iterator

Free memory following roaring_create_iterator

roaring_init_iterator

Initialize an iterator object that can be used to iterate through the values. If there is a value, then it->has_value is true. The first value is in it->current_value. The iterator traverses the values in increasing order.

roaring_iterate

Iterate over the bitmap elements. The function iterator is called once for all the values with ptr (can be NULL) as the second parameter of each call.

roaring_iterate64
roaring_move_uint32_iterator_equalorlarger

Move the iterator to the first value >= val. If there is a such a value, then it->has_value is true. The new value is in it->current_value. For convenience, returns it->has_value.

roaring_read_uint32_iterator
rpmatch
run_array_container_andnot
run_array_container_iandnot
run_array_container_ixor
run_bitset_container_andnot
run_bitset_container_iandnot
run_bitset_container_intersect
run_bitset_container_intersection
run_bitset_container_intersection_cardinality
run_bitset_container_ixor
run_bitset_container_lazy_union
run_bitset_container_lazy_xor
run_bitset_container_union
run_bitset_container_xor
run_container_add
run_container_andnot
run_container_clone
run_container_contains
run_container_copy
run_container_create
run_container_create_given_capacity
run_container_deserialize
run_container_equals

Return true if the two containers have the same content.

run_container_equals_array

Return true if the two containers have the same content.

run_container_equals_bitset

Return true if the two containers have the same content.

run_container_free
run_container_from_array
run_container_grow

increase capacity to at least min. Whether the existing data needs to be copied over depends on copy. If "copy" is false, then the new content will be uninitialized, otherwise a copy is made.

run_container_index_equalorlarger
run_container_intersect
run_container_intersection
run_container_intersection_cardinality
run_container_is_subset

Return true if container1 is a subset of container2.

run_container_is_subset_array

Return true if container1 is a subset of container2.

run_container_is_subset_bitset

Return true if container1 is a subset of container2.

run_container_iterate
run_container_iterate64
run_container_maximum
run_container_minimum
run_container_negation
run_container_negation_inplace
run_container_negation_range
run_container_negation_range_inplace
run_container_printf
run_container_printf_as_uint32_array
run_container_rank
run_container_read

Reads the instance from buf, outputs how many bytes were read. This is meant to be byte-by-byte compatible with the Java and Go versions of Roaring. The number of bytes read should be bitset_container_size_in_bytes(container). The cardinality parameter is provided for consistency with other containers, but it might be effectively ignored..

run_container_select

If the element of given rank is in this container, supposing that the first element has rank start_rank, then the function returns true and sets element accordingly. Otherwise, it returns false and update start_rank.

run_container_serialization_len
run_container_serialize
run_container_shrink_to_fit
run_container_smart_append_exclusive

Used in a start-finish scan that appends segments, for XOR and NOT

run_container_to_uint32_array
run_container_union
run_container_union_inplace
run_container_write

Writes the underlying array to buf, outputs how many bytes were written. This is meant to be byte-by-byte compatible with the Java and Go versions of Roaring. The number of bytes written should be run_container_size_in_bytes(container).

run_container_xor
run_run_container_andnot
run_run_container_iandnot
run_run_container_ixor
run_run_container_xor
scanf
secure_getenv
seed48
seed48_r
select
setbuf
setbuffer
setenv
setkey
setlinebuf
setstate
setstate_r
setvbuf
shared_container_extract_copy
shared_container_free
snprintf
sprintf
srand
srand48
srand48_r
srandom
srandom_r
sscanf
stpcpy
stpncpy
strcasecmp
strcasecmp_l
strcasestr
strcat
strchr
strchrnul
strcmp
strcoll
strcoll_l
strcpy
strcspn
strdup
strerror
strerror_l
strerror_r
strfry
strlen
strncasecmp
strncasecmp_l
strncat
strncmp
strncpy
strndup
strnlen
strpbrk
strrchr
strsep
strsignal
strspn
strstr
strtod
strtod_l
strtof
strtof_l
strtok
strtok_r
strtol
strtol_l
strtold
strtold_l
strtoll
strtoll_l
strtoq
strtoul
strtoul_l
strtoull
strtoull_l
strtouq
strverscmp
strxfrm
strxfrm_l
system
tempnam
tmpfile
tmpfile64
tmpnam
tmpnam_r
ungetc
union_uint16

Generic union function.

union_uint32

Generic union function.

union_uint32_card

Generic union function, returns just the cardinality.

union_vector16

A fast SSE-based union function.

unlockpt
unsetenv
valloc
vasprintf
vdprintf
vfprintf
vfscanf
vprintf
vscanf
vsnprintf
vsprintf
vsscanf
wcstombs
wctomb
xor_uint16

Generic XOR function.

xor_vector16

A fast SSE-based XOR function.

Type Definitions

FILE
_IO_lock_t
__FILE
__blkcnt64_t
__blkcnt_t
__blksize_t
__builtin_va_list
__caddr_t
__clock_t
__clockid_t
__codecvt_result
__compar_d_fn_t
__compar_fn_t
__daddr_t
__dev_t
__fd_mask
__fsblkcnt64_t
__fsblkcnt_t
__fsfilcnt64_t
__fsfilcnt_t
__fsword_t
__gid_t
__gnuc_va_list
__id_t
__ino64_t
__ino_t
__int8_t
__int16_t
__int32_t
__int64_t
__intptr_t
__io_close_fn
__io_read_fn
__io_seek_fn
__io_write_fn
__key_t
__locale_t
__loff_t
__m64
__m128
__m128d
__m128i
__m256
__m256d
__m256i
__m512
__m512d
__m512i
__mmask8
__mmask16
__mmask32
__mmask64
__mode_t
__nlink_t
__off64_t
__off_t
__pid_t
__pthread_list_t
__qaddr_t
__quad_t
__rlim64_t
__rlim_t
__sig_atomic_t
__socklen_t
__ssize_t
__suseconds_t
__syscall_slong_t
__syscall_ulong_t
__time_t
__timer_t
__u_char
__u_int
__u_long
__u_quad_t
__u_short
__uid_t
__uint8_t
__uint16_t
__uint32_t
__uint64_t
__useconds_t
__v2si
__v2df
__v2di
__v2sf
__v4hi
__v4si
__v4sf
__v4df
__v4di
__v8qi
__v8hi
__v8sf
__v8si
__v8df
__v8di
__v16qi
__v16qs
__v16hi
__v16sf
__v16si
__v32qi
__v32qs
__v32hi
__v64qi
_bindgen_ty_1
_bindgen_ty_2

During lazy computations, we can transform array containers into bitset containers as long as we can expect them to have ARRAY_LAZY_LOWERBOUND values.

_bindgen_ty_3
_bindgen_ty_4
_bindgen_ty_5
_bindgen_ty_6
_bindgen_ty_7
array_container_t
bitset_container_t
blkcnt64_t
blkcnt_t
blksize_t
caddr_t
clock_t
clockid_t
comparison_fn_t
cookie_close_function_t
cookie_io_functions_t
cookie_read_function_t
cookie_seek_function_t
cookie_write_function_t
daddr_t
dev_t
fd_mask
fpos64_t
fpos_t
fsblkcnt64_t
fsblkcnt_t
fsfilcnt64_t
fsfilcnt_t
fsid_t
gid_t
id_t
idtype_t
ino64_t
ino_t
int_fast8_t
int_fast16_t
int_fast32_t
int_fast64_t
int_least8_t
int_least16_t
int_least32_t
int_least64_t
intmax_t
key_t
locale_t
loff_t
mode_t
nlink_t
off64_t
off_t
pid_t
pthread_key_t
pthread_once_t
pthread_spinlock_t
pthread_t
quad_t
register_t
rle16_t
roaring_array_t
roaring_bitmap_t
roaring_iterator
roaring_iterator64
roaring_statistics_t
roaring_uint32_iterator_t
run_container_t
shared_container_t
sigset_t
suseconds_t
time_t
timer_t
u_char
u_int
u_int8_t
u_int16_t
u_int32_t
u_int64_t
u_long
u_quad_t
u_short
uid_t
uint
uint_fast8_t
uint_fast16_t
uint_fast32_t
uint_fast64_t
uint_least8_t
uint_least16_t
uint_least32_t
uint_least64_t
uintmax_t
ulong
useconds_t
ushort
va_list
wchar_t

Unions

__mbstate_t__bindgen_ty_1
pthread_attr_t
pthread_barrier_t
pthread_barrierattr_t
pthread_cond_t
pthread_condattr_t
pthread_mutex_t
pthread_mutexattr_t
pthread_rwlock_t
pthread_rwlockattr_t