roaring 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e21e62ddcac0d57cf83948329add1ead73e1299adc691b57dd940e7e5ca5306
-  data.tar.gz: 1367042b6b8d27c24f9e124cf8c081bc18aa153e4431cb6339181c65904dbb68
+  metadata.gz: 3f2956df800830dc45bb3b8e63fd1b7795c39a73ab52f5671e651ca1087e1572
+  data.tar.gz: 74b06f13df663851dd703b2888cd3b465fe788a794dcb0cadca5d1b534db023e
 SHA512:
-  metadata.gz: 3b94ccd487a8b5e28b6130e25a759f4ab1d226670cb30063cede4c5815a19c69481a5a5f7bbfafc6ebbca6e55fdf6e85166e63f0c5fe13a82bfeaba3d107ec7d
-  data.tar.gz: 9735a5df2fff46c07e917fc4cbd421fbff2bcca9304cf0da3f70c9f9e0ea12ed54447280b7a17b18f9d5a43a0f178f2d6fd840d5017dc80494b1f7add81ee242
+  metadata.gz: 18a68702d1d236e6817c542dcbb15d32515f76263b0e5f074837bdde8a5bc9ca5ff88976eba18d67b1cd041307b22a81a72e79f6d7b25124b80b2f14028e9ba0
+  data.tar.gz: 44ca8c98572f932a23d7488afd87bc05d3c0618062d912bc71b9f319497ba5ac3e824e046011b192198b8c90686ebeda972f1e15104428684cdb2dcc2761dd3d

data/.yardopts

@@ -0,0 +1 @@
+--embed-mixins --no-private

data/Gemfile

@@ -11,3 +11,6 @@ gem "rake-compiler"
 gem "debug"
 
 gem "minitest", "~> 5.0"
+
+gem "yard"
+gem "benchmark-ips"

data/README.md

@@ -1,9 +1,6 @@
 # Roaring
 
-A Ruby wrapper for CRoaring (a C/C++ implementation at https://github.com/RoaringBitmap/CRoaring)
-
-Roaring Bitmaps are a compressed bitmap/bitset format/library.
-More information and papers can be found at https://roaringbitmap.org/
+[Roaring Bitmaps](http://www.roaringbitmap.org/about/) are a compressed bitmap/bitset format/library. Think of it like a `Set` which can only hold (32-bit or 64-bit) `Integer`s, with much lower memory use and supporting fast set operations.
 
 ## Installation
 
@@ -16,20 +13,26 @@ Install the gem and add to the application's Gemfile by executing:
 ``` ruby
 require "roaring"
 
-# Bitmaps can efficiently store a large range of 32-bit integers
-bitmap = Roaring::Bitmap[1, 2, 3, 999]
+# Bitmap32 can efficiently store a large range of 32-bit integers
+bitmap = Roaring::Bitmap32[1, 2, 3, 999]
 bitmap << (2**32 - 1)
 
+# Bitmap64 can efficiently store a large range of 64-bit integers
+bitmap = Roaring::Bitmap64[1, 2, 3, 999]
+bitmap << (2**32 + 1)
+bitmap << (2**64 - 1)
+
 # Element access
 bitmap.each { }
 bitmap.first # => 1
 bitmap.min   # => 1
-bitmap.max   # => 4294967295
-bitmap.last  # => 4294967295
+bitmap.max   # => 18446744073709551615
+bitmap.last  # => 18446744073709551615
 bitmap[3]    # => 999
+bitmap.to_a  # => [1, 2, 3, 999, 4294967297, 18446744073709551615]
 
-b1 = Roaring::Bitmap.new(200...500)
-b2 = Roaring::Bitmap.new(100...1000)
+b1 = Roaring::Bitmap64.new(200...500)
+b2 = Roaring::Bitmap64.new(100...1000)
 
 # Support common set operations
 (b1 & b2).size # => 300
@@ -41,12 +44,14 @@ b1 < b2 # => true
 
 # (De)Serialization (also available via Marshal#{dump,load})
 dump = bitmap.serialize
-loaded = Roaring::Bitmap.deserialize(dump)
+loaded = Roaring::Bitmap64.deserialize(dump)
 loaded == bitmap # => true
 ```
 
 ## Development
 
+This is a Ruby wrapper around [CRoaring](https://github.com/RoaringBitmap/CRoaring)
+
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).

data/Rakefile

@@ -3,6 +3,12 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
 
+require "yard"
+
+YARD::Rake::YardocTask.new do |t|
+  t.files = ["lib/**/*.rb", "ext/**/*.c"]
+end
+
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
@@ -17,14 +23,13 @@ Rake::ExtensionTask.new("roaring") do |ext|
   ext.lib_dir = "lib/roaring"
 end
 
+desc "Update vendored CRoaring library"
 task :update_roaring do
-  require "open-uri"
-
-  ["roaring.c", "roaring.h"].each do |filename|
-    url = "https://github.com/RoaringBitmap/CRoaring/releases/latest/download/#{filename}"
-    source = URI.open(url).read
-    File.write("#{__dir__}/ext/roaring/#{filename}", source)
-  end
+  rm_rf "tmp/CRoaring"
+  sh "git clone --depth=1 https://github.com/RoaringBitmap/CRoaring tmp/CRoaring"
+  sh "cd tmp/CRoaring && sh amalgamation.sh"
+  cp "tmp/CRoaring/roaring.c", "ext/roaring/roaring.c"
+  cp "tmp/CRoaring/roaring.h", "ext/roaring/roaring.h"
 end
 
 task default: %i[compile test]

data/benchmark/to_a.rb

@@ -0,0 +1,15 @@
+require "benchmark/ips"
+require "roaring"
+
+small_bitmap = Roaring::Bitmap32[1,2,3,4]
+large_bitmap = Roaring::Bitmap32[1..1000]
+
+Benchmark.ips do |x|
+  x.report "small_bitmap.to_a" do
+    small_bitmap.to_a
+  end
+
+  x.report "large_bitmap.to_a" do
+    large_bitmap.to_a
+  end
+end

data/benchmark/to_set.rb

@@ -0,0 +1,15 @@
+require "benchmark/ips"
+require "roaring"
+
+small_bitmap = Roaring::Bitmap32[1,2,3,4]
+large_bitmap = Roaring::Bitmap32[1..1000]
+
+Benchmark.ips do |x|
+  x.report "small_bitmap.to_set" do
+    small_bitmap.to_set
+  end
+
+  x.report "large_bitmap.to_set" do
+    large_bitmap.to_set
+  end
+end

data/ext/roaring/bitmap32.c

@@ -48,6 +48,7 @@ static roaring_bitmap_t *get_bitmap(VALUE obj) {
     return bitmap;
 }
 
+// Replaces the contents of `self` with another bitmap
 static VALUE rb_roaring32_replace(VALUE self, VALUE other) {
     roaring_bitmap_t *self_data = get_bitmap(self);
     roaring_bitmap_t *other_data = get_bitmap(other);
@@ -57,6 +58,7 @@ static VALUE rb_roaring32_replace(VALUE self, VALUE other) {
     return self;
 }
 
+// @return [Integer] the number of elements in the bitmap
 static VALUE rb_roaring32_cardinality(VALUE self)
 {
     roaring_bitmap_t *data = get_bitmap(self);
@@ -64,6 +66,8 @@ static VALUE rb_roaring32_cardinality(VALUE self)
     return ULONG2NUM(cardinality);
 }
 
+// Adds an element from the bitmap
+// @param val [Integer] the value to add
 static VALUE rb_roaring32_add(VALUE self, VALUE val)
 {
     roaring_bitmap_t *data = get_bitmap(self);
@@ -73,6 +77,9 @@ static VALUE rb_roaring32_add(VALUE self, VALUE val)
     return self;
 }
 
+// Adds an element from the bitmap
+// @see {add}
+// @return `self` if value was add, `nil` if value was already in the bitmap
 static VALUE rb_roaring32_add_p(VALUE self, VALUE val)
 {
     roaring_bitmap_t *data = get_bitmap(self);
@@ -81,6 +88,19 @@ static VALUE rb_roaring32_add_p(VALUE self, VALUE val)
     return roaring_bitmap_add_checked(data, num) ? self : Qnil;
 }
 
+static VALUE rb_roaring32_add_range_closed(VALUE self, VALUE minv, VALUE maxv)
+{
+    roaring_bitmap_t *data = get_bitmap(self);
+
+    uint32_t min = NUM2UINT32(minv);
+    uint32_t max = NUM2UINT32(maxv);
+
+    roaring_bitmap_add_range_closed(data, min, max);
+
+    return self;
+}
+
+// Removes an element from the bitmap
 static VALUE rb_roaring32_remove(VALUE self, VALUE val)
 {
     roaring_bitmap_t *data = get_bitmap(self);
@@ -90,6 +110,10 @@ static VALUE rb_roaring32_remove(VALUE self, VALUE val)
     return self;
 }
 
+// Removes an element from the bitmap
+//
+// @see {remove}
+// @return [self,nil] `self` if value was removed, `nil` if the value wasn't in the bitmap
 static VALUE rb_roaring32_remove_p(VALUE self, VALUE val)
 {
     roaring_bitmap_t *data = get_bitmap(self);
@@ -98,6 +122,7 @@ static VALUE rb_roaring32_remove_p(VALUE self, VALUE val)
     return roaring_bitmap_remove_checked(data, num) ? self : Qnil;
 }
 
+// @return [Boolean] `true` if the bitmap is contains `val`, otherwise `false`
 static VALUE rb_roaring32_include_p(VALUE self, VALUE val)
 {
     roaring_bitmap_t *data = get_bitmap(self);
@@ -106,12 +131,14 @@ static VALUE rb_roaring32_include_p(VALUE self, VALUE val)
     return RBOOL(roaring_bitmap_contains(data, num));
 }
 
+// @return [Boolean] `true` if the bitmap is empty, otherwise `false`
 static VALUE rb_roaring32_empty_p(VALUE self)
 {
     roaring_bitmap_t *data = get_bitmap(self);
     return RBOOL(roaring_bitmap_is_empty(data));
 }
 
+// Removes all elements from the bitmap
 static VALUE rb_roaring32_clear(VALUE self)
 {
     roaring_bitmap_t *data = get_bitmap(self);
@@ -124,6 +151,8 @@ bool rb_roaring32_each_i(uint32_t value, void *param) {
     return true;  // iterate till the end
 }
 
+// Iterates over every element in the bitmap
+// @return [self]
 static VALUE rb_roaring32_each(VALUE self)
 {
     roaring_bitmap_t *data = get_bitmap(self);
@@ -131,6 +160,8 @@ static VALUE rb_roaring32_each(VALUE self)
     return self;
 }
 
+// Find the nth smallest integer in the bitmap
+// @return [Integer,nil] The nth integer in the bitmap, or `nil` if `rankv` is `>= cardinality`
 static VALUE rb_roaring32_aref(VALUE self, VALUE rankv)
 {
     roaring_bitmap_t *data = get_bitmap(self);
@@ -146,6 +177,8 @@ static VALUE rb_roaring32_aref(VALUE self, VALUE rankv)
     return self;
 }
 
+// Find the smallest integer in the bitmap
+// @return [Integer,nil] The smallest integer in the bitmap, or `nil` if it is empty
 static VALUE rb_roaring32_min(VALUE self)
 {
     roaring_bitmap_t *data = get_bitmap(self);
@@ -158,6 +191,8 @@ static VALUE rb_roaring32_min(VALUE self)
     }
 }
 
+// Find the largest integer in the bitmap
+// @return [Integer,nil] The largest integer in the bitmap, or `nil` if it is empty
 static VALUE rb_roaring32_max(VALUE self)
 {
     roaring_bitmap_t *data = get_bitmap(self);
@@ -170,12 +205,16 @@ static VALUE rb_roaring32_max(VALUE self)
     }
 }
 
+// Attemps to internally optimize the representation of bitmap by finding runs, consecutive sequences of integers.
+// @return [Boolean] whether the result has at least one run container
 static VALUE rb_roaring32_run_optimize(VALUE self)
 {
     roaring_bitmap_t *data = get_bitmap(self);
     return RBOOL(roaring_bitmap_run_optimize(data));
 }
 
+// Serializes a bitmap into a string
+// @return [string]
 static VALUE rb_roaring32_serialize(VALUE self)
 {
     roaring_bitmap_t *data = get_bitmap(self);
@@ -189,13 +228,58 @@ static VALUE rb_roaring32_serialize(VALUE self)
     return str;
 }
 
+// Loads a previously serialized bitmap
+// @param str [String] a string previously returned from {#serialize}
+// @raise [ArgumentError] if the string isn't a valid serialized bitmap
+// @return [Bitmap32]
 static VALUE rb_roaring32_deserialize(VALUE self, VALUE str)
 {
+    StringValue(str);
+
     roaring_bitmap_t *bitmap = roaring_bitmap_portable_deserialize_safe(RSTRING_PTR(str), RSTRING_LEN(str));
+    RB_GC_GUARD(str);
+
+    if (!bitmap) {
+        rb_raise(rb_eArgError, "invalid Roaring::Bitmap32 serialization");
+    }
 
     return TypedData_Wrap_Struct(cRoaringBitmap32, &roaring_type, bitmap);
 }
 
+// Provides statistics about the internal layout of the bitmap
+// @return [Hash]
+static VALUE rb_roaring32_statistics(VALUE self)
+{
+    roaring_bitmap_t *data = get_bitmap(self);
+
+    roaring_statistics_t stat;
+
+    roaring_bitmap_statistics(data, &stat);
+
+    VALUE ret = rb_hash_new();
+#define ADD_STAT(name) \
+    rb_hash_aset(ret, rb_id2sym(rb_intern(#name)), ULL2NUM(stat.name))
+
+    ADD_STAT(n_containers);
+    ADD_STAT(n_array_containers);
+    ADD_STAT(n_run_containers);
+    ADD_STAT(n_bitset_containers);
+    ADD_STAT(n_values_array_containers);
+    ADD_STAT(n_values_run_containers);
+    ADD_STAT(n_values_bitset_containers);
+    ADD_STAT(n_bytes_array_containers);
+    ADD_STAT(n_bytes_run_containers);
+    ADD_STAT(n_bytes_bitset_containers);
+    ADD_STAT(max_value);
+    ADD_STAT(min_value);
+    // ADD_STAT(sum_value); // deprecated, skipped
+    ADD_STAT(cardinality);
+
+#undef ADD_STAT
+
+    return ret;
+}
+
 typedef roaring_bitmap_t *binary_func(const roaring_bitmap_t *, const roaring_bitmap_t *);
 static VALUE rb_roaring32_binary_op(VALUE self, VALUE other, binary_func func) {
     roaring_bitmap_t *self_data = get_bitmap(self);
@@ -206,6 +290,16 @@ static VALUE rb_roaring32_binary_op(VALUE self, VALUE other, binary_func func) {
     return TypedData_Wrap_Struct(cRoaringBitmap32, &roaring_type, result);
 }
 
+typedef void binary_func_inplace(roaring_bitmap_t *, const roaring_bitmap_t *);
+static VALUE rb_roaring32_binary_op_inplace(VALUE self, VALUE other, binary_func_inplace func) {
+    roaring_bitmap_t *self_data = get_bitmap(self);
+    roaring_bitmap_t *other_data = get_bitmap(other);
+
+    func(self_data, other_data);
+
+    return self;
+}
+
 typedef bool binary_func_bool(const roaring_bitmap_t *, const roaring_bitmap_t *);
 static VALUE rb_roaring32_binary_op_bool(VALUE self, VALUE other, binary_func_bool func) {
     roaring_bitmap_t *self_data = get_bitmap(self);
@@ -215,42 +309,85 @@ static VALUE rb_roaring32_binary_op_bool(VALUE self, VALUE other, binary_func_bo
     return RBOOL(result);
 }
 
+// Inplace version of {and}
+// @return [self] the modified Bitmap
+static VALUE rb_roaring32_and_inplace(VALUE self, VALUE other)
+{
+    return rb_roaring32_binary_op_inplace(self, other, roaring_bitmap_and_inplace);
+}
+
+// Inplace version of {or}
+// @return [self] the modified Bitmap
+static VALUE rb_roaring32_or_inplace(VALUE self, VALUE other)
+{
+    return rb_roaring32_binary_op_inplace(self, other, roaring_bitmap_or_inplace);
+}
+
+// Inplace version of {xor}
+// @return [self] the modified Bitmap
+static VALUE rb_roaring32_xor_inplace(VALUE self, VALUE other)
+{
+    return rb_roaring32_binary_op_inplace(self, other, roaring_bitmap_xor_inplace);
+}
+
+// Inplace version of {andnot}
+// @return [self] the modified Bitmap
+static VALUE rb_roaring32_andnot_inplace(VALUE self, VALUE other)
+{
+    return rb_roaring32_binary_op_inplace(self, other, roaring_bitmap_andnot_inplace);
+}
 
+// Computes the intersection between two bitmaps
+// @return [Bitmap32] a new bitmap containing all elements in both `self` and `other`
 static VALUE rb_roaring32_and(VALUE self, VALUE other)
 {
     return rb_roaring32_binary_op(self, other, roaring_bitmap_and);
 }
 
+// Computes the union between two bitmaps
+// @return [Bitmap32] a new bitmap containing all elements in either `self` or `other`
 static VALUE rb_roaring32_or(VALUE self, VALUE other)
 {
     return rb_roaring32_binary_op(self, other, roaring_bitmap_or);
 }
 
+// Computes the exclusive or between two bitmaps
+// @return [Bitmap32] a new bitmap containing all elements in one of `self` or `other`, but not both
 static VALUE rb_roaring32_xor(VALUE self, VALUE other)
 {
     return rb_roaring32_binary_op(self, other, roaring_bitmap_xor);
 }
 
+// Computes the difference between two bitmaps
+// @return [Bitmap32] a new bitmap containing all elements in `self`, but not in `other`
 static VALUE rb_roaring32_andnot(VALUE self, VALUE other)
 {
     return rb_roaring32_binary_op(self, other, roaring_bitmap_andnot);
 }
 
+// Compare equality between two bitmaps
+// @return [Boolean] `true` if both bitmaps contain all the same elements, otherwise `false`
 static VALUE rb_roaring32_eq(VALUE self, VALUE other)
 {
     return rb_roaring32_binary_op_bool(self, other, roaring_bitmap_equals);
 }
 
+// Check if `self` is a strict subset of `other`. A strict subset requires every element in `self` is also in `other`, but they aren't exactly equal.
+// @return [Boolean] `true` if `self` is a strict subset of `other`, otherwise `false`
 static VALUE rb_roaring32_lt(VALUE self, VALUE other)
 {
     return rb_roaring32_binary_op_bool(self, other, roaring_bitmap_is_strict_subset);
 }
 
+// Check if `self` is a (non-strict) subset of `other`. A subset requires that every element in `self` is also in `other`. They may be equal.
+// @return [Boolean] `true` if `self` is a subset of `other`, otherwise `false`
 static VALUE rb_roaring32_lte(VALUE self, VALUE other)
 {
     return rb_roaring32_binary_op_bool(self, other, roaring_bitmap_is_subset);
 }
 
+// Checks whether `self` intersects `other`
+// @return [Boolean] `true` if `self` intersects `other`, otherwise `false`
 static VALUE rb_roaring32_intersect_p(VALUE self, VALUE other)
 {
     return rb_roaring32_binary_op_bool(self, other, roaring_bitmap_intersect);
@@ -267,17 +404,22 @@ rb_roaring32_init(void)
   rb_define_method(cRoaringBitmap32, "cardinality", rb_roaring32_cardinality, 0);
   rb_define_method(cRoaringBitmap32, "add", rb_roaring32_add, 1);
   rb_define_method(cRoaringBitmap32, "add?", rb_roaring32_add_p, 1);
-  rb_define_method(cRoaringBitmap32, "<<", rb_roaring32_add, 1);
+  rb_define_method(cRoaringBitmap32, "add_range_closed", rb_roaring32_add_range_closed, 2);
   rb_define_method(cRoaringBitmap32, "remove", rb_roaring32_remove, 1);
   rb_define_method(cRoaringBitmap32, "remove?", rb_roaring32_remove_p, 1);
   rb_define_method(cRoaringBitmap32, "include?", rb_roaring32_include_p, 1);
   rb_define_method(cRoaringBitmap32, "each", rb_roaring32_each, 0);
   rb_define_method(cRoaringBitmap32, "[]", rb_roaring32_aref, 1);
 
-  rb_define_method(cRoaringBitmap32, "&", rb_roaring32_and, 1);
-  rb_define_method(cRoaringBitmap32, "|", rb_roaring32_or, 1);
-  rb_define_method(cRoaringBitmap32, "^", rb_roaring32_xor, 1);
-  rb_define_method(cRoaringBitmap32, "-", rb_roaring32_andnot, 1);
+  rb_define_method(cRoaringBitmap32, "and!", rb_roaring32_and_inplace, 1);
+  rb_define_method(cRoaringBitmap32, "or!", rb_roaring32_or_inplace, 1);
+  rb_define_method(cRoaringBitmap32, "xor!", rb_roaring32_xor_inplace, 1);
+  rb_define_method(cRoaringBitmap32, "andnot!", rb_roaring32_andnot_inplace, 1);
+
+  rb_define_method(cRoaringBitmap32, "and", rb_roaring32_and, 1);
+  rb_define_method(cRoaringBitmap32, "or", rb_roaring32_or, 1);
+  rb_define_method(cRoaringBitmap32, "xor", rb_roaring32_xor, 1);
+  rb_define_method(cRoaringBitmap32, "andnot", rb_roaring32_andnot, 1);
 
   rb_define_method(cRoaringBitmap32, "==", rb_roaring32_eq, 1);
   rb_define_method(cRoaringBitmap32, "<", rb_roaring32_lt, 1);
@@ -288,6 +430,7 @@ rb_roaring32_init(void)
   rb_define_method(cRoaringBitmap32, "max", rb_roaring32_max, 0);
 
   rb_define_method(cRoaringBitmap32, "run_optimize", rb_roaring32_run_optimize, 0);
+  rb_define_method(cRoaringBitmap32, "statistics", rb_roaring32_statistics, 0);
 
   rb_define_method(cRoaringBitmap32, "serialize", rb_roaring32_serialize, 0);
   rb_define_singleton_method(cRoaringBitmap32, "deserialize", rb_roaring32_deserialize, 1);

data/ext/roaring/bitmap64.c

@@ -56,7 +56,7 @@ static VALUE rb_roaring64_replace(VALUE self, VALUE other) {
     // FIXME: Very likely a newer version of CRoaring will have
     //roaring64_bitmap_overwrite(self_data, other_data);
 
-    roaring64_bitmap_remove_range_closed(self_data, 0, UINT64_MAX);
+    roaring64_bitmap_clear(self_data);
     roaring64_bitmap_or_inplace(self_data, other_data);
 
     return self;
@@ -86,6 +86,18 @@ static VALUE rb_roaring64_add_p(VALUE self, VALUE val)
     return roaring64_bitmap_add_checked(data, num) ? self : Qnil;
 }
 
+static VALUE rb_roaring64_add_range_closed(VALUE self, VALUE minv, VALUE maxv)
+{
+    roaring64_bitmap_t *data = get_bitmap(self);
+
+    uint64_t min = NUM2UINT64(minv);
+    uint64_t max = NUM2UINT64(maxv);
+
+    roaring64_bitmap_add_range_closed(data, min, max);
+
+    return self;
+}
+
 static VALUE rb_roaring64_remove(VALUE self, VALUE val)
 {
     roaring64_bitmap_t *data = get_bitmap(self);
@@ -120,8 +132,7 @@ static VALUE rb_roaring64_empty_p(VALUE self)
 static VALUE rb_roaring64_clear(VALUE self)
 {
     roaring64_bitmap_t *data = get_bitmap(self);
-    // roaring64_bitmap_clear(data); // Doesn't exist yet in 4.0.0
-    roaring64_bitmap_remove_range_closed(data, 0, UINT64_MAX);
+    roaring64_bitmap_clear(data);
     return self;
 }
 
@@ -197,11 +208,50 @@ static VALUE rb_roaring64_serialize(VALUE self)
 
 static VALUE rb_roaring64_deserialize(VALUE self, VALUE str)
 {
+    StringValue(str);
+
     roaring64_bitmap_t *bitmap = roaring64_bitmap_portable_deserialize_safe(RSTRING_PTR(str), RSTRING_LEN(str));
+    RB_GC_GUARD(str);
+
+    if (!bitmap) {
+        rb_raise(rb_eArgError, "invalid Roaring::Bitmap64 serialization");
+    }
 
     return TypedData_Wrap_Struct(cRoaringBitmap64, &roaring64_type, bitmap);
 }
 
+static VALUE rb_roaring64_statistics(VALUE self)
+{
+    roaring64_bitmap_t *data = get_bitmap(self);
+
+    roaring64_statistics_t stat;
+
+    roaring64_bitmap_statistics(data, &stat);
+
+    VALUE ret = rb_hash_new();
+#define ADD_STAT(name) \
+    rb_hash_aset(ret, rb_id2sym(rb_intern(#name)), ULL2NUM(stat.name))
+
+    ADD_STAT(n_containers);
+    ADD_STAT(n_array_containers);
+    ADD_STAT(n_run_containers);
+    ADD_STAT(n_bitset_containers);
+    ADD_STAT(n_values_array_containers);
+    ADD_STAT(n_values_run_containers);
+    ADD_STAT(n_values_bitset_containers);
+    ADD_STAT(n_bytes_array_containers);
+    ADD_STAT(n_bytes_run_containers);
+    ADD_STAT(n_bytes_bitset_containers);
+    ADD_STAT(max_value);
+    ADD_STAT(min_value);
+    // ADD_STAT(sum_value); // deprecated, skipped
+    ADD_STAT(cardinality);
+
+#undef ADD_STAT
+
+    return ret;
+}
+
 typedef roaring64_bitmap_t *binary_func(const roaring64_bitmap_t *, const roaring64_bitmap_t *);
 static VALUE rb_roaring64_binary_op(VALUE self, VALUE other, binary_func func) {
     roaring64_bitmap_t *self_data = get_bitmap(self);
@@ -212,6 +262,16 @@ static VALUE rb_roaring64_binary_op(VALUE self, VALUE other, binary_func func) {
     return TypedData_Wrap_Struct(cRoaringBitmap64, &roaring64_type, result);
 }
 
+typedef void binary_func_inplace(roaring64_bitmap_t *, const roaring64_bitmap_t *);
+static VALUE rb_roaring64_binary_op_inplace(VALUE self, VALUE other, binary_func_inplace func) {
+    roaring64_bitmap_t *self_data = get_bitmap(self);
+    roaring64_bitmap_t *other_data = get_bitmap(other);
+
+    func(self_data, other_data);
+
+    return self;
+}
+
 typedef bool binary_func_bool(const roaring64_bitmap_t *, const roaring64_bitmap_t *);
 static VALUE rb_roaring64_binary_op_bool(VALUE self, VALUE other, binary_func_bool func) {
     roaring64_bitmap_t *self_data = get_bitmap(self);
@@ -221,6 +281,25 @@ static VALUE rb_roaring64_binary_op_bool(VALUE self, VALUE other, binary_func_bo
     return RBOOL(result);
 }
 
+static VALUE rb_roaring64_and_inplace(VALUE self, VALUE other)
+{
+    return rb_roaring64_binary_op_inplace(self, other, roaring64_bitmap_and_inplace);
+}
+
+static VALUE rb_roaring64_or_inplace(VALUE self, VALUE other)
+{
+    return rb_roaring64_binary_op_inplace(self, other, roaring64_bitmap_or_inplace);
+}
+
+static VALUE rb_roaring64_xor_inplace(VALUE self, VALUE other)
+{
+    return rb_roaring64_binary_op_inplace(self, other, roaring64_bitmap_xor_inplace);
+}
+
+static VALUE rb_roaring64_andnot_inplace(VALUE self, VALUE other)
+{
+    return rb_roaring64_binary_op_inplace(self, other, roaring64_bitmap_andnot_inplace);
+}
 
 static VALUE rb_roaring64_and(VALUE self, VALUE other)
 {
@@ -273,6 +352,7 @@ rb_roaring64_init(void)
   rb_define_method(cRoaringBitmap64, "cardinality", rb_roaring64_cardinality, 0);
   rb_define_method(cRoaringBitmap64, "add", rb_roaring64_add, 1);
   rb_define_method(cRoaringBitmap64, "add?", rb_roaring64_add_p, 1);
+  rb_define_method(cRoaringBitmap64, "add_range_closed", rb_roaring64_add_range_closed, 2);
   rb_define_method(cRoaringBitmap64, "<<", rb_roaring64_add, 1);
   rb_define_method(cRoaringBitmap64, "remove", rb_roaring64_remove, 1);
   rb_define_method(cRoaringBitmap64, "remove?", rb_roaring64_remove_p, 1);
@@ -280,10 +360,15 @@ rb_roaring64_init(void)
   rb_define_method(cRoaringBitmap64, "each", rb_roaring64_each, 0);
   rb_define_method(cRoaringBitmap64, "[]", rb_roaring64_aref, 1);
 
-  rb_define_method(cRoaringBitmap64, "&", rb_roaring64_and, 1);
-  rb_define_method(cRoaringBitmap64, "|", rb_roaring64_or, 1);
-  rb_define_method(cRoaringBitmap64, "^", rb_roaring64_xor, 1);
-  rb_define_method(cRoaringBitmap64, "-", rb_roaring64_andnot, 1);
+  rb_define_method(cRoaringBitmap64, "and!", rb_roaring64_and_inplace, 1);
+  rb_define_method(cRoaringBitmap64, "or!", rb_roaring64_or_inplace, 1);
+  rb_define_method(cRoaringBitmap64, "xor!", rb_roaring64_xor_inplace, 1);
+  rb_define_method(cRoaringBitmap64, "andnot!", rb_roaring64_andnot_inplace, 1);
+
+  rb_define_method(cRoaringBitmap64, "and", rb_roaring64_and, 1);
+  rb_define_method(cRoaringBitmap64, "or", rb_roaring64_or, 1);
+  rb_define_method(cRoaringBitmap64, "xor", rb_roaring64_xor, 1);
+  rb_define_method(cRoaringBitmap64, "andnot", rb_roaring64_andnot, 1);
 
   rb_define_method(cRoaringBitmap64, "==", rb_roaring64_eq, 1);
   rb_define_method(cRoaringBitmap64, "<", rb_roaring64_lt, 1);
@@ -294,6 +379,7 @@ rb_roaring64_init(void)
   rb_define_method(cRoaringBitmap64, "max", rb_roaring64_max, 0);
 
   rb_define_method(cRoaringBitmap64, "run_optimize", rb_roaring64_run_optimize, 0);
+  rb_define_method(cRoaringBitmap64, "statistics", rb_roaring64_statistics, 0);
 
   rb_define_method(cRoaringBitmap64, "serialize", rb_roaring64_serialize, 0);
   rb_define_singleton_method(cRoaringBitmap64, "deserialize", rb_roaring64_deserialize, 1);