Struct croaring::Bitmap
[−]
[src]
pub struct Bitmap { /* fields omitted */ }
Methods
impl Bitmap
[src]
fn create() -> Self
[src]
Creates a new bitmap (initially empty)
Examples
use croaring::Bitmap; let bitmap = Bitmap::create(); assert!(bitmap.is_empty());
fn create_with_capacity(capacity: u32) -> Self
[src]
Creates a new bitmap (initially empty) with a provided container-storage capacity (it is a performance hint).
Examples
use croaring::Bitmap; let bitmap = Bitmap::create_with_capacity(100_000); assert!(bitmap.is_empty());
fn add_many(&mut self, elements: &[u32])
[src]
Add the integer element to the bitmap
Examples
use croaring::Bitmap; let mut bitmap = Bitmap::create(); bitmap.add_many(&[1, 2, 3]); assert!(!bitmap.is_empty()); assert!(bitmap.contains(1)); assert!(bitmap.contains(2)); assert!(bitmap.contains(3));
fn add(&mut self, element: u32)
[src]
Add the integer element to the bitmap
Examples
use croaring::Bitmap; let mut bitmap = Bitmap::create(); bitmap.add(1); assert!(!bitmap.is_empty());
fn remove(&mut self, element: u32)
[src]
Remove the integer element from the bitmap
Examples
use croaring::Bitmap; let mut bitmap = Bitmap::create(); bitmap.add(1); bitmap.remove(1); assert!(bitmap.is_empty());
fn contains(&self, element: u32) -> bool
[src]
Contains returns true if the integer element is contained in the bitmap
Examples
use croaring::Bitmap; let mut bitmap = Bitmap::create(); bitmap.add(1); assert!(bitmap.contains(1)); assert!(!bitmap.contains(2));
fn cardinality(&self) -> u64
[src]
Returns the number of integers contained in the bitmap
Examples
use croaring::Bitmap; let mut bitmap = Bitmap::create(); bitmap.add(1); assert_eq!(bitmap.cardinality(), 1); bitmap.add(2); assert_eq!(bitmap.cardinality(), 2);
fn and(&self, other: &Self) -> Self
[src]
And computes the intersection between two bitmaps and returns the result as a new bitmap
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(1); let mut bitmap2 = Bitmap::create(); bitmap2.add(1); bitmap2.add(2); let bitmap3 = bitmap1.and(&bitmap2); assert!(bitmap3.contains(1)); assert!(!bitmap3.contains(2));
fn and_inplace(&mut self, other: &Self)
[src]
Computes the intersection between two bitmaps and stores the result in the current bitmap
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); let mut bitmap3 = Bitmap::create(); bitmap3.add(15); let mut bitmap4 = Bitmap::create(); bitmap4.add(15); bitmap4.add(25); bitmap1.and_inplace(&bitmap2); assert!(bitmap1.cardinality() == 0); assert!(!bitmap1.contains(15)); assert!(!bitmap1.contains(25)); bitmap3.and_inplace(&bitmap4); assert!(bitmap3.cardinality() == 1); assert!(bitmap3.contains(15)); assert!(!bitmap3.contains(25));
fn or(&self, other: &Self) -> Self
[src]
Or computes the union between two bitmaps and returns the result as a new bitmap
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); let bitmap3 = bitmap1.or(&bitmap2); assert!(bitmap3.cardinality() == 2); assert!(bitmap3.contains(15)); assert!(bitmap3.contains(25));
fn or_inplace(&mut self, other: &Self)
[src]
Computes the union between two bitmaps and stores the result in the current bitmap.
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); bitmap1.or_inplace(&bitmap2); assert!(bitmap1.cardinality() == 2); assert!(bitmap1.contains(15)); assert!(bitmap1.contains(25));
fn fast_or(bitmaps: &[&Bitmap]) -> Self
[src]
Computes the union between many bitmaps quickly, as opposed to having to call or() repeatedly. Returns the result as a new bitmap.
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); let mut bitmap3 = Bitmap::create(); bitmap3.add(35); let bitmap4 = Bitmap::fast_or(&[&bitmap1, &bitmap2, &bitmap3]); assert_eq!(bitmap4.cardinality(), 3); assert!(bitmap4.contains(15)); assert!(bitmap4.contains(25)); assert!(bitmap4.contains(25));
fn fast_or_heap(bitmaps: &[&Bitmap]) -> Self
[src]
Compute the union of 'number' bitmaps using a heap. This can sometimes be faster than Bitmap::fast_or.
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); let mut bitmap3 = Bitmap::create(); bitmap3.add(35); let bitmap4 = Bitmap::fast_or_heap(&[&bitmap1, &bitmap2, &bitmap3]); assert_eq!(bitmap4.cardinality(), 3); assert!(bitmap4.contains(15)); assert!(bitmap4.contains(25)); assert!(bitmap4.contains(25));
fn xor(&self, other: &Self) -> Self
[src]
Computes the symmetric difference (xor) between two bitmaps and returns new bitmap.
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); bitmap1.add(25); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); bitmap2.add(35); let bitmap3 = bitmap1.xor(&bitmap2); assert!(bitmap3.cardinality() == 2); assert!(bitmap3.contains(15)); assert!(!bitmap3.contains(25)); assert!(bitmap3.contains(35));
fn xor_inplace(&mut self, other: &Self)
[src]
Inplace version of roaring_bitmap_xor, stores result in current bitmap.
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); bitmap1.add(25); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); bitmap2.add(35); bitmap1.xor_inplace(&bitmap2); assert!(bitmap1.cardinality() == 2); assert!(bitmap1.contains(15)); assert!(!bitmap1.contains(25)); assert!(bitmap1.contains(35));
fn fast_xor(bitmaps: &[&Bitmap]) -> Self
[src]
Computes the symmetric difference (xor) between multiple bitmaps and returns new bitmap as a result.
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); bitmap1.add(25); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); bitmap2.add(35); let bitmap3 = Bitmap::fast_xor(&[&bitmap1, &bitmap2]); assert!(bitmap3.cardinality() == 2); assert!(bitmap3.contains(15)); assert!(!bitmap3.contains(25)); assert!(bitmap3.contains(35));
fn andnot(&self, other: &Self) -> Self
[src]
Computes the difference between two bitmaps and returns the result.
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); bitmap1.add(25); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); bitmap2.add(35); let bitmap3 = bitmap1.andnot(&bitmap2); assert_eq!(bitmap3.cardinality(), 1); assert!(bitmap3.contains(15)); assert!(!bitmap3.contains(25)); assert!(!bitmap3.contains(35));
fn andnot_inplace(&mut self, other: &Self)
[src]
Computes the difference between two bitmaps and stores the result in the current bitmap.
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); bitmap1.add(25); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); bitmap2.add(35); bitmap1.andnot_inplace(&bitmap2); assert_eq!(bitmap1.cardinality(), 1); assert!(bitmap1.contains(15)); assert!(!bitmap1.contains(25)); assert!(!bitmap1.contains(35));
fn flip(&self, range: Range<u64>) -> Self
[src]
Negates the bits in the given range (i.e., [rangeStart..rangeEnd)), any integer present in this range and in the bitmap is removed. Returns result as a new bitmap.
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(4); let bitmap2 = bitmap1.flip((1..3)); assert_eq!(bitmap2.cardinality(), 3); assert!(bitmap2.contains(1)); assert!(bitmap2.contains(2)); assert!(!bitmap2.contains(3)); assert!(bitmap2.contains(4));
fn flip_inplace(&mut self, range: Range<u64>)
[src]
Negates the bits in the given range (i.e., [rangeStart..rangeEnd)), any integer present in this range and in the bitmap is removed. Stores the result in the current bitmap.
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(4); bitmap1.flip_inplace((1..3)); assert_eq!(bitmap1.cardinality(), 3); assert!(bitmap1.contains(1)); assert!(bitmap1.contains(2)); assert!(!bitmap1.contains(3)); assert!(bitmap1.contains(4));
fn to_vec(&self) -> Vec<u32>
[src]
Returns a vector containing all of the integers stored in the Bitmap in sorted order.
use croaring::Bitmap; let mut bitmap = Bitmap::create(); bitmap.add(15); bitmap.add(25); assert_eq!(bitmap.to_vec(), [15, 25]); assert!(bitmap.to_vec() != [10, 15, 25]);
fn get_serialized_size_in_bytes(&self) -> usize
[src]
Computes the serialized size in bytes of the Bitmap.
fn serialize(&self) -> Vec<u8>
[src]
Serializes a bitmap to a slice of bytes.
Examples
use croaring::Bitmap; let original_bitmap: Bitmap = (1..5).collect(); let serialized_buffer = original_bitmap.serialize(); let deserialized_bitmap = Bitmap::deserialize(&serialized_buffer); assert_eq!(original_bitmap, deserialized_bitmap);
fn deserialize(buffer: &[u8]) -> Self
[src]
Given a serialized bitmap as slice of bytes returns a bitmap instance. See example of #serialize function.
fn of(elements: &[u32]) -> Self
[src]
Creates a new bitmap from a slice of u32 integers
Examples
use croaring::Bitmap; let elements = vec![1, 2]; let bitmap = Bitmap::of(&elements); let mut bitmap2 = Bitmap::create(); for element in &elements { bitmap2.add(*element); } assert!(bitmap.contains(1)); assert!(bitmap.contains(2)); assert!(!bitmap.contains(3)); assert_eq!(bitmap, bitmap2);
fn run_optimize(&mut self) -> bool
[src]
Compresses of the bitmap. Returns true if the bitmap was modified.
Examples
use croaring::Bitmap; let mut bitmap: Bitmap = (100..1000).collect(); assert_eq!(bitmap.cardinality(), 900); assert!(bitmap.run_optimize());
fn remove_run_compression(&mut self) -> bool
[src]
Removes run-length encoding even when it is more space efficient. Returns true if a change was applied.
Examples
use croaring::Bitmap; let mut bitmap: Bitmap = (100..1000).collect(); assert_eq!(bitmap.cardinality(), 900); bitmap.run_optimize(); assert!(bitmap.remove_run_compression()); assert!(!bitmap.remove_run_compression());
fn is_empty(&self) -> bool
[src]
Returns true if the Bitmap is empty. Faster than doing: bitmap.cardinality() == 0)
Examples
use croaring::Bitmap; let mut bitmap = Bitmap::create(); assert!(bitmap.is_empty()); bitmap.add(1); assert!(!bitmap.is_empty());
fn is_subset(&self, other: &Self) -> bool
[src]
Return true if all the elements of Self are in &other.
Examples
use croaring::Bitmap; let bitmap1: Bitmap = (5..10).collect(); let bitmap2: Bitmap = (5..8).collect(); let bitmap3: Bitmap = (5..10).collect(); let bitmap4: Bitmap = (9..11).collect(); assert!(bitmap2.is_subset(&bitmap1)); assert!(bitmap3.is_subset(&bitmap1)); assert!(!bitmap4.is_subset(&bitmap1));
fn is_strict_subset(&self, other: &Self) -> bool
[src]
Return true if all the elements of Self are in &other and &other is strictly greater than Self.
Examples
use croaring::Bitmap; let bitmap1: Bitmap = (5..9).collect(); let bitmap2: Bitmap = (5..8).collect(); let bitmap3: Bitmap = (5..10).collect(); let bitmap4: Bitmap = (9..11).collect(); assert!(bitmap2.is_subset(&bitmap1)); assert!(!bitmap3.is_subset(&bitmap1)); assert!(!bitmap4.is_subset(&bitmap1));
fn intersect(&self, other: &Self) -> bool
[src]
Return true if Self and &other intersect
Examples
use croaring::Bitmap; let bitmap1: Bitmap = (1..5).collect(); let bitmap2: Bitmap = (5..9).collect(); let bitmap3: Bitmap = (3..7).collect(); assert_eq!(bitmap1.intersect(&bitmap2), false); assert_eq!(bitmap1.intersect(&bitmap3), true); assert_eq!(bitmap2.intersect(&bitmap3), true);
fn jaccard_index(&self, other: &Self) -> f64
[src]
Return the Jaccard index between Self and &other
use croaring::Bitmap; let bitmap1: Bitmap = (1..5).collect(); let bitmap2: Bitmap = (5..9).collect(); let bitmap3: Bitmap = (3..9).collect(); assert_eq!(bitmap1.jaccard_index(&bitmap2), 0.0); assert_eq!(bitmap1.jaccard_index(&bitmap3), 0.25); assert_eq!(bitmap2.jaccard_index(&bitmap3), 0.6666666666666666);
fn and_cardinality(&self, other: &Self) -> u64
[src]
Return the size of the intersection between Self and &other
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(1); let mut bitmap2 = Bitmap::create(); bitmap2.add(1); bitmap2.add(2); assert_eq!(bitmap1.and_cardinality(&bitmap2), 1);
fn or_cardinality(&self, other: &Self) -> u64
[src]
Return the size of the union between Self and &other
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); assert_eq!(bitmap1.or_cardinality(&bitmap2), 2);
fn andnot_cardinality(&self, other: &Self) -> u64
[src]
Return the size of the difference between Self and &other
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); bitmap1.add(25); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); bitmap2.add(35); assert_eq!(bitmap1.andnot_cardinality(&bitmap2), 1);
fn xor_cardinality(&self, other: &Self) -> u64
[src]
Return the size of the symmetric difference between Self and &other
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); bitmap1.add(25); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); bitmap2.add(35); assert_eq!(bitmap1.xor_cardinality(&bitmap2), 2);
fn minimum(&self) -> u32
[src]
Returns the smallest value in the set. Returns std::u32::MAX if the set is empty.
Examples
use croaring::Bitmap; let mut bitmap: Bitmap = (5..10).collect(); let empty_bitmap: Bitmap = Bitmap::create(); assert_eq!(bitmap.minimum(), 5); assert_eq!(empty_bitmap.minimum(), std::u32::MAX); bitmap.add(3); assert_eq!(bitmap.minimum(), 3);
fn maximum(&self) -> u32
[src]
Returns the greatest value in the set. Returns 0 if the set is empty.
Examples
use croaring::Bitmap; let mut bitmap: Bitmap = (5..10).collect(); let empty_bitmap: Bitmap = Bitmap::create(); assert_eq!(bitmap.maximum(), 9); assert_eq!(empty_bitmap.maximum(), 0); bitmap.add(15); assert_eq!(bitmap.maximum(), 15);
fn rank(&self, x: u32) -> u64
[src]
Rank returns the number of values smaller or equal to x.
Examples
use croaring::Bitmap; let mut bitmap: Bitmap = (5..10).collect(); assert_eq!(bitmap.rank(8), 4); bitmap.add(15); assert_eq!(bitmap.rank(11), 5);
fn select(&self, rank: u32) -> Option<u32>
[src]
Select returns the element having the designated rank, if it exists If the size of the roaring bitmap is strictly greater than rank, then this function returns element of given rank wrapped in Some. Otherwise, it returns None.
Examples
use croaring::Bitmap; let bitmap: Bitmap = (5..10).collect(); assert_eq!(bitmap.select(0), Some(5)); assert_eq!(bitmap.select(1), Some(6)); assert_eq!(bitmap.select(2), Some(7)); assert_eq!(bitmap.select(3), Some(8)); assert_eq!(bitmap.select(4), Some(9)); assert_eq!(bitmap.select(5), None);
fn statistics(&self) -> Statistics
[src]
Returns statistics about the composition of a roaring bitmap.
Examples
use croaring::Bitmap; let mut bitmap: Bitmap = (1..100).collect(); let statistics = bitmap.statistics(); assert_eq!(statistics.n_containers, 1); assert_eq!(statistics.n_array_containers, 1); assert_eq!(statistics.n_run_containers, 0); assert_eq!(statistics.n_bitset_containers, 0); assert_eq!(statistics.n_values_array_containers, 99); assert_eq!(statistics.n_values_run_containers, 0); assert_eq!(statistics.n_values_bitset_containers, 0); assert_eq!(statistics.n_bytes_array_containers, 198); assert_eq!(statistics.n_bytes_run_containers, 0); assert_eq!(statistics.n_bytes_bitset_containers, 0); assert_eq!(statistics.max_value, 99); assert_eq!(statistics.min_value, 1); assert_eq!(statistics.sum_value, 4950); assert_eq!(statistics.cardinality, 99); bitmap.run_optimize(); let statistics = bitmap.statistics(); assert_eq!(statistics.n_containers, 1); assert_eq!(statistics.n_array_containers, 0); assert_eq!(statistics.n_run_containers, 1); assert_eq!(statistics.n_bitset_containers, 0); assert_eq!(statistics.n_values_array_containers, 0); assert_eq!(statistics.n_values_run_containers, 99); assert_eq!(statistics.n_values_bitset_containers, 0); assert_eq!(statistics.n_bytes_array_containers, 0); assert_eq!(statistics.n_bytes_run_containers, 6); assert_eq!(statistics.n_bytes_bitset_containers, 0); assert_eq!(statistics.max_value, 99); assert_eq!(statistics.min_value, 1); assert_eq!(statistics.sum_value, 4950); assert_eq!(statistics.cardinality, 99);
impl Bitmap
[src]
fn iter(&self) -> BitmapIterator
[src]
Returns an iterator over each value stored in the bitmap. Returned values are ordered in ascending order.
Examples
use croaring::Bitmap; let mut bitmap = Bitmap::create(); bitmap.add(4); bitmap.add(3); bitmap.add(2); let mut iterator = bitmap.iter(); assert_eq!(iterator.next(), Some(2)); assert_eq!(iterator.next(), Some(3)); assert_eq!(iterator.next(), Some(4)); assert_eq!(iterator.next(), None);
Trait Implementations
impl Debug for Bitmap
[src]
impl PartialEq for Bitmap
[src]
fn eq(&self, other: &Bitmap) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl Clone for Bitmap
[src]
fn clone(&self) -> Bitmap
[src]
Create a copy of a Bitmap
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(11); let bitmap2 = bitmap1.clone(); assert_eq!(bitmap1, bitmap2);
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl Drop for Bitmap
[src]
impl BitAnd for Bitmap
[src]
type Output = Bitmap
The resulting type after applying the &
operator.
fn bitand(self, other: Bitmap) -> Bitmap
[src]
Syntactic sugar for .and
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(1); let mut bitmap2 = Bitmap::create(); bitmap2.add(1); bitmap2.add(2); let bitmap3 = bitmap1 & bitmap2; assert!(bitmap3.contains(1)); assert!(!bitmap3.contains(2));
impl<'a> BitAnd<&'a Bitmap> for Bitmap
[src]
type Output = Bitmap
The resulting type after applying the &
operator.
fn bitand(self, other: &'a Bitmap) -> Bitmap
[src]
Syntactic sugar for .and
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(1); let mut bitmap2 = Bitmap::create(); bitmap2.add(1); bitmap2.add(2); let bitmap3 = bitmap1 & &bitmap2; assert!(bitmap3.contains(1)); assert!(!bitmap3.contains(2));
impl<'a, 'b> BitAnd<&'a Bitmap> for &'b Bitmap
[src]
type Output = Bitmap
The resulting type after applying the &
operator.
fn bitand(self, other: &'a Bitmap) -> Bitmap
[src]
Syntactic sugar for .and
Examples
use croaring::Bitmap; let mut bitmap1: Bitmap = Bitmap::create(); bitmap1.add(1); let mut bitmap2 = Bitmap::create(); bitmap2.add(1); bitmap2.add(2); let bitmap3 = &bitmap1 & &bitmap2; assert!(bitmap3.contains(1)); assert!(!bitmap3.contains(2));
impl BitAndAssign for Bitmap
[src]
fn bitand_assign(&mut self, other: Bitmap)
[src]
Syntactic sugar for .and_inplace
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); let mut bitmap3 = Bitmap::create(); bitmap3.add(15); let mut bitmap4 = Bitmap::create(); bitmap4.add(15); bitmap4.add(25); bitmap1 &= bitmap2; assert!(bitmap1.cardinality() == 0); assert!(!bitmap1.contains(15)); assert!(!bitmap1.contains(25)); bitmap3 &= bitmap4; assert!(bitmap3.cardinality() == 1); assert!(bitmap3.contains(15)); assert!(!bitmap3.contains(25));
impl BitOr for Bitmap
[src]
type Output = Bitmap
The resulting type after applying the |
operator.
fn bitor(self, other: Bitmap) -> Bitmap
[src]
Syntatic sugar for .or
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); let bitmap3 = bitmap1 | bitmap2; assert!(bitmap3.cardinality() == 2); assert!(bitmap3.contains(15)); assert!(bitmap3.contains(25));
impl<'a> BitOr<&'a Bitmap> for Bitmap
[src]
type Output = Bitmap
The resulting type after applying the |
operator.
fn bitor(self, other: &'a Bitmap) -> Bitmap
[src]
Syntatic sugar for .or
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); let bitmap3 = bitmap1 | &bitmap2; assert!(bitmap3.cardinality() == 2); assert!(bitmap3.contains(15)); assert!(bitmap3.contains(25));
impl<'a, 'b> BitOr<&'a Bitmap> for &'b Bitmap
[src]
type Output = Bitmap
The resulting type after applying the |
operator.
fn bitor(self, other: &'a Bitmap) -> Bitmap
[src]
Syntatic sugar for .or
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); let bitmap3 = &bitmap1 | &bitmap2; assert!(bitmap3.cardinality() == 2); assert!(bitmap3.contains(15)); assert!(bitmap3.contains(25));
impl BitOrAssign for Bitmap
[src]
fn bitor_assign(&mut self, other: Bitmap)
[src]
Syntatic sugar for .or_inplace
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); bitmap1 |= bitmap2; assert!(bitmap1.cardinality() == 2); assert!(bitmap1.contains(15)); assert!(bitmap1.contains(25));
impl BitXor for Bitmap
[src]
type Output = Bitmap
The resulting type after applying the ^
operator.
fn bitxor(self, other: Bitmap) -> Bitmap
[src]
Syntatic sugar for .xor
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); bitmap1.add(25); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); bitmap2.add(35); let bitmap3 = bitmap1 ^ bitmap2; assert!(bitmap3.cardinality() == 2); assert!(bitmap3.contains(15)); assert!(!bitmap3.contains(25)); assert!(bitmap3.contains(35));
impl<'a> BitXor<&'a Bitmap> for Bitmap
[src]
type Output = Bitmap
The resulting type after applying the ^
operator.
fn bitxor(self, other: &'a Bitmap) -> Bitmap
[src]
Syntatic sugar for .xor
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); bitmap1.add(25); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); bitmap2.add(35); let bitmap3 = bitmap1 ^ &bitmap2; assert!(bitmap3.cardinality() == 2); assert!(bitmap3.contains(15)); assert!(!bitmap3.contains(25)); assert!(bitmap3.contains(35));
impl<'a, 'b> BitXor<&'a Bitmap> for &'b Bitmap
[src]
type Output = Bitmap
The resulting type after applying the ^
operator.
fn bitxor(self, other: &'a Bitmap) -> Bitmap
[src]
Syntatic sugar for .xor
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); bitmap1.add(25); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); bitmap2.add(35); let bitmap3 = &bitmap1 ^ &bitmap2; assert!(bitmap3.cardinality() == 2); assert!(bitmap3.contains(15)); assert!(!bitmap3.contains(25)); assert!(bitmap3.contains(35));
impl BitXorAssign for Bitmap
[src]
fn bitxor_assign(&mut self, other: Bitmap)
[src]
Syntatic sugar for .xor_inplace
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); bitmap1.add(25); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); bitmap2.add(35); bitmap1 ^= bitmap2; assert!(bitmap1.cardinality() == 2); assert!(bitmap1.contains(15)); assert!(!bitmap1.contains(25)); assert!(bitmap1.contains(35));
impl Sub for Bitmap
[src]
type Output = Bitmap
The resulting type after applying the -
operator.
fn sub(self, other: Bitmap) -> Bitmap
[src]
Syntatic sugar for .andnot
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); bitmap1.add(25); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); bitmap2.add(35); let bitmap3 = bitmap1 - bitmap2; assert_eq!(bitmap3.cardinality(), 1); assert!(bitmap3.contains(15)); assert!(!bitmap3.contains(25)); assert!(!bitmap3.contains(35));
impl<'a> Sub<&'a Bitmap> for Bitmap
[src]
type Output = Bitmap
The resulting type after applying the -
operator.
fn sub(self, other: &'a Bitmap) -> Bitmap
[src]
Syntatic sugar for .andnot
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); bitmap1.add(25); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); bitmap2.add(35); let bitmap3 = bitmap1 - &bitmap2; assert_eq!(bitmap3.cardinality(), 1); assert!(bitmap3.contains(15)); assert!(!bitmap3.contains(25)); assert!(!bitmap3.contains(35));
impl<'a, 'b> Sub<&'a Bitmap> for &'b Bitmap
[src]
type Output = Bitmap
The resulting type after applying the -
operator.
fn sub(self, other: &'a Bitmap) -> Bitmap
[src]
Syntatic sugar for .andnot
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); bitmap1.add(25); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); bitmap2.add(35); let bitmap3 = &bitmap1 - &bitmap2; assert_eq!(bitmap3.cardinality(), 1); assert!(bitmap3.contains(15)); assert!(!bitmap3.contains(25)); assert!(!bitmap3.contains(35));
impl SubAssign for Bitmap
[src]
fn sub_assign(&mut self, other: Bitmap)
[src]
Syntatic sugar for .andnot_inplace
Examples
use croaring::Bitmap; let mut bitmap1 = Bitmap::create(); bitmap1.add(15); bitmap1.add(25); let mut bitmap2 = Bitmap::create(); bitmap2.add(25); bitmap2.add(35); bitmap1.andnot_inplace(&bitmap2); assert_eq!(bitmap1.cardinality(), 1); assert!(bitmap1.contains(15)); assert!(!bitmap1.contains(25)); assert!(!bitmap1.contains(35));
impl FromIterator<u32> for Bitmap
[src]
fn from_iter<I: IntoIterator<Item = u32>>(iter: I) -> Self
[src]
Convenience method for creating bitmap from iterator.
Examples
use croaring::Bitmap; let bitmap: Bitmap = (1..3).collect(); assert!(!bitmap.is_empty()); assert!(bitmap.contains(1)); assert!(bitmap.contains(2)); assert_eq!(bitmap.cardinality(), 2);