roaring 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e08dfb8d63633ed830e1d06d55ca7fd7b765d980c95bc7615f9fa72687cfe473
-  data.tar.gz: 89ad77599782c197c0bce64b8c8f3de67faca0663de40254d29de4499701293f
+  metadata.gz: 0e21e62ddcac0d57cf83948329add1ead73e1299adc691b57dd940e7e5ca5306
+  data.tar.gz: 1367042b6b8d27c24f9e124cf8c081bc18aa153e4431cb6339181c65904dbb68
 SHA512:
-  metadata.gz: 5304e68fb92cf65f91a14f2febd49746a6f84a858816d2c5dfb4c45ed025e079d62d509532c24f58b53314c26b370f25090c08d18a30e0030f317c76679d0a79
-  data.tar.gz: d132d47dbcb586a0db6e8204e42bd71f2512de670e004b05c5b9068f2f096e0551c9c43cb7283b9536c28c49754a95bfe2a79ba7514a7bff1611e47d426c5e23
+  metadata.gz: 3b94ccd487a8b5e28b6130e25a759f4ab1d226670cb30063cede4c5815a19c69481a5a5f7bbfafc6ebbca6e55fdf6e85166e63f0c5fe13a82bfeaba3d107ec7d
+  data.tar.gz: 9735a5df2fff46c07e917fc4cbd421fbff2bcca9304cf0da3f70c9f9e0ea12ed54447280b7a17b18f9d5a43a0f178f2d6fd840d5017dc80494b1f7add81ee242

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    roaring (0.1.0)
+    roaring (0.3.0)
 
 GEM
   remote: https://rubygems.org/

data/Rakefile

@@ -17,4 +17,14 @@ Rake::ExtensionTask.new("roaring") do |ext|
   ext.lib_dir = "lib/roaring"
 end
 
-task default: %i[clobber compile test]
+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
+end
+
+task default: %i[compile test]

data/ext/roaring/bitmap32.c

@@ -0,0 +1,294 @@
+#include "roaring_ruby.h"
+
+#include <stdio.h>
+
+static VALUE cRoaringBitmap32;
+
+static inline uint32_t
+NUM2UINT32(VALUE num) {
+    if (!FIXNUM_P(num) && !RB_TYPE_P(num, T_BIGNUM)) {
+        rb_raise(rb_eTypeError, "wrong argument type %s (expected Integer)", rb_obj_classname(num));
+    } else if ((SIGNED_VALUE)num < (SIGNED_VALUE)INT2FIX(0)) {
+        rb_raise(rb_eRangeError, "Integer %"PRIdVALUE " must be >= 0 to use with Roaring::Bitmap", num);
+    } else {
+        return FIX2UINT(num);
+    }
+}
+
+static void rb_roaring32_free(void *data)
+{
+    roaring_bitmap_free(data);
+}
+
+static size_t rb_roaring32_memsize(const void *data)
+{
+    // This is probably an estimate, "frozen" refers to the "frozen"
+    // serialization format, which mimics the in-memory representation.
+    return sizeof(roaring_bitmap_t) + roaring_bitmap_frozen_size_in_bytes(data);
+}
+
+static const rb_data_type_t roaring_type = {
+    .wrap_struct_name = "roaring/bitmap",
+    .function = {
+        .dfree = rb_roaring32_free,
+        .dsize = rb_roaring32_memsize
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE rb_roaring32_alloc(VALUE self)
+{
+    roaring_bitmap_t *data = roaring_bitmap_create();
+    return TypedData_Wrap_Struct(self, &roaring_type, data);
+}
+
+static roaring_bitmap_t *get_bitmap(VALUE obj) {
+    roaring_bitmap_t *bitmap;
+    TypedData_Get_Struct(obj, roaring_bitmap_t, &roaring_type, bitmap);
+    return 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);
+
+    roaring_bitmap_overwrite(self_data, other_data);
+
+    return self;
+}
+
+static VALUE rb_roaring32_cardinality(VALUE self)
+{
+    roaring_bitmap_t *data = get_bitmap(self);
+    uint64_t cardinality = roaring_bitmap_get_cardinality(data);
+    return ULONG2NUM(cardinality);
+}
+
+static VALUE rb_roaring32_add(VALUE self, VALUE val)
+{
+    roaring_bitmap_t *data = get_bitmap(self);
+
+    uint32_t num = NUM2UINT32(val);
+    roaring_bitmap_add(data, num);
+    return self;
+}
+
+static VALUE rb_roaring32_add_p(VALUE self, VALUE val)
+{
+    roaring_bitmap_t *data = get_bitmap(self);
+
+    uint32_t num = NUM2UINT32(val);
+    return roaring_bitmap_add_checked(data, num) ? self : Qnil;
+}
+
+static VALUE rb_roaring32_remove(VALUE self, VALUE val)
+{
+    roaring_bitmap_t *data = get_bitmap(self);
+
+    uint32_t num = NUM2UINT32(val);
+    roaring_bitmap_remove(data, num);
+    return self;
+}
+
+static VALUE rb_roaring32_remove_p(VALUE self, VALUE val)
+{
+    roaring_bitmap_t *data = get_bitmap(self);
+
+    uint32_t num = NUM2UINT32(val);
+    return roaring_bitmap_remove_checked(data, num) ? self : Qnil;
+}
+
+static VALUE rb_roaring32_include_p(VALUE self, VALUE val)
+{
+    roaring_bitmap_t *data = get_bitmap(self);
+
+    uint32_t num = NUM2UINT32(val);
+    return RBOOL(roaring_bitmap_contains(data, num));
+}
+
+static VALUE rb_roaring32_empty_p(VALUE self)
+{
+    roaring_bitmap_t *data = get_bitmap(self);
+    return RBOOL(roaring_bitmap_is_empty(data));
+}
+
+static VALUE rb_roaring32_clear(VALUE self)
+{
+    roaring_bitmap_t *data = get_bitmap(self);
+    roaring_bitmap_clear(data);
+    return self;
+}
+
+bool rb_roaring32_each_i(uint32_t value, void *param) {
+    rb_yield(UINT2NUM(value));
+    return true;  // iterate till the end
+}
+
+static VALUE rb_roaring32_each(VALUE self)
+{
+    roaring_bitmap_t *data = get_bitmap(self);
+    roaring_iterate(data, rb_roaring32_each_i, NULL);
+    return self;
+}
+
+static VALUE rb_roaring32_aref(VALUE self, VALUE rankv)
+{
+    roaring_bitmap_t *data = get_bitmap(self);
+
+    uint32_t rank = NUM2UINT32(rankv);
+    uint32_t val;
+
+    if (roaring_bitmap_select(data, rank, &val)) {
+        return UINT2NUM(val);
+    } else {
+        return Qnil;
+    }
+    return self;
+}
+
+static VALUE rb_roaring32_min(VALUE self)
+{
+    roaring_bitmap_t *data = get_bitmap(self);
+
+    if (roaring_bitmap_is_empty(data)) {
+        return Qnil;
+    } else {
+        uint32_t val = roaring_bitmap_minimum(data);
+        return UINT2NUM(val);
+    }
+}
+
+static VALUE rb_roaring32_max(VALUE self)
+{
+    roaring_bitmap_t *data = get_bitmap(self);
+
+    if (roaring_bitmap_is_empty(data)) {
+        return Qnil;
+    } else {
+        uint32_t val = roaring_bitmap_maximum(data);
+        return UINT2NUM(val);
+    }
+}
+
+static VALUE rb_roaring32_run_optimize(VALUE self)
+{
+    roaring_bitmap_t *data = get_bitmap(self);
+    return RBOOL(roaring_bitmap_run_optimize(data));
+}
+
+static VALUE rb_roaring32_serialize(VALUE self)
+{
+    roaring_bitmap_t *data = get_bitmap(self);
+
+    size_t size = roaring_bitmap_portable_size_in_bytes(data);
+    VALUE str = rb_str_buf_new(size);
+
+    size_t written = roaring_bitmap_portable_serialize(data, RSTRING_PTR(str));
+    rb_str_set_len(str, written);
+
+    return str;
+}
+
+static VALUE rb_roaring32_deserialize(VALUE self, VALUE str)
+{
+    roaring_bitmap_t *bitmap = roaring_bitmap_portable_deserialize_safe(RSTRING_PTR(str), RSTRING_LEN(str));
+
+    return TypedData_Wrap_Struct(cRoaringBitmap32, &roaring_type, bitmap);
+}
+
+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);
+    roaring_bitmap_t *other_data = get_bitmap(other);
+
+    roaring_bitmap_t *result = func(self_data, other_data);
+
+    return TypedData_Wrap_Struct(cRoaringBitmap32, &roaring_type, result);
+}
+
+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);
+    roaring_bitmap_t *other_data = get_bitmap(other);
+
+    bool result = func(self_data, other_data);
+    return RBOOL(result);
+}
+
+
+static VALUE rb_roaring32_and(VALUE self, VALUE other)
+{
+    return rb_roaring32_binary_op(self, other, roaring_bitmap_and);
+}
+
+static VALUE rb_roaring32_or(VALUE self, VALUE other)
+{
+    return rb_roaring32_binary_op(self, other, roaring_bitmap_or);
+}
+
+static VALUE rb_roaring32_xor(VALUE self, VALUE other)
+{
+    return rb_roaring32_binary_op(self, other, roaring_bitmap_xor);
+}
+
+static VALUE rb_roaring32_andnot(VALUE self, VALUE other)
+{
+    return rb_roaring32_binary_op(self, other, roaring_bitmap_andnot);
+}
+
+static VALUE rb_roaring32_eq(VALUE self, VALUE other)
+{
+    return rb_roaring32_binary_op_bool(self, other, roaring_bitmap_equals);
+}
+
+static VALUE rb_roaring32_lt(VALUE self, VALUE other)
+{
+    return rb_roaring32_binary_op_bool(self, other, roaring_bitmap_is_strict_subset);
+}
+
+static VALUE rb_roaring32_lte(VALUE self, VALUE other)
+{
+    return rb_roaring32_binary_op_bool(self, other, roaring_bitmap_is_subset);
+}
+
+static VALUE rb_roaring32_intersect_p(VALUE self, VALUE other)
+{
+    return rb_roaring32_binary_op_bool(self, other, roaring_bitmap_intersect);
+}
+
+void
+rb_roaring32_init(void)
+{
+  cRoaringBitmap32 = rb_define_class_under(rb_mRoaring, "Bitmap32", rb_cObject);
+  rb_define_alloc_func(cRoaringBitmap32, rb_roaring32_alloc);
+  rb_define_method(cRoaringBitmap32, "replace", rb_roaring32_replace, 1);
+  rb_define_method(cRoaringBitmap32, "empty?", rb_roaring32_empty_p, 0);
+  rb_define_method(cRoaringBitmap32, "clear", rb_roaring32_clear, 0);
+  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, "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, "==", rb_roaring32_eq, 1);
+  rb_define_method(cRoaringBitmap32, "<", rb_roaring32_lt, 1);
+  rb_define_method(cRoaringBitmap32, "<=", rb_roaring32_lte, 1);
+  rb_define_method(cRoaringBitmap32, "intersect?", rb_roaring32_intersect_p, 1);
+
+  rb_define_method(cRoaringBitmap32, "min", rb_roaring32_min, 0);
+  rb_define_method(cRoaringBitmap32, "max", rb_roaring32_max, 0);
+
+  rb_define_method(cRoaringBitmap32, "run_optimize", rb_roaring32_run_optimize, 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

@@ -0,0 +1,300 @@
+#include "roaring_ruby.h"
+
+#include <stdio.h>
+
+static VALUE cRoaringBitmap64;
+
+static inline uint64_t
+NUM2UINT64(VALUE num) {
+    if (!FIXNUM_P(num) && !RB_TYPE_P(num, T_BIGNUM)) {
+        rb_raise(rb_eTypeError, "wrong argument type %s (expected Integer)", rb_obj_classname(num));
+    } else if ((SIGNED_VALUE)num < (SIGNED_VALUE)INT2FIX(0)) {
+        rb_raise(rb_eRangeError, "Integer %"PRIdVALUE " must be >= 0 to use with Roaring::Bitmap32", num);
+    } else {
+        return NUM2ULL(num);
+    }
+}
+
+static void rb_roaring64_free(void *data)
+{
+    roaring64_bitmap_free(data);
+}
+
+static size_t rb_roaring64_memsize(const void *data)
+{
+    // This is probably an estimate, "frozen" refers to the "frozen"
+    // serialization format, which mimics the in-memory representation.
+    //return sizeof(roaring64_bitmap_t) + roaring64_bitmap_frozen_size_in_bytes(data);
+    return 0;
+}
+
+static const rb_data_type_t roaring64_type = {
+    .wrap_struct_name = "roaring/bitmap64",
+    .function = {
+        .dfree = rb_roaring64_free,
+        .dsize = rb_roaring64_memsize
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE rb_roaring64_alloc(VALUE self)
+{
+    roaring64_bitmap_t *data = roaring64_bitmap_create();
+    return TypedData_Wrap_Struct(self, &roaring64_type, data);
+}
+
+static roaring64_bitmap_t *get_bitmap(VALUE obj) {
+    roaring64_bitmap_t *bitmap;
+    TypedData_Get_Struct(obj, roaring64_bitmap_t, &roaring64_type, bitmap);
+    return bitmap;
+}
+
+static VALUE rb_roaring64_replace(VALUE self, VALUE other) {
+    roaring64_bitmap_t *self_data = get_bitmap(self);
+    roaring64_bitmap_t *other_data = get_bitmap(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_or_inplace(self_data, other_data);
+
+    return self;
+}
+
+static VALUE rb_roaring64_cardinality(VALUE self)
+{
+    roaring64_bitmap_t *data = get_bitmap(self);
+    uint64_t cardinality = roaring64_bitmap_get_cardinality(data);
+    return ULONG2NUM(cardinality);
+}
+
+static VALUE rb_roaring64_add(VALUE self, VALUE val)
+{
+    roaring64_bitmap_t *data = get_bitmap(self);
+
+    uint64_t num = NUM2UINT64(val);
+    roaring64_bitmap_add(data, num);
+    return self;
+}
+
+static VALUE rb_roaring64_add_p(VALUE self, VALUE val)
+{
+    roaring64_bitmap_t *data = get_bitmap(self);
+
+    uint64_t num = NUM2UINT64(val);
+    return roaring64_bitmap_add_checked(data, num) ? self : Qnil;
+}
+
+static VALUE rb_roaring64_remove(VALUE self, VALUE val)
+{
+    roaring64_bitmap_t *data = get_bitmap(self);
+
+    uint64_t num = NUM2UINT64(val);
+    roaring64_bitmap_remove(data, num);
+    return self;
+}
+
+static VALUE rb_roaring64_remove_p(VALUE self, VALUE val)
+{
+    roaring64_bitmap_t *data = get_bitmap(self);
+
+    uint64_t num = NUM2UINT64(val);
+    return roaring64_bitmap_remove_checked(data, num) ? self : Qnil;
+}
+
+static VALUE rb_roaring64_include_p(VALUE self, VALUE val)
+{
+    roaring64_bitmap_t *data = get_bitmap(self);
+
+    uint64_t num = NUM2UINT64(val);
+    return RBOOL(roaring64_bitmap_contains(data, num));
+}
+
+static VALUE rb_roaring64_empty_p(VALUE self)
+{
+    roaring64_bitmap_t *data = get_bitmap(self);
+    return RBOOL(roaring64_bitmap_is_empty(data));
+}
+
+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);
+    return self;
+}
+
+bool rb_roaring64_each_i(uint64_t value, void *param) {
+    rb_yield(ULL2NUM(value));
+    return true;  // iterate till the end
+}
+
+static VALUE rb_roaring64_each(VALUE self)
+{
+    roaring64_bitmap_t *data = get_bitmap(self);
+    roaring64_bitmap_iterate(data, rb_roaring64_each_i, NULL);
+    return self;
+}
+
+static VALUE rb_roaring64_aref(VALUE self, VALUE rankv)
+{
+    roaring64_bitmap_t *data = get_bitmap(self);
+
+    uint64_t rank = NUM2UINT64(rankv);
+    uint64_t val;
+
+    if (roaring64_bitmap_select(data, rank, &val)) {
+        return ULL2NUM(val);
+    } else {
+        return Qnil;
+    }
+    return self;
+}
+
+static VALUE rb_roaring64_min(VALUE self)
+{
+    roaring64_bitmap_t *data = get_bitmap(self);
+
+    if (roaring64_bitmap_is_empty(data)) {
+        return Qnil;
+    } else {
+        uint64_t val = roaring64_bitmap_minimum(data);
+        return ULL2NUM(val);
+    }
+}
+
+static VALUE rb_roaring64_max(VALUE self)
+{
+    roaring64_bitmap_t *data = get_bitmap(self);
+
+    if (roaring64_bitmap_is_empty(data)) {
+        return Qnil;
+    } else {
+        uint64_t val = roaring64_bitmap_maximum(data);
+        return ULL2NUM(val);
+    }
+}
+
+static VALUE rb_roaring64_run_optimize(VALUE self)
+{
+    roaring64_bitmap_t *data = get_bitmap(self);
+    return RBOOL(roaring64_bitmap_run_optimize(data));
+}
+
+static VALUE rb_roaring64_serialize(VALUE self)
+{
+    roaring64_bitmap_t *data = get_bitmap(self);
+
+    size_t size = roaring64_bitmap_portable_size_in_bytes(data);
+    VALUE str = rb_str_buf_new(size);
+
+    size_t written = roaring64_bitmap_portable_serialize(data, RSTRING_PTR(str));
+    rb_str_set_len(str, written);
+
+    return str;
+}
+
+static VALUE rb_roaring64_deserialize(VALUE self, VALUE str)
+{
+    roaring64_bitmap_t *bitmap = roaring64_bitmap_portable_deserialize_safe(RSTRING_PTR(str), RSTRING_LEN(str));
+
+    return TypedData_Wrap_Struct(cRoaringBitmap64, &roaring64_type, bitmap);
+}
+
+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);
+    roaring64_bitmap_t *other_data = get_bitmap(other);
+
+    roaring64_bitmap_t *result = func(self_data, other_data);
+
+    return TypedData_Wrap_Struct(cRoaringBitmap64, &roaring64_type, result);
+}
+
+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);
+    roaring64_bitmap_t *other_data = get_bitmap(other);
+
+    bool result = func(self_data, other_data);
+    return RBOOL(result);
+}
+
+
+static VALUE rb_roaring64_and(VALUE self, VALUE other)
+{
+    return rb_roaring64_binary_op(self, other, roaring64_bitmap_and);
+}
+
+static VALUE rb_roaring64_or(VALUE self, VALUE other)
+{
+    return rb_roaring64_binary_op(self, other, roaring64_bitmap_or);
+}
+
+static VALUE rb_roaring64_xor(VALUE self, VALUE other)
+{
+    return rb_roaring64_binary_op(self, other, roaring64_bitmap_xor);
+}
+
+static VALUE rb_roaring64_andnot(VALUE self, VALUE other)
+{
+    return rb_roaring64_binary_op(self, other, roaring64_bitmap_andnot);
+}
+
+static VALUE rb_roaring64_eq(VALUE self, VALUE other)
+{
+    return rb_roaring64_binary_op_bool(self, other, roaring64_bitmap_equals);
+}
+
+static VALUE rb_roaring64_lt(VALUE self, VALUE other)
+{
+    return rb_roaring64_binary_op_bool(self, other, roaring64_bitmap_is_strict_subset);
+}
+
+static VALUE rb_roaring64_lte(VALUE self, VALUE other)
+{
+    return rb_roaring64_binary_op_bool(self, other, roaring64_bitmap_is_subset);
+}
+
+static VALUE rb_roaring64_intersect_p(VALUE self, VALUE other)
+{
+    return rb_roaring64_binary_op_bool(self, other, roaring64_bitmap_intersect);
+}
+
+void
+rb_roaring64_init(void)
+{
+  cRoaringBitmap64 = rb_define_class_under(rb_mRoaring, "Bitmap64", rb_cObject);
+  rb_define_alloc_func(cRoaringBitmap64, rb_roaring64_alloc);
+  rb_define_method(cRoaringBitmap64, "replace", rb_roaring64_replace, 1);
+  rb_define_method(cRoaringBitmap64, "empty?", rb_roaring64_empty_p, 0);
+  rb_define_method(cRoaringBitmap64, "clear", rb_roaring64_clear, 0);
+  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, "<<", rb_roaring64_add, 1);
+  rb_define_method(cRoaringBitmap64, "remove", rb_roaring64_remove, 1);
+  rb_define_method(cRoaringBitmap64, "remove?", rb_roaring64_remove_p, 1);
+  rb_define_method(cRoaringBitmap64, "include?", rb_roaring64_include_p, 1);
+  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, "==", rb_roaring64_eq, 1);
+  rb_define_method(cRoaringBitmap64, "<", rb_roaring64_lt, 1);
+  rb_define_method(cRoaringBitmap64, "<=", rb_roaring64_lte, 1);
+  rb_define_method(cRoaringBitmap64, "intersect?", rb_roaring64_intersect_p, 1);
+
+  rb_define_method(cRoaringBitmap64, "min", rb_roaring64_min, 0);
+  rb_define_method(cRoaringBitmap64, "max", rb_roaring64_max, 0);
+
+  rb_define_method(cRoaringBitmap64, "run_optimize", rb_roaring64_run_optimize, 0);
+
+  rb_define_method(cRoaringBitmap64, "serialize", rb_roaring64_serialize, 0);
+  rb_define_singleton_method(cRoaringBitmap64, "deserialize", rb_roaring64_deserialize, 1);
+}