annoy-rb 0.7.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1f1b7326f096ef01be709b819e6fcac709776e5561d931b8b8a5b022aed1dc2
-  data.tar.gz: e767849b0970773b1c01307b830d6bbf15c250d86a4716d809867dc0cf8f211d
+  metadata.gz: 25b6e3d18705801e5458c656517e57d5bb42fb42846bc4cde36107787bc0f506
+  data.tar.gz: caca0acd3a163bc4a0e09dfe7a30dfcd975d3b123f7bce76f44263545271d8d1
 SHA512:
-  metadata.gz: da4627d3414ed6ba062a3fb5d9ba546a32dced3e11d42ab4756badc219c29813b9d5389cbcb2159c027ad9a3b43c58f23f0f19660836c557d12c2c1b2a37330f
-  data.tar.gz: f195b96f9010a67ccc01088006a09e1ec5f857e7226f3d6b7c58a9ab5205757365061bbd1eb571715bfcd24a8f47c00e6aea7fcc1d7024f8cb6e511b7cb37255
+  metadata.gz: 5c8a5dca9dacb2004e17ac14c2e362424b40a1532ee785c17ba85e01b02a5c40e2defd352362b97e6098b3a69d7f5e62011dba62d7ddf47b4b81fa6cd4e482f9
+  data.tar.gz: e50f8d449dc142bb80c4caeab0c4450a80b1f3f0f0979d6a460f9115bbbc80fa6d934d006463ce8da04a10a17929ed125ffd985aadc8a50c5d6979dbe1be3026

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.7.2
+
+- Refactor native extension codes to set rb_data_type_t.wrap_struct_name for each metric and dtype.
+
 ## 0.7.1
 
 - Fix bug that item elements are converted to unsingned integers when dtype is set to float32 ([#3](https://github.com/yoshoku/annoy-rb/issues/3)).

data/ext/annoy/annoyext.cpp

@@ -1,7 +1,7 @@
 /**
  * Annoy.rb is a Ruby binding for the Annoy (Approximate Nearest Neighbors Oh Yeah).
  *
- * Copyright (c) 2020-2022 Atsushi Tatsuma
+ * Copyright (c) 2020-2023 Atsushi Tatsuma
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,14 +20,14 @@
 
 extern "C" void Init_annoyext(void) {
   VALUE rb_mAnnoy = rb_define_module("Annoy");
-  RbAnnoyIndex<AnnoyIndexAngular<double>, double>::define_class(rb_mAnnoy, "AnnoyIndexAngular");
-  RbAnnoyIndex<AnnoyIndexDotProduct<double>, double>::define_class(rb_mAnnoy, "AnnoyIndexDotProduct");
-  RbAnnoyIndex<AnnoyIndexHamming<uint64_t>, uint64_t>::define_class(rb_mAnnoy, "AnnoyIndexHamming");
-  RbAnnoyIndex<AnnoyIndexEuclidean<double>, double>::define_class(rb_mAnnoy, "AnnoyIndexEuclidean");
-  RbAnnoyIndex<AnnoyIndexManhattan<double>, double>::define_class(rb_mAnnoy, "AnnoyIndexManhattan");
+  RbAnnoyIndexAngular::define_class(rb_mAnnoy, "AnnoyIndexAngular");
+  RbAnnoyIndexDotProduct::define_class(rb_mAnnoy, "AnnoyIndexDotProduct");
+  RbAnnoyIndexHamming::define_class(rb_mAnnoy, "AnnoyIndexHamming");
+  RbAnnoyIndexEuclidean::define_class(rb_mAnnoy, "AnnoyIndexEuclidean");
+  RbAnnoyIndexManhattan::define_class(rb_mAnnoy, "AnnoyIndexManhattan");
 
-  RbAnnoyIndex<AnnoyIndexAngular<float>, float>::define_class(rb_mAnnoy, "AnnoyIndexAngularFloat32");
-  RbAnnoyIndex<AnnoyIndexDotProduct<float>, float>::define_class(rb_mAnnoy, "AnnoyIndexDotProductFloat32");
-  RbAnnoyIndex<AnnoyIndexEuclidean<float>, float>::define_class(rb_mAnnoy, "AnnoyIndexEuclideanFloat32");
-  RbAnnoyIndex<AnnoyIndexManhattan<float>, float>::define_class(rb_mAnnoy, "AnnoyIndexManhattanFloat32");
+  RbAnnoyIndexAngularFloat32::define_class(rb_mAnnoy, "AnnoyIndexAngularFloat32");
+  RbAnnoyIndexDotProductFloat32::define_class(rb_mAnnoy, "AnnoyIndexDotProductFloat32");
+  RbAnnoyIndexEuclideanFloat32::define_class(rb_mAnnoy, "AnnoyIndexEuclideanFloat32");
+  RbAnnoyIndexManhattanFloat32::define_class(rb_mAnnoy, "AnnoyIndexManhattanFloat32");
 }

data/ext/annoy/annoyext.hpp

@@ -1,7 +1,7 @@
 /**
  * Annoy.rb is a Ruby binding for the Annoy (Approximate Nearest Neighbors Oh Yeah).
  *
- * Copyright (c) 2020-2022 Atsushi Tatsuma
+ * Copyright (c) 2020-2023 Atsushi Tatsuma
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -35,31 +35,36 @@ typedef AnnoyIndexSingleThreadedBuildPolicy AnnoyIndexThreadedBuildPolicy;
 #endif
 
 // clang-format off
-template<typename F> using AnnoyIndexAngular = AnnoyIndex<int32_t, F, Angular, Kiss64Random, AnnoyIndexThreadedBuildPolicy>;
-template<typename F> using AnnoyIndexDotProduct = AnnoyIndex<int32_t, F, DotProduct, Kiss64Random, AnnoyIndexThreadedBuildPolicy>;
-template<typename F> using AnnoyIndexHamming = AnnoyIndex<int32_t, F, Hamming, Kiss64Random, AnnoyIndexThreadedBuildPolicy>;
-template<typename F> using AnnoyIndexEuclidean = AnnoyIndex<int32_t, F, Euclidean, Kiss64Random, AnnoyIndexThreadedBuildPolicy>;
-template<typename F> using AnnoyIndexManhattan = AnnoyIndex<int32_t, F, Manhattan, Kiss64Random, AnnoyIndexThreadedBuildPolicy>;
+template<typename El> using AnnoyIndexAngular = AnnoyIndex<int32_t, El, Angular, Kiss64Random, AnnoyIndexThreadedBuildPolicy>;
+template<typename El> using AnnoyIndexDotProduct = AnnoyIndex<int32_t, El, DotProduct, Kiss64Random, AnnoyIndexThreadedBuildPolicy>;
+template<typename El> using AnnoyIndexHamming = AnnoyIndex<int32_t, El, Hamming, Kiss64Random, AnnoyIndexThreadedBuildPolicy>;
+template<typename El> using AnnoyIndexEuclidean = AnnoyIndex<int32_t, El, Euclidean, Kiss64Random, AnnoyIndexThreadedBuildPolicy>;
+template<typename El> using AnnoyIndexManhattan = AnnoyIndex<int32_t, El, Manhattan, Kiss64Random, AnnoyIndexThreadedBuildPolicy>;
 // clang-format on
 
-template <class T, typename F> class RbAnnoyIndex {
+template <class Idx, typename El, class Impl>
+class RbAnnoyIndex {
 public:
+  // static const rb_data_type_t annoy_index_type;
+
   static VALUE annoy_index_alloc(VALUE self) {
-    T* ptr = (T*)ruby_xmalloc(sizeof(T));
-    new (ptr) T();
-    return TypedData_Wrap_Struct(self, &annoy_index_type, ptr);
+    Idx* ptr = (Idx*)ruby_xmalloc(sizeof(Idx));
+    new (ptr) Idx();
+    return TypedData_Wrap_Struct(self, &Impl::annoy_index_type, ptr);
   };
 
   static void annoy_index_free(void* ptr) {
-    ((T*)ptr)->~AnnoyIndex();
+    ((Idx*)ptr)->~AnnoyIndex();
     ruby_xfree(ptr);
   };
 
-  static size_t annoy_index_size(const void* ptr) { return sizeof(*((T*)ptr)); };
+  static size_t annoy_index_size(const void* ptr) {
+    return sizeof(*((Idx*)ptr));
+  };
 
-  static T* get_annoy_index(VALUE self) {
-    T* ptr;
-    TypedData_Get_Struct(self, T, &annoy_index_type, ptr);
+  static Idx* get_annoy_index(VALUE self) {
+    Idx* ptr;
+    TypedData_Get_Struct(self, Idx, &Impl::annoy_index_type, ptr);
     return ptr;
   };
 
@@ -86,12 +91,10 @@ public:
   };
 
 private:
-  static const rb_data_type_t annoy_index_type;
-
   static VALUE _annoy_index_init(VALUE self, VALUE _n_dims) {
     const int n_dims = NUM2INT(_n_dims);
-    T* ptr = get_annoy_index(self);
-    new (ptr) T(n_dims);
+    Idx* ptr = get_annoy_index(self);
+    new (ptr) Idx(n_dims);
     return Qnil;
   };
 
@@ -109,9 +112,9 @@ private:
       return Qfalse;
     }
 
-    F* vec = (F*)ruby_xmalloc(n_dims * sizeof(F));
+    El* vec = (El*)ruby_xmalloc(n_dims * sizeof(El));
     for (int i = 0; i < n_dims; i++) {
-      vec[i] = (F)(typeid(F) == typeid(uint64_t) ? NUM2UINT(rb_ary_entry(arr, i)) : NUM2DBL(rb_ary_entry(arr, i)));
+      vec[i] = (El)(typeid(El) == typeid(uint64_t) ? NUM2UINT(rb_ary_entry(arr, i)) : NUM2DBL(rb_ary_entry(arr, i)));
     }
 
     char* error;
@@ -180,7 +183,7 @@ private:
     const int search_k = NUM2INT(_search_k);
     const bool include_distances = _include_distances == Qtrue ? true : false;
     std::vector<int32_t> neighbors;
-    std::vector<F> distances;
+    std::vector<El> distances;
 
     get_annoy_index(self)->get_nns_by_item(idx, n_neighbors, search_k, &neighbors, include_distances ? &distances : NULL);
 
@@ -195,7 +198,7 @@ private:
       const int sz_distances = distances.size();
       VALUE distances_arr = rb_ary_new2(sz_distances);
       for (int i = 0; i < sz_distances; i++) {
-        rb_ary_store(distances_arr, i, typeid(F) == typeid(uint64_t) ? UINT2NUM(distances[i]) : DBL2NUM(distances[i]));
+        rb_ary_store(distances_arr, i, typeid(El) == typeid(uint64_t) ? UINT2NUM(distances[i]) : DBL2NUM(distances[i]));
       }
       VALUE res = rb_ary_new2(2);
       rb_ary_store(res, 0, neighbors_arr);
@@ -220,16 +223,16 @@ private:
       return Qfalse;
     }
 
-    F* vec = (F*)ruby_xmalloc(n_dims * sizeof(F));
+    El* vec = (El*)ruby_xmalloc(n_dims * sizeof(El));
     for (int i = 0; i < n_dims; i++) {
-      vec[i] = (F)(typeid(F) == typeid(uint64_t) ? NUM2UINT(rb_ary_entry(_vec, i)) : NUM2DBL(rb_ary_entry(_vec, i)));
+      vec[i] = (El)(typeid(El) == typeid(uint64_t) ? NUM2UINT(rb_ary_entry(_vec, i)) : NUM2DBL(rb_ary_entry(_vec, i)));
     }
 
     const int n_neighbors = NUM2INT(_n_neighbors);
     const int search_k = NUM2INT(_search_k);
     const bool include_distances = _include_distances == Qtrue ? true : false;
     std::vector<int32_t> neighbors;
-    std::vector<F> distances;
+    std::vector<El> distances;
 
     get_annoy_index(self)->get_nns_by_vector(vec, n_neighbors, search_k, &neighbors, include_distances ? &distances : NULL);
 
@@ -246,7 +249,7 @@ private:
       const int sz_distances = distances.size();
       VALUE distances_arr = rb_ary_new2(sz_distances);
       for (int i = 0; i < sz_distances; i++) {
-        rb_ary_store(distances_arr, i, typeid(F) == typeid(uint64_t) ? UINT2NUM(distances[i]) : DBL2NUM(distances[i]));
+        rb_ary_store(distances_arr, i, typeid(El) == typeid(uint64_t) ? UINT2NUM(distances[i]) : DBL2NUM(distances[i]));
       }
       VALUE res = rb_ary_new2(2);
       rb_ary_store(res, 0, neighbors_arr);
@@ -260,13 +263,13 @@ private:
   static VALUE _annoy_index_get_item(VALUE self, VALUE _idx) {
     const int32_t idx = (int32_t)NUM2INT(_idx);
     const int n_dims = get_annoy_index(self)->get_f();
-    F* vec = (F*)ruby_xmalloc(n_dims * sizeof(F));
+    El* vec = (El*)ruby_xmalloc(n_dims * sizeof(El));
     VALUE arr = rb_ary_new2(n_dims);
 
     get_annoy_index(self)->get_item(idx, vec);
 
     for (int i = 0; i < n_dims; i++) {
-      rb_ary_store(arr, i, typeid(F) == typeid(uint64_t) ? UINT2NUM(vec[i]) : DBL2NUM(vec[i]));
+      rb_ary_store(arr, i, typeid(El) == typeid(uint64_t) ? UINT2NUM(vec[i]) : DBL2NUM(vec[i]));
     }
 
     ruby_xfree(vec);
@@ -276,8 +279,8 @@ private:
   static VALUE _annoy_index_get_distance(VALUE self, VALUE _i, VALUE _j) {
     const int32_t i = (int32_t)NUM2INT(_i);
     const int32_t j = (int32_t)NUM2INT(_j);
-    const F dist = get_annoy_index(self)->get_distance(i, j);
-    return typeid(F) == typeid(uint64_t) ? UINT2NUM(dist) : DBL2NUM(dist);
+    const El dist = get_annoy_index(self)->get_distance(i, j);
+    return typeid(El) == typeid(uint64_t) ? UINT2NUM(dist) : DBL2NUM(dist);
   };
 
   static VALUE _annoy_index_get_n_items(VALUE self) {
@@ -321,19 +324,85 @@ private:
   };
 };
 
-// clang-format off
-template<class T, typename F>
-const rb_data_type_t RbAnnoyIndex<T, F>::annoy_index_type = {
-  "RbAnnoyIndex",
-  {
-    NULL,
-    RbAnnoyIndex::annoy_index_free,
-    RbAnnoyIndex::annoy_index_size
-  },
-  NULL,
-  NULL,
-  RUBY_TYPED_FREE_IMMEDIATELY
+class RbAnnoyIndexAngular : public RbAnnoyIndex<AnnoyIndexAngular<double>, double, RbAnnoyIndexAngular> {
+public:
+  static const rb_data_type_t annoy_index_type;
+};
+
+const rb_data_type_t RbAnnoyIndexAngular::annoy_index_type = {
+  "RbAnnoyIndexAngular", { NULL, RbAnnoyIndexAngular::annoy_index_free, RbAnnoyIndexAngular::annoy_index_size }, NULL, NULL, 0
+};
+
+class RbAnnoyIndexDotProduct : public RbAnnoyIndex<AnnoyIndexDotProduct<double>, double, RbAnnoyIndexDotProduct> {
+public:
+  static const rb_data_type_t annoy_index_type;
+};
+
+const rb_data_type_t RbAnnoyIndexDotProduct::annoy_index_type = {
+  "RbAnnoyIndexDotProduct", { NULL, RbAnnoyIndexDotProduct::annoy_index_free, RbAnnoyIndexDotProduct::annoy_index_size }, NULL, NULL, 0
+};
+
+class RbAnnoyIndexHamming : public RbAnnoyIndex<AnnoyIndexHamming<uint64_t>, uint64_t, RbAnnoyIndexHamming> {
+public:
+  static const rb_data_type_t annoy_index_type;
+};
+
+const rb_data_type_t RbAnnoyIndexHamming::annoy_index_type = {
+  "RbAnnoyIndexHamming", { NULL, RbAnnoyIndexHamming::annoy_index_free, RbAnnoyIndexHamming::annoy_index_size }, NULL, NULL, 0
+};
+
+class RbAnnoyIndexEuclidean : public RbAnnoyIndex<AnnoyIndexEuclidean<double>, double, RbAnnoyIndexEuclidean> {
+public:
+  static const rb_data_type_t annoy_index_type;
+};
+
+const rb_data_type_t RbAnnoyIndexEuclidean::annoy_index_type = {
+  "RbAnnoyIndexEuclidean", { NULL, RbAnnoyIndexEuclidean::annoy_index_free, RbAnnoyIndexEuclidean::annoy_index_size }, NULL, NULL, 0
+};
+
+class RbAnnoyIndexManhattan : public RbAnnoyIndex<AnnoyIndexManhattan<double>, double, RbAnnoyIndexManhattan> {
+public:
+  static const rb_data_type_t annoy_index_type;
+};
+
+const rb_data_type_t RbAnnoyIndexManhattan::annoy_index_type = {
+  "RbAnnoyIndexManhattan", { NULL, RbAnnoyIndexManhattan::annoy_index_free, RbAnnoyIndexManhattan::annoy_index_size }, NULL, NULL, 0
+};
+
+class RbAnnoyIndexAngularFloat32 : public RbAnnoyIndex<AnnoyIndexAngular<float>, float, RbAnnoyIndexAngularFloat32> {
+public:
+  static const rb_data_type_t annoy_index_type;
+};
+
+const rb_data_type_t RbAnnoyIndexAngularFloat32::annoy_index_type = {
+  "RbAnnoyIndexAngularFloat32", { NULL, RbAnnoyIndexAngularFloat32::annoy_index_free, RbAnnoyIndexAngularFloat32::annoy_index_size }, NULL, NULL, 0
+};
+
+class RbAnnoyIndexDotProductFloat32 : public RbAnnoyIndex<AnnoyIndexDotProduct<float>, float, RbAnnoyIndexDotProductFloat32> {
+public:
+  static const rb_data_type_t annoy_index_type;
+};
+
+const rb_data_type_t RbAnnoyIndexDotProductFloat32::annoy_index_type = {
+  "RbAnnoyIndexDotProductFloat32", { NULL, RbAnnoyIndexDotProductFloat32::annoy_index_free, RbAnnoyIndexDotProductFloat32::annoy_index_size }, NULL, NULL, 0
+};
+
+class RbAnnoyIndexEuclideanFloat32 : public RbAnnoyIndex<AnnoyIndexEuclidean<float>, float, RbAnnoyIndexEuclideanFloat32> {
+public:
+  static const rb_data_type_t annoy_index_type;
+};
+
+const rb_data_type_t RbAnnoyIndexEuclideanFloat32::annoy_index_type = {
+  "RbAnnoyIndexEuclideanFloat32", { NULL, RbAnnoyIndexEuclideanFloat32::annoy_index_free, RbAnnoyIndexEuclideanFloat32::annoy_index_size }, NULL, NULL, 0
+};
+
+class RbAnnoyIndexManhattanFloat32 : public RbAnnoyIndex<AnnoyIndexManhattan<float>, float, RbAnnoyIndexManhattanFloat32> {
+public:
+  static const rb_data_type_t annoy_index_type;
+};
+
+const rb_data_type_t RbAnnoyIndexManhattanFloat32::annoy_index_type = {
+  "RbAnnoyIndexManhattanFloat32", { NULL, RbAnnoyIndexManhattanFloat32::annoy_index_free, RbAnnoyIndexManhattanFloat32::annoy_index_size }, NULL, NULL, 0
 };
-// clang-format on
 
 #endif /* ANNOYEXT_HPP */

data/lib/annoy/version.rb

@@ -3,7 +3,7 @@
 # Annoy.rb is a Ruby wrapper for Annoy (Approximate Nearest Neighbors Oh Yeah).
 module Annoy
   # The version of Annoy.rb you are using.
-  VERSION = '0.7.1'
+  VERSION = '0.7.2'
 
   # The version of Annoy included with gem.
   ANNOY_VERSION = '1.17.1'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: annoy-rb
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.2
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-30 00:00:00.000000000 Z
+date: 2023-02-05 00:00:00.000000000 Z
 dependencies: []
 description: Annoy.rb provides Ruby bindings for the Annoy (Approximate Nearest Neighbors
   Oh Yeah).
@@ -57,7 +57,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: Ruby bindings for the Annoy (Approximate Nearest Neighbors Oh Yeah).