hnswlib 0.1.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9a4129957f2d395c00654d74062bec452fec715e148e8db2b5ad3e4f3bc815e
-  data.tar.gz: 54691ff4e40f812327ffa019527654e936ef570a115b9082359828a2e9d14704
+  metadata.gz: 99f5f1403a51083df75ef842a11b996fe6c159f95c3798f217a076cb5f535254
+  data.tar.gz: f9972ac4e644727a126e937e81494cc11bc051bc7ff0daf57139845aed1e7719
 SHA512:
-  metadata.gz: 1c766bbe540dc5d8135b56959c8e088f5ab1ffc4e104fd6f8ea39de350ed4e7313fa495d7d76cea294d63e68679ac024a7d842b1c454d0252dcd330516511264
-  data.tar.gz: af8ce64f52e0361497f17ef0e316890e870ca637757790f64973bd7f15d7d195c00a1faa5dc9c651276d7d8fb8622efad0efee55a2666ff948576421e05f1392
+  metadata.gz: c4f96fceab228e3cffd9f2b77e513b86fe71ec3156cdff10c0bc9206ad7951f87c507531088f91f45a940c399102bff6a2dedc5fee8b09b37a5f5739e9a02b6c
+  data.tar.gz: 8297e1e0d1f6753b3e8900b07b80dba271276a14303b102cd8084e480ec491da269baac1fc8be08ab350976fc22cb859583745dc219d73d6f56b33fe7502ac2b

data/.gitignore

@@ -15,4 +15,5 @@ mkmf.log
 # rspec failure tracking
 .rspec_status
 
-spec/test.ann
+*.ann
+/bin/

data/CHANGELOG.md

@@ -1,4 +1,22 @@
-## [Unreleased]
+## [0.4.0] - 2021-09-12
+
+- Add type declaration file.
+
+## [0.3.0] - 2021-08-08
+
+- Rename `Hnswlib::Index` to `Hnswlib::HnswIndex` (for compatibility, `Hnswlib::Index` has been an alis for `Hnswlib::HnswIndex`).
+- Update API documentation.
+
+## [0.2.0] - 2021-08-02
+
+- Add binding class for the BruteforceSearch.
+- Add type check for arguments of initialize methods of BruteforceSearch and HierarchicalNSW.
+- Add dummy constructor call at memory allocation for class to prevent occuring segment fault on GC when initialize method is failed.
+
+## [0.1.1] - 2021-07-25
+
+- Fix to use `rb_obj_is_isntance_of` for klass comparison due to type error when loading search index on irb 1.3.x: [issue #1](https://github.com/yoshoku/hnswlib.rb/issues/1)
+- Update API documentation.
 
 ## [0.1.0] - 2021-07-24
 

data/Gemfile

@@ -8,3 +8,5 @@ gemspec
 gem 'rake', '~> 13.0'
 gem 'rake-compiler', '~> 1.1'
 gem 'rspec', '~> 3.0'
+gem 'rbs', '~> 1.2'
+gem 'steep', '~> 0.44'

data/README.md

@@ -35,7 +35,7 @@ Or install it yourself as:
 require 'hnswlib'
 
 f = 40 # length of item vector that will be indexed.
-t = Hnswlib::Index.new(n_features: f, max_item: 1000)
+t = Hnswlib::HnswIndex.new(n_features: f, max_item: 1000)
 
 1000.times do |i|
   v = Array.new(f) { rand }
@@ -44,11 +44,15 @@ end
 
 t.save('test.ann')
 
-u = Hnswlib::Index.new(n_features: f, max_item: 1000)
+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.
 ```
 
+## License
+
+The gem is available as open source under the terms of the [Apache-2.0 License](https://www.apache.org/licenses/LICENSE-2.0).
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/yoshoku/hnswlib.rb.

data/Steepfile

@@ -0,0 +1,27 @@
+# D = Steep::Diagnostic
+#
+target :lib do
+  signature "sig"
+#
+  check "lib"                       # Directory name
+#   check "Gemfile"                   # File name
+#   check "app/models/**/*.rb"        # Glob
+#   # ignore "lib/templates/*.rb"
+#
+#   # library "pathname", "set"       # Standard libraries
+#   # library "strong_json"           # Gems
+#
+#   # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
+#   # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
+#   # configure_code_diagnostics do |hash|             # You can setup everything yourself
+#   #   hash[D::Ruby::NoMethod] = :information
+#   # end
+end
+
+# target :test do
+#   signature "sig", "sig-private"
+#
+#   check "test"
+#
+#   # library "pathname", "set"       # Standard libraries
+# end

data/ext/hnswlib/hnswlibext.cpp

@@ -26,4 +26,5 @@ void Init_hnswlibext(void) {
   RbHnswlibL2Space::define_class(rb_mHnswlib);
   RbHnswlibInnerProductSpace::define_class(rb_mHnswlib);
   RbHnswlibHierarchicalNSW::define_class(rb_mHnswlib);
+  RbHnswlibBruteforceSearch::define_class(rb_mHnswlib);
 }

data/ext/hnswlib/hnswlibext.hpp

@@ -26,11 +26,13 @@
 VALUE rb_cHnswlibL2Space;
 VALUE rb_cHnswlibInnerProductSpace;
 VALUE rb_cHnswlibHierarchicalNSW;
+VALUE rb_cHnswlibBruteforceSearch;
 
 class RbHnswlibL2Space {
   public:
     static VALUE hnsw_l2space_alloc(VALUE self) {
       hnswlib::L2Space* ptr = (hnswlib::L2Space*)ruby_xmalloc(sizeof(hnswlib::L2Space));
+      new (ptr) hnswlib::L2Space(); // dummy call to constructor for GC.
       return TypedData_Wrap_Struct(self, &hnsw_l2space_type, ptr);
     };
 
@@ -106,6 +108,7 @@ class RbHnswlibInnerProductSpace {
   public:
     static VALUE hnsw_ipspace_alloc(VALUE self) {
       hnswlib::InnerProductSpace* ptr = (hnswlib::InnerProductSpace*)ruby_xmalloc(sizeof(hnswlib::InnerProductSpace));
+      new (ptr) hnswlib::InnerProductSpace(); // dummy call to constructor for GC.
       return TypedData_Wrap_Struct(self, &hnsw_ipspace_type, ptr);
     };
 
@@ -181,6 +184,7 @@ class RbHnswlibHierarchicalNSW {
   public:
     static VALUE hnsw_hierarchicalnsw_alloc(VALUE self) {
       hnswlib::HierarchicalNSW<float>* ptr = (hnswlib::HierarchicalNSW<float>*)ruby_xmalloc(sizeof(hnswlib::HierarchicalNSW<float>));
+      new (ptr) hnswlib::HierarchicalNSW<float>(); // dummy call to constructor for GC.
       return TypedData_Wrap_Struct(self, &hnsw_hierarchicalnsw_type, ptr);
     };
 
@@ -239,9 +243,30 @@ class RbHnswlibHierarchicalNSW {
       if (kw_values[3] == Qundef) kw_values[3] = INT2NUM(200);
       if (kw_values[4] == Qundef) kw_values[4] = INT2NUM(100);
 
+      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");
+        return Qnil;
+      }
+      if (!RB_INTEGER_TYPE_P(kw_values[1])) {
+        rb_raise(rb_eTypeError, "expected max_elements, Integer");
+        return Qnil;
+      }
+      if (!RB_INTEGER_TYPE_P(kw_values[2])) {
+        rb_raise(rb_eTypeError, "expected m, Integer");
+        return Qnil;
+      }
+      if (!RB_INTEGER_TYPE_P(kw_values[3])) {
+        rb_raise(rb_eTypeError, "expected ef_construction, Integer");
+        return Qnil;
+      }
+      if (!RB_INTEGER_TYPE_P(kw_values[4])) {
+        rb_raise(rb_eTypeError, "expected random_seed, Integer");
+        return Qnil;
+      }
+
       rb_iv_set(self, "@space", kw_values[0]);
       hnswlib::SpaceInterface<float>* space;
-      if (CLASS_OF(kw_values[0]) == rb_cHnswlibL2Space) {
+      if (rb_obj_is_instance_of(kw_values[0], rb_cHnswlibL2Space)) {
         space = RbHnswlibL2Space::get_hnsw_l2space(kw_values[0]);
       } else {
         space = RbHnswlibInnerProductSpace::get_hnsw_ipspace(kw_values[0]);
@@ -344,11 +369,12 @@ class RbHnswlibHierarchicalNSW {
 
     static VALUE _hnsw_hierarchicalnsw_load_index(VALUE self, VALUE _filename) {
       std::string filename(StringValuePtr(_filename));
+      VALUE ivspace = rb_iv_get(self, "@space");
       hnswlib::SpaceInterface<float>* space;
-      if (CLASS_OF(rb_iv_get(self, "@space")) == rb_cHnswlibL2Space) {
-        space = RbHnswlibL2Space::get_hnsw_l2space(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(rb_iv_get(self, "@space"));
+        space = RbHnswlibInnerProductSpace::get_hnsw_ipspace(ivspace);
       }
       get_hnsw_hierarchicalnsw(self)->loadIndex(filename, space);
       RB_GC_GUARD(_filename);
@@ -417,4 +443,201 @@ const rb_data_type_t RbHnswlibHierarchicalNSW::hnsw_hierarchicalnsw_type = {
   RUBY_TYPED_FREE_IMMEDIATELY
 };
 
+class RbHnswlibBruteforceSearch {
+  public:
+    static VALUE hnsw_bruteforcesearch_alloc(VALUE self) {
+      hnswlib::BruteforceSearch<float>* ptr = (hnswlib::BruteforceSearch<float>*)ruby_xmalloc(sizeof(hnswlib::BruteforceSearch<float>));
+      new (ptr) hnswlib::BruteforceSearch<float>(); // dummy call to constructor for GC.
+      return TypedData_Wrap_Struct(self, &hnsw_bruteforcesearch_type, ptr);
+    };
+
+    static void hnsw_bruteforcesearch_free(void* ptr) {
+      ((hnswlib::BruteforceSearch<float>*)ptr)->~BruteforceSearch();
+      ruby_xfree(ptr);
+    };
+
+    static size_t hnsw_bruteforcesearch_size(const void* ptr) {
+      return sizeof(*((hnswlib::BruteforceSearch<float>*)ptr));
+    };
+
+    static hnswlib::BruteforceSearch<float>* get_hnsw_bruteforcesearch(VALUE self) {
+      hnswlib::BruteforceSearch<float>* ptr;
+      TypedData_Get_Struct(self, hnswlib::BruteforceSearch<float>, &hnsw_bruteforcesearch_type, ptr);
+      return ptr;
+    };
+
+    static VALUE define_class(VALUE rb_mHnswlib) {
+      rb_cHnswlibBruteforceSearch = rb_define_class_under(rb_mHnswlib, "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, "add_point", RUBY_METHOD_FUNC(_hnsw_bruteforcesearch_add_point), 2);
+      rb_define_method(rb_cHnswlibBruteforceSearch, "search_knn", RUBY_METHOD_FUNC(_hnsw_bruteforcesearch_search_knn), 2);
+      rb_define_method(rb_cHnswlibBruteforceSearch, "save_index", RUBY_METHOD_FUNC(_hnsw_bruteforcesearch_save_index), 1);
+      rb_define_method(rb_cHnswlibBruteforceSearch, "load_index", RUBY_METHOD_FUNC(_hnsw_bruteforcesearch_load_index), 1);
+      rb_define_method(rb_cHnswlibBruteforceSearch, "remove_point", RUBY_METHOD_FUNC(_hnsw_bruteforcesearch_remove_point), 1);
+      rb_define_method(rb_cHnswlibBruteforceSearch, "max_elements", RUBY_METHOD_FUNC(_hnsw_bruteforcesearch_max_elements), 0);
+      rb_define_method(rb_cHnswlibBruteforceSearch, "current_count", RUBY_METHOD_FUNC(_hnsw_bruteforcesearch_current_count), 0);
+      rb_define_attr(rb_cHnswlibBruteforceSearch, "space", 1, 0);
+      return rb_cHnswlibBruteforceSearch;
+    };
+
+  private:
+    static const rb_data_type_t hnsw_bruteforcesearch_type;
+
+    static VALUE _hnsw_bruteforcesearch_init(int argc, VALUE* argv, VALUE self) {
+      VALUE kw_args = Qnil;
+      ID kw_table[2] = { rb_intern("space"), rb_intern("max_elements") };
+      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");
+        return Qnil;
+      }
+      if (!RB_INTEGER_TYPE_P(kw_values[1])) {
+        rb_raise(rb_eTypeError, "expected max_elements, 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]);
+      } else {
+        space = RbHnswlibInnerProductSpace::get_hnsw_ipspace(kw_values[0]);
+      }
+      const size_t max_elements = (size_t)NUM2INT(kw_values[1]);
+
+      hnswlib::BruteforceSearch<float>* ptr = get_hnsw_bruteforcesearch(self);
+      new (ptr) hnswlib::BruteforceSearch<float>(space, max_elements);
+
+      return Qnil;
+    };
+
+    static VALUE _hnsw_bruteforcesearch_add_point(VALUE self, VALUE arr, VALUE idx) {
+      const int dim = NUM2INT(rb_iv_get(rb_iv_get(self, "@space"), "@dim"));
+
+      if (!RB_TYPE_P(arr, T_ARRAY)) {
+        rb_raise(rb_eArgError, "Expect point vector to be Ruby Array.");
+        return Qfalse;
+      }
+
+      if (!RB_INTEGER_TYPE_P(idx)) {
+        rb_raise(rb_eArgError, "Expect index to be Ruby Integer.");
+        return Qfalse;
+      }
+
+      if (dim != RARRAY_LEN(arr)) {
+        rb_raise(rb_eArgError, "Array size does not match to index dimensionality.");
+        return Qfalse;
+      }
+
+      float* vec = (float*)ruby_xmalloc(dim * sizeof(float));
+      for (int i = 0; i < dim; i++) {
+        vec[i] = (float)NUM2DBL(rb_ary_entry(arr, i));
+      }
+
+      get_hnsw_bruteforcesearch(self)->addPoint((void *)vec, (size_t)NUM2INT(idx));
+
+      ruby_xfree(vec);
+      return Qtrue;
+    };
+
+    static VALUE _hnsw_bruteforcesearch_search_knn(VALUE self, VALUE arr, VALUE k) {
+      const int dim = NUM2INT(rb_iv_get(rb_iv_get(self, "@space"), "@dim"));
+
+      if (!RB_TYPE_P(arr, T_ARRAY)) {
+        rb_raise(rb_eArgError, "Expect query vector to be Ruby Array.");
+        return Qnil;
+      }
+
+      if (!RB_INTEGER_TYPE_P(k)) {
+        rb_raise(rb_eArgError, "Expect the number of nearest neighbors to be Ruby Integer.");
+        return Qnil;
+      }
+
+      if (dim != RARRAY_LEN(arr)) {
+        rb_raise(rb_eArgError, "Array size does not match to index dimensionality.");
+        return Qnil;
+      }
+
+      float* vec = (float*)ruby_xmalloc(dim * sizeof(float));
+      for (int i = 0; i < dim; i++) {
+        vec[i] = (float)NUM2DBL(rb_ary_entry(arr, i));
+      }
+
+      std::priority_queue<std::pair<float, size_t>> result =
+        get_hnsw_bruteforcesearch(self)->searchKnn((void *)vec, (size_t)NUM2INT(k));
+
+      ruby_xfree(vec);
+
+      if (result.size() != (size_t)NUM2INT(k)) {
+        rb_raise(rb_eRuntimeError, "Cannot return the results in a contigious 2D array. Probably ef or M is too small.");
+        return Qnil;
+      }
+
+      VALUE distances_arr = rb_ary_new2(result.size());
+      VALUE neighbors_arr = rb_ary_new2(result.size());
+
+      for (int i = NUM2INT(k) - 1; i >= 0; i--) {
+        const std::pair<float, size_t>& result_tuple = result.top();
+        rb_ary_store(distances_arr, i, DBL2NUM((double)result_tuple.first));
+        rb_ary_store(neighbors_arr, i, INT2NUM((int)result_tuple.second));
+        result.pop();
+      }
+
+      VALUE ret = rb_ary_new2(2);
+      rb_ary_store(ret, 0, neighbors_arr);
+      rb_ary_store(ret, 1, distances_arr);
+      return ret;
+    };
+
+    static VALUE _hnsw_bruteforcesearch_save_index(VALUE self, VALUE _filename) {
+      std::string filename(StringValuePtr(_filename));
+      get_hnsw_bruteforcesearch(self)->saveIndex(filename);
+      RB_GC_GUARD(_filename);
+      return Qnil;
+    };
+
+    static VALUE _hnsw_bruteforcesearch_load_index(VALUE self, VALUE _filename) {
+      std::string filename(StringValuePtr(_filename));
+      VALUE ivspace = rb_iv_get(self, "@space");
+      hnswlib::SpaceInterface<float>* space;
+      if (rb_obj_is_instance_of(ivspace, rb_cHnswlibL2Space)) {
+        space = RbHnswlibL2Space::get_hnsw_l2space(ivspace);
+      } else {
+        space = RbHnswlibInnerProductSpace::get_hnsw_ipspace(ivspace);
+      }
+      get_hnsw_bruteforcesearch(self)->loadIndex(filename, space);
+      RB_GC_GUARD(_filename);
+      return Qnil;
+    };
+
+    static VALUE _hnsw_bruteforcesearch_remove_point(VALUE self, VALUE idx) {
+      get_hnsw_bruteforcesearch(self)->removePoint((size_t)NUM2INT(idx));
+      return Qnil;
+    };
+
+    static VALUE _hnsw_bruteforcesearch_max_elements(VALUE self) {
+      return INT2NUM((int)(get_hnsw_bruteforcesearch(self)->maxelements_));
+    };
+
+    static VALUE _hnsw_bruteforcesearch_current_count(VALUE self) {
+      return INT2NUM((int)(get_hnsw_bruteforcesearch(self)->cur_element_count));
+    };
+};
+
+const rb_data_type_t RbHnswlibBruteforceSearch::hnsw_bruteforcesearch_type = {
+  "RbHnswlibBruteforceSearch",
+  {
+    NULL,
+    RbHnswlibBruteforceSearch::hnsw_bruteforcesearch_free,
+    RbHnswlibBruteforceSearch::hnsw_bruteforcesearch_size
+  },
+  NULL,
+  NULL,
+  RUBY_TYPED_FREE_IMMEDIATELY
+};
+
 #endif /* HNSWLIBEXT_HPP */

data/ext/hnswlib/src/bruteforce.h

@@ -8,6 +8,7 @@ namespace hnswlib {
     template<typename dist_t>
     class BruteforceSearch : public AlgorithmInterface<dist_t> {
     public:
+        BruteforceSearch() : data_(nullptr) { }
         BruteforceSearch(SpaceInterface <dist_t> *s) {
 
         }
@@ -91,13 +92,13 @@ namespace hnswlib {
         searchKnn(const void *query_data, size_t k) const {
             std::priority_queue<std::pair<dist_t, labeltype >> topResults;
             if (cur_element_count == 0) return topResults;
-            for (int i = 0; i < k; i++) {
+            for (size_t i = 0; i < k; i++) {
                 dist_t dist = fstdistfunc_(query_data, data_ + size_per_element_ * i, dist_func_param_);
                 topResults.push(std::pair<dist_t, labeltype>(dist, *((labeltype *) (data_ + size_per_element_ * i +
                                                                                     data_size_))));
             }
             dist_t lastdist = topResults.top().first;
-            for (int i = k; i < cur_element_count; i++) {
+            for (size_t i = k; i < cur_element_count; i++) {
                 dist_t dist = fstdistfunc_(query_data, data_ + size_per_element_ * i, dist_func_param_);
                 if (dist <= lastdist) {
                     topResults.push(std::pair<dist_t, labeltype>(dist, *((labeltype *) (data_ + size_per_element_ * i +

data/ext/hnswlib/src/hnswalg.h

@@ -17,6 +17,7 @@ namespace hnswlib {
     class HierarchicalNSW : public AlgorithmInterface<dist_t> {
     public:
         static const tableint max_update_element_locks = 65536;
+        HierarchicalNSW() : visited_list_pool_(nullptr), data_level0_memory_(nullptr), linkLists_(nullptr), cur_element_count(0) { }
         HierarchicalNSW(SpaceInterface<dist_t> *s) {
 
         }
@@ -757,7 +758,7 @@ namespace hnswlib {
             size_t dim = *((size_t *) dist_func_param_);
             std::vector<data_t> data;
             data_t* data_ptr = (data_t*) data_ptrv;
-            for (int i = 0; i < dim; i++) {
+            for (size_t i = 0; i < dim; i++) {
                 data.push_back(*data_ptr);
                 data_ptr += 1;
             }

data/ext/hnswlib/src/space_ip.h

@@ -247,6 +247,7 @@ namespace hnswlib {
         size_t data_size_;
         size_t dim_;
     public:
+        InnerProductSpace() : data_size_(0), dim_(0) { }
         InnerProductSpace(size_t dim) {
             fstdistfunc_ = InnerProduct;
     #if defined(USE_AVX) || defined(USE_SSE)

data/ext/hnswlib/src/space_l2.h

@@ -172,6 +172,7 @@ namespace hnswlib {
         size_t data_size_;
         size_t dim_;
     public:
+        L2Space() : data_size_(0), dim_(0) { }
         L2Space(size_t dim) {
             fstdistfunc_ = L2Sqr;
         #if defined(USE_SSE) || defined(USE_AVX)

data/hnswlib.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }.reject { |f| f.include?('dummy.rb') }
   end
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }

data/lib/hnswlib/version.rb

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

data/lib/hnswlib.rb

@@ -4,12 +4,12 @@ require_relative 'hnswlib/version'
 require_relative 'hnswlib/hnswlibext'
 
 module Hnswlib
-  # Index is a class that provides functions for k-nearest eighbors search.
+  # HnswIndex is a class that provides functions for k-nearest eighbors search.
   #
   # @example
   #   require 'hnswlib'
   #
-  #   index = Hnswlib::Index.new(n_features: 100, max_item: 10000)
+  #   index = Hnswlib::HnswIndex.new(n_features: 100, max_item: 10000)
   #
   #   5000.times do |item_id|
   #     item_vec = Array.new(100) { rand - 0.5 }
@@ -18,7 +18,7 @@ module Hnswlib
   #
   #   index.get_nns_by_item(0, 100)
   #
-  class Index
+  class HnswIndex
     # Returns the metric of index.
     # @return [String]
     attr_reader :metric
@@ -63,7 +63,6 @@ module Hnswlib
     # Remove the item vector.
     #
     # @param i [Integer] The ID of item.
-    # @return [Array]
     def remove_item(i)
       @index.mark_deleted(i)
     end
@@ -151,4 +150,7 @@ module Hnswlib
       @index.max_elements
     end
   end
+
+  # Index is alias of HnswIndex
+  Index = ::Hnswlib::HnswIndex
 end

data/sig/hnswlib.rbs

@@ -0,0 +1,69 @@
+module Hnswlib
+  VERSION: ::String
+  HSWLIB_VERSION: ::String
+
+  class HnswIndex
+    attr_reader metric: String
+
+    def initialize: (n_features: Integer n_features, max_item: Integer max_item, ?metric: ::String metric, ?m: ::Integer m, ?ef_construction: ::Integer ef_construction, ?random_seed: ::Integer random_seed) -> void
+    def add_item: (Integer i, Array[Float] v) -> bool
+    def get_item: (Integer i) -> Array[Float]
+    def remove_item: (Integer i) -> void
+    def get_nns_by_item: (Integer i, Integer n, ?include_distances: (true | false) include_distances) -> ([Array[Integer], Array[Float]] | Array[Integer])
+    def get_nns_by_vector: (Array[Float] v, Integer n, ?include_distances: (true | false) include_distances) -> ([Array[Integer], Array[Float]] | Array[Integer])
+    def resize_index: (Integer new_max_item) -> void
+    def set_ef: (Integer ef) -> void
+    def save: (String filename) -> void
+    def load: (String filename) -> void
+    def get_distance: (Integer i, Integer j) -> Float
+    def n_items: () -> Integer
+    def n_features: () -> Integer
+    def max_item: () -> Integer
+  end
+
+  Index: untyped
+
+  class L2Space
+    attr_accessor dim: Integer
+
+    def initialize: (Integer dim) -> void
+    def distance: (Array[Float] a, Array[Float] b) -> Float
+  end
+
+  class InnerProductSpace
+    attr_accessor dim: Integer
+
+    def initialize: (Integer dim) -> void
+    def distance: (Array[Float] a, Array[Float] b) -> Float
+  end
+
+  class BruteforceSearch
+    attr_accessor space: (::Hnswlib::L2Space | ::Hnswlib::InnerProductSpace)
+
+    def initialize: (space: (::Hnswlib::L2Space | ::Hnswlib::InnerProductSpace) space, 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]]
+  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) -> void
+    def add_point: (Array[Float] arr, Integer idx) -> bool
+    def current_count: () -> Integer
+    def get_ids: () -> Array[Integer]
+    def get_point: (Integer idx) -> Array[Float]
+    def load_index: (String filename) -> void
+    def mark_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 set_ef: (Integer ef) -> void
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hnswlib
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.4.0
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-24 00:00:00.000000000 Z
+date: 2021-09-11 00:00:00.000000000 Z
 dependencies: []
 description: Hnswlib.rb provides Ruby bindings for the Hnswlib.
 email:
@@ -27,6 +27,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- Steepfile
 - ext/hnswlib/extconf.rb
 - ext/hnswlib/hnswlibext.cpp
 - ext/hnswlib/hnswlibext.hpp
@@ -40,6 +41,7 @@ files:
 - hnswlib.gemspec
 - lib/hnswlib.rb
 - lib/hnswlib/version.rb
+- sig/hnswlib.rbs
 homepage: https://github.com/yoshoku/hnswlib.rb
 licenses:
 - Apache-2.0
@@ -62,7 +64,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: Ruby bindings for the Hnswlib.