hnswlib 0.7.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a564835f983f6c07a04d62e198aac0b2a80eef8eaa784a14d3d7bdc5dadaa962
-  data.tar.gz: 98cc90158fbe92a012a6e0f945a1c82cd3bbfc1ae973cf1c4c1eccf95c249fed
+  metadata.gz: 33dd2f9cd8656dfe469b4b9baf319ae4e0b78826dec58da8ae78516077a6fbc2
+  data.tar.gz: ad32e54a325136587ae12716243b88ed1269c7bc9cd4e92e9aa8896b2517d4d2
 SHA512:
-  metadata.gz: ada8080314124e768aba55385f92c98a8e1206932c25a3d93cff2eaf8659d44375622a22226bb96379c7377055d8840703aa8dac25b49440f1a862f5c9b45444
-  data.tar.gz: 6ce0ee55fd1d0174bd1d06377eb1a5ed3cf875ea1225da0320ba6e4b003bdd18d73d00f126fc17484dc8c2b45621a2cfe86c74134f6c227b4b1364b631977d69
+  metadata.gz: 361822ebf216d8f8ba3abf8314e52b1a72887fb2a03aea29572940376326b128442fc007fa7de6a6e925facb0b9295076fb10a98ff053aad7e0fbe41e4973c2a
+  data.tar.gz: 38f9f4b10665d9e87940b23fae51a15640229367f6bb74a7dba176bab6e798c8fad8abce106c07e38e0acc9046949f80208f9f9b30e3341aceb5a6193dac3aca

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+## [0.8.1] - 2023-03-18
+
+- Update the type declarations of HierarchicalNSW and BruteforceSearch along with recent changes.
+
+## [0.8.0] - 2023-03-14
+
+**Breaking change:**
+
+- Change to give a String to the space argument of the `initialize` method
+in [HierarchicalNSW](https://yoshoku.github.io/hnswlib.rb/doc/Hnswlib/HierarchicalNSW.html) and [BruteforceSearch](https://yoshoku.github.io/hnswlib.rb/doc/Hnswlib/BruteforceSearch.html).
+- Add `init_index` method to HierarchicalNSW and BruteforceSearch.
+Along with this, some arguments of `initialize` method moved to `init_index` method.
+  ```ruby
+  require 'hnswlib'
+
+  n_features = 3
+  max_elements = 10
+
+  hnsw = Hnswlib::HierarchicalNSW.new(space: 'l2', dim: n_features)
+  hnsw.init_index(max_elements: max_elements, m: 16, ef_construction: 200, random_seed: 42, allow_replace_deleted: false)
+
+  bf = Hnswlib::BruteforceSearch.new(space: 'l2', dim: n_features)
+  bf.init_index(max_elements: max_elements)
+  ```
+- Deprecate [HnswIndex](https://yoshoku.github.io/hnswlib.rb/doc/Hnswlib/HnswIndex.html) has interface similar to Annoy.
+
 ## [0.7.0] - 2023-03-04
 
 - Update bundled hnswlib version to 0.7.0.

data/README.md

@@ -48,19 +48,26 @@ $ gem install hnswlib -- --with-cxxflags=-march=native
 ```ruby
 require 'hnswlib'
 
-f = 40 # length of item vector that will be indexed.
-t = Hnswlib::HnswIndex.new(n_features: f, max_item: 1000)
+f = 40 # length of datum point vector that will be indexed.
+t = Hnswlib::HierarchicalNSW.new(space: 'l2', dim: f)
+t.init_index(max_elements: 1000)
 
 1000.times do |i|
   v = Array.new(f) { rand }
-  t.add_item(i, v)
+  t.add_point(v, i)
 end
 
-t.save('test.ann')
+t.save_index('test.ann')
+```
+
+```ruby
+require 'hnswlib'
+
+u = Hnswlib::HierarchicalNSW.new(space: 'l2', dim: f)
+u.load_index('test.ann')
 
-u = Hnswlib::HnswIndex.new(n_features: f, max_item: 1000)
-u.load('test.ann')
-p u.get_nns_by_item(0, 100) # will find the 100 nearest neighbors.
+q = Array.new(f) { rand }
+p u.search_knn(q, 100) # will find the 100 nearest neighbors.
 ```
 
 ## License

data/ext/hnswlib/hnswlibext.cpp

@@ -18,8 +18,6 @@
 
 #include "hnswlibext.hpp"
 
-VALUE rb_mHnswlib;
-
 extern "C" void Init_hnswlibext(void) {
   rb_mHnswlib = rb_define_module("Hnswlib");
   RbHnswlibL2Space::define_class(rb_mHnswlib);

data/ext/hnswlib/hnswlibext.hpp

@@ -23,9 +23,11 @@
 
 #include <hnswlib.h>
 
+#include <cmath>
 #include <new>
 #include <vector>
 
+VALUE rb_mHnswlib;
 VALUE rb_cHnswlibL2Space;
 VALUE rb_cHnswlibInnerProductSpace;
 VALUE rb_cHnswlibHierarchicalNSW;
@@ -52,8 +54,8 @@ public:
     return ptr;
   };
 
-  static VALUE define_class(VALUE rb_mHnswlib) {
-    rb_cHnswlibL2Space = rb_define_class_under(rb_mHnswlib, "L2Space", rb_cObject);
+  static VALUE define_class(VALUE outer) {
+    rb_cHnswlibL2Space = rb_define_class_under(outer, "L2Space", rb_cObject);
     rb_define_alloc_func(rb_cHnswlibL2Space, hnsw_l2space_alloc);
     rb_define_method(rb_cHnswlibL2Space, "initialize", RUBY_METHOD_FUNC(_hnsw_l2space_init), 1);
     rb_define_method(rb_cHnswlibL2Space, "distance", RUBY_METHOD_FUNC(_hnsw_l2space_distance), 2);
@@ -128,8 +130,8 @@ public:
     return ptr;
   };
 
-  static VALUE define_class(VALUE rb_mHnswlib) {
-    rb_cHnswlibInnerProductSpace = rb_define_class_under(rb_mHnswlib, "InnerProductSpace", rb_cObject);
+  static VALUE define_class(VALUE outer) {
+    rb_cHnswlibInnerProductSpace = rb_define_class_under(outer, "InnerProductSpace", rb_cObject);
     rb_define_alloc_func(rb_cHnswlibInnerProductSpace, hnsw_ipspace_alloc);
     rb_define_method(rb_cHnswlibInnerProductSpace, "initialize", RUBY_METHOD_FUNC(_hnsw_ipspace_init), 1);
     rb_define_method(rb_cHnswlibInnerProductSpace, "distance", RUBY_METHOD_FUNC(_hnsw_ipspace_distance), 2);
@@ -218,10 +220,11 @@ public:
     return ptr;
   };
 
-  static VALUE define_class(VALUE rb_mHnswlib) {
-    rb_cHnswlibHierarchicalNSW = rb_define_class_under(rb_mHnswlib, "HierarchicalNSW", rb_cObject);
+  static VALUE define_class(VALUE outer) {
+    rb_cHnswlibHierarchicalNSW = rb_define_class_under(outer, "HierarchicalNSW", rb_cObject);
     rb_define_alloc_func(rb_cHnswlibHierarchicalNSW, hnsw_hierarchicalnsw_alloc);
-    rb_define_method(rb_cHnswlibHierarchicalNSW, "initialize", RUBY_METHOD_FUNC(_hnsw_hierarchicalnsw_init), -1);
+    rb_define_method(rb_cHnswlibHierarchicalNSW, "initialize", RUBY_METHOD_FUNC(_hnsw_hierarchicalnsw_initialize), -1);
+    rb_define_method(rb_cHnswlibHierarchicalNSW, "init_index", RUBY_METHOD_FUNC(_hnsw_hierarchicalnsw_init_index), -1);
     rb_define_method(rb_cHnswlibHierarchicalNSW, "add_point", RUBY_METHOD_FUNC(_hnsw_hierarchicalnsw_add_point), -1);
     rb_define_method(rb_cHnswlibHierarchicalNSW, "search_knn", RUBY_METHOD_FUNC(_hnsw_hierarchicalnsw_search_knn), -1);
     rb_define_method(rb_cHnswlibHierarchicalNSW, "save_index", RUBY_METHOD_FUNC(_hnsw_hierarchicalnsw_save_index), 1);
@@ -244,59 +247,90 @@ public:
 private:
   static const rb_data_type_t hnsw_hierarchicalnsw_type;
 
-  static VALUE _hnsw_hierarchicalnsw_init(int argc, VALUE* argv, VALUE self) {
+  static VALUE _hnsw_hierarchicalnsw_initialize(int argc, VALUE* argv, VALUE self) {
     VALUE kw_args = Qnil;
-    ID kw_table[6] = {rb_intern("space"),           rb_intern("max_elements"), rb_intern("m"),
-                      rb_intern("ef_construction"), rb_intern("random_seed"),  rb_intern("allow_replace_deleted")};
-    VALUE kw_values[6] = {Qundef, Qundef, Qundef, Qundef, Qundef, Qundef};
+    ID kw_table[2] = {rb_intern("space"), rb_intern("dim")};
+    VALUE kw_values[2] = {Qundef, Qundef};
     rb_scan_args(argc, argv, ":", &kw_args);
-    rb_get_kwargs(kw_args, kw_table, 2, 4, kw_values);
-    if (kw_values[2] == Qundef) kw_values[2] = SIZET2NUM(16);
-    if (kw_values[3] == Qundef) kw_values[3] = SIZET2NUM(200);
-    if (kw_values[4] == Qundef) kw_values[4] = SIZET2NUM(100);
-    if (kw_values[5] == Qundef) kw_values[5] = Qfalse;
+    rb_get_kwargs(kw_args, kw_table, 2, 0, kw_values);
 
-    if (!(rb_obj_is_instance_of(kw_values[0], rb_cHnswlibL2Space) ||
-          rb_obj_is_instance_of(kw_values[0], rb_cHnswlibInnerProductSpace))) {
-      rb_raise(rb_eTypeError, "expected space, Hnswlib::L2Space or Hnswlib::InnerProductSpace");
+    if (!RB_TYPE_P(kw_values[0], T_STRING)) {
+      rb_raise(rb_eTypeError, "expected space, String");
+      return Qnil;
+    }
+    if (strcmp(StringValueCStr(kw_values[0]), "l2") != 0 && strcmp(StringValueCStr(kw_values[0]), "ip") != 0 &&
+        strcmp(StringValueCStr(kw_values[0]), "cosine") != 0) {
+      rb_raise(rb_eArgError, "expected space, 'l2', 'ip', or 'cosine' only");
       return Qnil;
     }
     if (!RB_INTEGER_TYPE_P(kw_values[1])) {
+      rb_raise(rb_eTypeError, "expected dim, Integer");
+      return Qnil;
+    }
+
+    if (strcmp(StringValueCStr(kw_values[0]), "l2") == 0) {
+      rb_iv_set(self, "@space", rb_funcall(rb_const_get(rb_mHnswlib, rb_intern("L2Space")), rb_intern("new"), 1, kw_values[1]));
+    } else {
+      rb_iv_set(self, "@space",
+                rb_funcall(rb_const_get(rb_mHnswlib, rb_intern("InnerProductSpace")), rb_intern("new"), 1, kw_values[1]));
+    }
+
+    rb_iv_set(self, "@normalize", Qfalse);
+    if (strcmp(StringValueCStr(kw_values[0]), "cosine") == 0) rb_iv_set(self, "@normalize", Qtrue);
+
+    return Qnil;
+  };
+
+  static VALUE _hnsw_hierarchicalnsw_init_index(int argc, VALUE* argv, VALUE self) {
+    VALUE kw_args = Qnil;
+    ID kw_table[5] = {rb_intern("max_elements"), rb_intern("m"), rb_intern("ef_construction"), rb_intern("random_seed"),
+                      rb_intern("allow_replace_deleted")};
+    VALUE kw_values[5] = {Qundef, Qundef, Qundef, Qundef, Qundef};
+    rb_scan_args(argc, argv, ":", &kw_args);
+    rb_get_kwargs(kw_args, kw_table, 1, 4, kw_values);
+    if (kw_values[1] == Qundef) kw_values[1] = SIZET2NUM(16);
+    if (kw_values[2] == Qundef) kw_values[2] = SIZET2NUM(200);
+    if (kw_values[3] == Qundef) kw_values[3] = SIZET2NUM(100);
+    if (kw_values[4] == Qundef) kw_values[4] = Qfalse;
+
+    if (!RB_INTEGER_TYPE_P(kw_values[0])) {
       rb_raise(rb_eTypeError, "expected max_elements, Integer");
       return Qnil;
     }
-    if (!RB_INTEGER_TYPE_P(kw_values[2])) {
+    if (!RB_INTEGER_TYPE_P(kw_values[1])) {
       rb_raise(rb_eTypeError, "expected m, Integer");
       return Qnil;
     }
-    if (!RB_INTEGER_TYPE_P(kw_values[3])) {
+    if (!RB_INTEGER_TYPE_P(kw_values[2])) {
       rb_raise(rb_eTypeError, "expected ef_construction, Integer");
       return Qnil;
     }
-    if (!RB_INTEGER_TYPE_P(kw_values[4])) {
+    if (!RB_INTEGER_TYPE_P(kw_values[3])) {
       rb_raise(rb_eTypeError, "expected random_seed, Integer");
       return Qnil;
     }
-    if (!RB_TYPE_P(kw_values[5], T_TRUE) && !RB_TYPE_P(kw_values[5], T_FALSE)) {
+    if (!RB_TYPE_P(kw_values[4], T_TRUE) && !RB_TYPE_P(kw_values[4], T_FALSE)) {
       rb_raise(rb_eTypeError, "expected allow_replace_deleted, Boolean");
       return Qnil;
     }
 
-    rb_iv_set(self, "@space", kw_values[0]);
-    hnswlib::SpaceInterface<float>* space;
-    if (rb_obj_is_instance_of(kw_values[0], rb_cHnswlibL2Space)) {
-      space = RbHnswlibL2Space::get_hnsw_l2space(kw_values[0]);
+    hnswlib::SpaceInterface<float>* space = nullptr;
+    VALUE ivspace = rb_iv_get(self, "@space");
+    if (rb_obj_is_instance_of(ivspace, rb_cHnswlibL2Space)) {
+      space = RbHnswlibL2Space::get_hnsw_l2space(ivspace);
     } else {
-      space = RbHnswlibInnerProductSpace::get_hnsw_ipspace(kw_values[0]);
+      space = RbHnswlibInnerProductSpace::get_hnsw_ipspace(ivspace);
     }
-    const size_t max_elements = NUM2SIZET(kw_values[1]);
-    const size_t m = NUM2SIZET(kw_values[2]);
-    const size_t ef_construction = NUM2SIZET(kw_values[3]);
-    const size_t random_seed = NUM2SIZET(kw_values[4]);
-    const bool allow_replace_deleted = kw_values[5] == Qtrue ? true : false;
+
+    const size_t max_elements = NUM2SIZET(kw_values[0]);
+    const size_t m = NUM2SIZET(kw_values[1]);
+    const size_t ef_construction = NUM2SIZET(kw_values[2]);
+    const size_t random_seed = NUM2SIZET(kw_values[3]);
+    const bool allow_replace_deleted = kw_values[4] == Qtrue ? true : false;
 
     hnswlib::HierarchicalNSW<float>* ptr = get_hnsw_hierarchicalnsw(self);
     try {
+      ptr->~HierarchicalNSW();
       new (ptr) hnswlib::HierarchicalNSW<float>(space, max_elements, m, ef_construction, random_seed, allow_replace_deleted);
     } catch (const std::runtime_error& e) {
       rb_raise(rb_eRuntimeError, "%s", e.what());
@@ -335,20 +369,29 @@ private:
       return Qfalse;
     }
 
-    float* arr = (float*)ruby_xmalloc(dim * sizeof(float));
-    for (size_t i = 0; i < dim; i++) arr[i] = (float)NUM2DBL(rb_ary_entry(_arr, i));
+    float* vec = (float*)ruby_xmalloc(dim * sizeof(float));
+    for (size_t i = 0; i < dim; i++) vec[i] = (float)NUM2DBL(rb_ary_entry(_arr, i));
     const size_t idx = NUM2SIZET(_idx);
     const bool replace_deleted = _replace_deleted == Qtrue ? true : false;
 
+    if (rb_iv_get(self, "@normalize") == Qtrue) {
+      float norm = 0.0;
+      for (size_t i = 0; i < dim; i++) norm += vec[i] * vec[i];
+      norm = std::sqrt(std::fabs(norm));
+      if (norm >= 0.0) {
+        for (size_t i = 0; i < dim; i++) vec[i] /= norm;
+      }
+    }
+
     try {
-      get_hnsw_hierarchicalnsw(self)->addPoint((void*)arr, idx, replace_deleted);
+      get_hnsw_hierarchicalnsw(self)->addPoint((void*)vec, idx, replace_deleted);
     } catch (const std::runtime_error& e) {
-      ruby_xfree(arr);
+      ruby_xfree(vec);
       rb_raise(rb_eRuntimeError, "%s", e.what());
       return Qfalse;
     }
 
-    ruby_xfree(arr);
+    ruby_xfree(vec);
     return Qtrue;
   };
 
@@ -392,6 +435,15 @@ private:
       vec[i] = (float)NUM2DBL(rb_ary_entry(arr, i));
     }
 
+    if (rb_iv_get(self, "@normalize") == Qtrue) {
+      float norm = 0.0;
+      for (size_t i = 0; i < dim; i++) norm += vec[i] * vec[i];
+      norm = std::sqrt(std::fabs(norm));
+      if (norm >= 0.0) {
+        for (size_t i = 0; i < dim; i++) vec[i] /= norm;
+      }
+    }
+
     std::priority_queue<std::pair<float, size_t>> result;
     try {
       result = get_hnsw_hierarchicalnsw(self)->searchKnn((void*)vec, NUM2SIZET(k), filter_func);
@@ -607,10 +659,11 @@ public:
     return ptr;
   };
 
-  static VALUE define_class(VALUE rb_mHnswlib) {
-    rb_cHnswlibBruteforceSearch = rb_define_class_under(rb_mHnswlib, "BruteforceSearch", rb_cObject);
+  static VALUE define_class(VALUE outer) {
+    rb_cHnswlibBruteforceSearch = rb_define_class_under(outer, "BruteforceSearch", rb_cObject);
     rb_define_alloc_func(rb_cHnswlibBruteforceSearch, hnsw_bruteforcesearch_alloc);
-    rb_define_method(rb_cHnswlibBruteforceSearch, "initialize", RUBY_METHOD_FUNC(_hnsw_bruteforcesearch_init), -1);
+    rb_define_method(rb_cHnswlibBruteforceSearch, "initialize", RUBY_METHOD_FUNC(_hnsw_bruteforcesearch_initialize), -1);
+    rb_define_method(rb_cHnswlibBruteforceSearch, "init_index", RUBY_METHOD_FUNC(_hnsw_bruteforcesearch_init_index), -1);
     rb_define_method(rb_cHnswlibBruteforceSearch, "add_point", RUBY_METHOD_FUNC(_hnsw_bruteforcesearch_add_point), 2);
     rb_define_method(rb_cHnswlibBruteforceSearch, "search_knn", RUBY_METHOD_FUNC(_hnsw_bruteforcesearch_search_knn), -1);
     rb_define_method(rb_cHnswlibBruteforceSearch, "save_index", RUBY_METHOD_FUNC(_hnsw_bruteforcesearch_save_index), 1);
@@ -625,34 +678,66 @@ public:
 private:
   static const rb_data_type_t hnsw_bruteforcesearch_type;
 
-  static VALUE _hnsw_bruteforcesearch_init(int argc, VALUE* argv, VALUE self) {
+  static VALUE _hnsw_bruteforcesearch_initialize(int argc, VALUE* argv, VALUE self) {
     VALUE kw_args = Qnil;
-    ID kw_table[2] = {rb_intern("space"), rb_intern("max_elements")};
+    ID kw_table[2] = {rb_intern("space"), rb_intern("dim")};
     VALUE kw_values[2] = {Qundef, Qundef};
     rb_scan_args(argc, argv, ":", &kw_args);
     rb_get_kwargs(kw_args, kw_table, 2, 0, kw_values);
 
-    if (!(rb_obj_is_instance_of(kw_values[0], rb_cHnswlibL2Space) ||
-          rb_obj_is_instance_of(kw_values[0], rb_cHnswlibInnerProductSpace))) {
-      rb_raise(rb_eTypeError, "expected space, Hnswlib::L2Space or Hnswlib::InnerProductSpace");
+    if (!RB_TYPE_P(kw_values[0], T_STRING)) {
+      rb_raise(rb_eTypeError, "expected space, String");
+      return Qnil;
+    }
+    if (strcmp(StringValueCStr(kw_values[0]), "l2") != 0 && strcmp(StringValueCStr(kw_values[0]), "ip") != 0 &&
+        strcmp(StringValueCStr(kw_values[0]), "cosine") != 0) {
+      rb_raise(rb_eArgError, "expected space, 'l2', 'ip', or 'cosine' only");
       return Qnil;
     }
     if (!RB_INTEGER_TYPE_P(kw_values[1])) {
-      rb_raise(rb_eTypeError, "expected max_elements, Integer");
+      rb_raise(rb_eTypeError, "expected dim, Integer");
       return Qnil;
     }
 
-    rb_iv_set(self, "@space", kw_values[0]);
     hnswlib::SpaceInterface<float>* space;
-    if (rb_obj_is_instance_of(kw_values[0], rb_cHnswlibL2Space)) {
-      space = RbHnswlibL2Space::get_hnsw_l2space(kw_values[0]);
+    if (strcmp(StringValueCStr(kw_values[0]), "l2") == 0) {
+      rb_iv_set(self, "@space", rb_funcall(rb_const_get(rb_mHnswlib, rb_intern("L2Space")), rb_intern("new"), 1, kw_values[1]));
+    } else {
+      rb_iv_set(self, "@space",
+                rb_funcall(rb_const_get(rb_mHnswlib, rb_intern("InnerProductSpace")), rb_intern("new"), 1, kw_values[1]));
+    }
+
+    rb_iv_set(self, "@normalize", Qfalse);
+    if (strcmp(StringValueCStr(kw_values[0]), "cosine") == 0) rb_iv_set(self, "@normalize", Qtrue);
+
+    return Qnil;
+  };
+
+  static VALUE _hnsw_bruteforcesearch_init_index(int argc, VALUE* argv, VALUE self) {
+    VALUE kw_args = Qnil;
+    ID kw_table[1] = {rb_intern("max_elements")};
+    VALUE kw_values[1] = {Qundef};
+    rb_scan_args(argc, argv, ":", &kw_args);
+    rb_get_kwargs(kw_args, kw_table, 1, 0, kw_values);
+
+    if (!RB_INTEGER_TYPE_P(kw_values[0])) {
+      rb_raise(rb_eTypeError, "expected max_elements, Integer");
+      return Qnil;
+    }
+
+    hnswlib::SpaceInterface<float>* space = nullptr;
+    VALUE ivspace = rb_iv_get(self, "@space");
+    if (rb_obj_is_instance_of(ivspace, rb_cHnswlibL2Space)) {
+      space = RbHnswlibL2Space::get_hnsw_l2space(ivspace);
     } else {
-      space = RbHnswlibInnerProductSpace::get_hnsw_ipspace(kw_values[0]);
+      space = RbHnswlibInnerProductSpace::get_hnsw_ipspace(ivspace);
     }
-    const size_t max_elements = NUM2SIZET(kw_values[1]);
+
+    const size_t max_elements = NUM2SIZET(kw_values[0]);
 
     hnswlib::BruteforceSearch<float>* ptr = get_hnsw_bruteforcesearch(self);
     try {
+      ptr->~BruteforceSearch();
       new (ptr) hnswlib::BruteforceSearch<float>(space, max_elements);
     } catch (const std::runtime_error& e) {
       rb_raise(rb_eRuntimeError, "%s", e.what());
@@ -681,6 +766,15 @@ private:
     float* vec = (float*)ruby_xmalloc(dim * sizeof(float));
     for (size_t i = 0; i < dim; i++) vec[i] = (float)NUM2DBL(rb_ary_entry(arr, i));
 
+    if (rb_iv_get(self, "@normalize") == Qtrue) {
+      float norm = 0.0;
+      for (size_t i = 0; i < dim; i++) norm += vec[i] * vec[i];
+      norm = std::sqrt(std::fabs(norm));
+      if (norm >= 0.0) {
+        for (size_t i = 0; i < dim; i++) vec[i] /= norm;
+      }
+    }
+
     try {
       get_hnsw_bruteforcesearch(self)->addPoint((void*)vec, NUM2SIZET(idx));
     } catch (const std::runtime_error& e) {
@@ -729,8 +823,15 @@ private:
     }
 
     float* vec = (float*)ruby_xmalloc(dim * sizeof(float));
-    for (size_t i = 0; i < dim; i++) {
-      vec[i] = (float)NUM2DBL(rb_ary_entry(arr, i));
+    for (size_t i = 0; i < dim; i++) vec[i] = (float)NUM2DBL(rb_ary_entry(arr, i));
+
+    if (rb_iv_get(self, "@normalize") == Qtrue) {
+      float norm = 0.0;
+      for (size_t i = 0; i < dim; i++) norm += vec[i] * vec[i];
+      norm = std::sqrt(std::fabs(norm));
+      if (norm >= 0.0) {
+        for (size_t i = 0; i < dim; i++) vec[i] /= norm;
+      }
     }
 
     std::priority_queue<std::pair<float, size_t>> result =

data/lib/hnswlib/version.rb

@@ -3,7 +3,7 @@
 # Hnswlib.rb provides Ruby bindings for the Hnswlib.
 module Hnswlib
   # The version of Hnswlib.rb you install.
-  VERSION = '0.7.0'
+  VERSION = '0.8.1'
 
   # The version of Hnswlib included with gem.
   HSWLIB_VERSION = '0.7.0'

data/lib/hnswlib.rb

@@ -18,6 +18,7 @@ module Hnswlib
   #
   #   index.get_nns_by_item(0, 100)
   #
+  # @deprecated This class was prepared as a class with an interface similar to Annoy, but it is not very useful and will be deleted in the next version.
   class HnswIndex
     # Returns the metric of index.
     # @return [String]
@@ -27,7 +28,7 @@ module Hnswlib
     #
     # @param n_features [Integer] The number of features (dimensions) of stored vector.
     # @param max_item [Integer] The maximum number of items.
-    # @param metric [String] The distance metric between vectors ('l2' or 'dot').
+    # @param metric [String] The distance metric between vectors ('l2', 'dot', or 'cosine').
     # @param m [Integer] The maximum number of outgoing connections in the graph
     # @param ef_construction [Integer] The size of the dynamic list for the nearest neighbors. It controls the index time/accuracy trade-off.
     # @param random_seed [Integer] The seed value using to initialize the random generator.
@@ -35,15 +36,10 @@ module Hnswlib
     def initialize(n_features:, max_item:, metric: 'l2', m: 16, ef_construction: 200,
                    random_seed: 100, allow_replace_removed: false)
       @metric = metric
-      space = if @metric == 'dot'
-                Hnswlib::InnerProductSpace.new(n_features)
-              else
-                Hnswlib::L2Space.new(n_features)
-              end
-      @index = Hnswlib::HierarchicalNSW.new(
-        space: space, max_elements: max_item, m: m, ef_construction: ef_construction,
-        random_seed: random_seed, allow_replace_deleted: allow_replace_removed
-      )
+      space = @metric == 'dot' ? 'ip' : 'l2'
+      @index = Hnswlib::HierarchicalNSW.new(space: space, dim: n_features)
+      @index.init_index(max_elements: max_item, m: m, ef_construction: ef_construction,
+                        random_seed: random_seed, allow_replace_deleted: allow_replace_removed)
     end
 
     # Add item to be indexed.

data/sig/hnswlib.rbs

@@ -40,30 +40,36 @@ module Hnswlib
   class BruteforceSearch
     attr_accessor space: (::Hnswlib::L2Space | ::Hnswlib::InnerProductSpace)
 
-    def initialize: (space: (::Hnswlib::L2Space | ::Hnswlib::InnerProductSpace) space, max_elements: Integer max_elements) -> void
+    def initialize: (space: String space, dim: Integer dim) -> void
+    def init_index: (max_elements: Integer max_elements) -> void
     def add_point: (Array[Float] arr, Integer idx) -> bool
     def current_count: () -> Integer
     def load_index: (String filename) -> void
     def max_elements: () -> Integer
     def remove_point: (Integer idx) -> void
     def save_index: (String filename) -> void
-    def search_knn: (Array[Float] arr, Integer k) -> [Array[Integer], Array[Float]]
+    def search_knn: (Array[Float] arr, Integer k, ?filter: Proc filter) -> [Array[Integer], Array[Float]]
   end
 
   class HierarchicalNSW
     attr_accessor space: (::Hnswlib::L2Space | ::Hnswlib::InnerProductSpace)
 
-    def initialize: (space: (::Hnswlib::L2Space | ::Hnswlib::InnerProductSpace) space, max_elements: Integer max_elements, ?m: Integer m, ?ef_construction: Integer ef_construction, ?random_seed: Integer random_seed, ?allow_replace_deleted: (true | false) allow_replace_deleted) -> void
+    def initialize: (space: String space, dim: Integer dim) -> void
+    def init_index: (max_elements: Integer max_elements, ?m: Integer m, ?ef_construction: Integer ef_construction, ?random_seed: Integer random_seed, ?allow_replace_deleted: (true | false) allow_replace_deleted) -> void
     def add_point: (Array[Float] arr, Integer idx, ?replace_deleted: (true | false) replace_deleted) -> bool
     def current_count: () -> Integer
     def get_ids: () -> Array[Integer]
     def get_point: (Integer idx) -> Array[Float]
     def load_index: (String filename, ?allow_replace_deleted: (true | false) allow_replace_deleted) -> void
     def mark_deleted: (Integer idx) -> void
+    def unmark_deleted: (Integer idx) -> void
     def max_elements: () -> Integer
     def resize_index: (Integer new_max_elements) -> void
     def save_index: (String filename) -> void
-    def search_knn: (Array[Float] arr, Integer k) -> [Array[Integer], Array[Float]]
+    def search_knn: (Array[Float] arr, Integer k, ?filter: Proc filter) -> [Array[Integer], Array[Float]]
     def set_ef: (Integer ef) -> void
+    def get_ef: () -> Integer
+    def ef_construction: () -> Integer
+    def m: () -> Integer
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hnswlib
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.1
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-03-04 00:00:00.000000000 Z
+date: 2023-03-18 00:00:00.000000000 Z
 dependencies: []
 description: Hnswlib.rb provides Ruby bindings for the Hnswlib.
 email: