annoy-rb 0.5.0 → 0.7.0

data/ext/annoy/src/annoylib.h

@@ -13,8 +13,8 @@
 // the License.
 
 
-#ifndef ANNOYLIB_H
-#define ANNOYLIB_H
+#ifndef ANNOY_ANNOYLIB_H
+#define ANNOY_ANNOYLIB_H
 
 #include <stdio.h>
 #include <sys/stat.h>
@@ -58,6 +58,10 @@ typedef signed __int64    int64_t;
 #include <queue>
 #include <limits>
 
+#if __cplusplus >= 201103L
+#include <type_traits>
+#endif
+
 #ifdef ANNOYLIB_MULTITHREADED_BUILD
 #include <thread>
 #include <mutex>
@@ -72,9 +76,9 @@ typedef signed __int64    int64_t;
 // This allows others to supply their own logger / error printer without
 // requiring Annoy to import their headers. See RcppAnnoy for a use case.
 #ifndef __ERROR_PRINTER_OVERRIDE__
-  #define showUpdate(...) { fprintf(stderr, __VA_ARGS__ ); }
+  #define annoylib_showUpdate(...) { fprintf(stderr, __VA_ARGS__ ); }
 #else
-  #define showUpdate(...) { __ERROR_PRINTER_OVERRIDE__( __VA_ARGS__ ); }
+  #define annoylib_showUpdate(...) { __ERROR_PRINTER_OVERRIDE__( __VA_ARGS__ ); }
 #endif
 
 // Portable alloc definition, cf Writing R Extensions, Section 1.6.4
@@ -87,40 +91,24 @@ typedef signed __int64    int64_t;
   # include <alloca.h>
 #endif
 
-inline void set_error_from_errno(char **error, const char* msg) {
-  showUpdate("%s: %s (%d)\n", msg, strerror(errno), errno);
-  if (error) {
-    *error = (char *)malloc(256);  // TODO: win doesn't support snprintf
-    sprintf(*error, "%s: %s (%d)", msg, strerror(errno), errno);
-  }
-}
-
-inline void set_error_from_string(char **error, const char* msg) {
-  showUpdate("%s\n", msg);
-  if (error) {
-    *error = (char *)malloc(strlen(msg) + 1);
-    strcpy(*error, msg);
-  }
-}
-
 // We let the v array in the Node struct take whatever space is needed, so this is a mostly insignificant number.
 // Compilers need *some* size defined for the v array, and some memory checking tools will flag for buffer overruns if this is set too low.
-#define V_ARRAY_SIZE 65536
+#define ANNOYLIB_V_ARRAY_SIZE 65536
 
 #ifndef _MSC_VER
-#define popcount __builtin_popcountll
+#define annoylib_popcount __builtin_popcountll
 #else // See #293, #358
-#define popcount cole_popcount
+#define annoylib_popcount cole_popcount
 #endif
 
 #if !defined(NO_MANUAL_VECTORIZATION) && defined(__GNUC__) && (__GNUC__ >6) && defined(__AVX512F__)  // See #402
-#define USE_AVX512
+#define ANNOYLIB_USE_AVX512
 #elif !defined(NO_MANUAL_VECTORIZATION) && defined(__AVX__) && defined (__SSE__) && defined(__SSE2__) && defined(__SSE3__)
-#define USE_AVX
+#define ANNOYLIB_USE_AVX
 #else
 #endif
 
-#if defined(USE_AVX) || defined(USE_AVX512)
+#if defined(ANNOYLIB_USE_AVX) || defined(ANNOYLIB_USE_AVX512)
 #if defined(_MSC_VER)
 #include <intrin.h>
 #elif defined(__GNUC__)
@@ -129,11 +117,30 @@ inline void set_error_from_string(char **error, const char* msg) {
 #endif
 
 #if !defined(__MINGW32__)
-#define FTRUNCATE_SIZE(x) static_cast<int64_t>(x)
+#define ANNOYLIB_FTRUNCATE_SIZE(x) static_cast<int64_t>(x)
 #else
-#define FTRUNCATE_SIZE(x) (x)
+#define ANNOYLIB_FTRUNCATE_SIZE(x) (x)
 #endif
 
+namespace Annoy {
+
+inline void set_error_from_errno(char **error, const char* msg) {
+  annoylib_showUpdate("%s: %s (%d)\n", msg, strerror(errno), errno);
+  if (error) {
+    *error = (char *)malloc(256);  // TODO: win doesn't support snprintf
+    sprintf(*error, "%s: %s (%d)", msg, strerror(errno), errno);
+  }
+}
+
+inline void set_error_from_string(char **error, const char* msg) {
+  annoylib_showUpdate("%s\n", msg);
+  if (error) {
+    *error = (char *)malloc(strlen(msg) + 1);
+    strcpy(*error, msg);
+  }
+}
+
+
 using std::vector;
 using std::pair;
 using std::numeric_limits;
@@ -145,7 +152,7 @@ inline bool remap_memory_and_truncate(void** _ptr, int _fd, size_t old_size, siz
     bool ok = ftruncate(_fd, new_size) != -1;
 #else
     munmap(*_ptr, old_size);
-    bool ok = ftruncate(_fd, FTRUNCATE_SIZE(new_size)) != -1;
+    bool ok = ftruncate(_fd, ANNOYLIB_FTRUNCATE_SIZE(new_size)) != -1;
 #ifdef MAP_POPULATE
     *_ptr = mmap(*_ptr, new_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE, _fd, 0);
 #else
@@ -194,7 +201,7 @@ inline T euclidean_distance(const T* x, const T* y, int f) {
   return d;
 }
 
-#ifdef USE_AVX
+#ifdef ANNOYLIB_USE_AVX
 // Horizontal single sum of 256bit vector.
 inline float hsum256_ps_avx(__m256 v) {
   const __m128 x128 = _mm_add_ps(_mm256_extractf128_ps(v, 1), _mm256_castps256_ps128(v));
@@ -277,7 +284,7 @@ inline float euclidean_distance<float>(const float* x, const float* y, int f) {
 
 #endif
 
-#ifdef USE_AVX512
+#ifdef ANNOYLIB_USE_AVX512
 template<>
 inline float dot<float>(const float* x, const float *y, int f) {
   float result = 0;
@@ -452,7 +459,7 @@ struct Angular : Base {
       S children[2]; // Will possibly store more than 2
       T norm;
     };
-    T v[V_ARRAY_SIZE];
+    T v[ANNOYLIB_V_ARRAY_SIZE];
   };
   template<typename S, typename T>
   static inline T distance(const Node<S, T>* x, const Node<S, T>* y, int f) {
@@ -523,7 +530,7 @@ struct DotProduct : Angular {
     S n_descendants;
     S children[2]; // Will possibly store more than 2
     T dot_factor;
-    T v[V_ARRAY_SIZE];
+    T v[ANNOYLIB_V_ARRAY_SIZE];
   };
 
   static const char* name() {
@@ -630,7 +637,7 @@ struct Hamming : Base {
   struct Node {
     S n_descendants;
     S children[2];
-    T v[V_ARRAY_SIZE];
+    T v[ANNOYLIB_V_ARRAY_SIZE];
   };
 
   static const size_t max_iterations = 20;
@@ -659,7 +666,7 @@ struct Hamming : Base {
   static inline T distance(const Node<S, T>* x, const Node<S, T>* y, int f) {
     size_t dist = 0;
     for (int i = 0; i < f; i++) {
-      dist += popcount(x->v[i] ^ y->v[i]);
+      dist += annoylib_popcount(x->v[i] ^ y->v[i]);
     }
     return dist;
   }
@@ -727,7 +734,7 @@ struct Minkowski : Base {
     S n_descendants;
     T a; // need an extra constant term to determine the offset of the plane
     S children[2];
-    T v[V_ARRAY_SIZE];
+    T v[ANNOYLIB_V_ARRAY_SIZE];
   };
   template<typename S, typename T>
   static inline T margin(const Node<S, T>* n, const T* y, int f) {
@@ -815,7 +822,7 @@ struct Manhattan : Minkowski {
   }
 };
 
-template<typename S, typename T>
+template<typename S, typename T, typename R = uint64_t>
 class AnnoyIndexInterface {
  public:
   // Note that the methods with an **error argument will allocate memory and write the pointer to that string if error is non-NULL
@@ -833,12 +840,18 @@ class AnnoyIndexInterface {
   virtual S get_n_trees() const = 0;
   virtual void verbose(bool v) = 0;
   virtual void get_item(S item, T* v) const = 0;
-  virtual void set_seed(int q) = 0;
+  virtual void set_seed(R q) = 0;
   virtual bool on_disk_build(const char* filename, char** error=NULL) = 0;
 };
 
 template<typename S, typename T, typename Distance, typename Random, class ThreadedBuildPolicy>
-  class AnnoyIndex : public AnnoyIndexInterface<S, T> {
+  class AnnoyIndex : public AnnoyIndexInterface<S, T, 
+#if __cplusplus >= 201103L
+    typename std::remove_const<decltype(Random::default_seed)>::type
+#else
+    typename Random::seed_type
+#endif
+    > {
   /*
    * We use random projection to build a forest of binary trees of all items.
    * Basically just split the hyperspace into two sides by a hyperplane,
@@ -849,6 +862,11 @@ template<typename S, typename T, typename Distance, typename Random, class Threa
 public:
   typedef Distance D;
   typedef typename D::template Node<S, T> Node;
+#if __cplusplus >= 201103L
+  typedef typename std::remove_const<decltype(Random::default_seed)>::type R;
+#else
+  typedef typename Random::seed_type R;
+#endif
 
 protected:
   const int _f;
@@ -859,8 +877,7 @@ protected:
   S _nodes_size;
   vector<S> _roots;
   S _K;
-  bool _is_seeded;
-  int _seed;
+  R _seed;
   bool _loaded;
   bool _verbose;
   int _fd;
@@ -869,8 +886,8 @@ protected:
 public:
 
    AnnoyIndex() : _f(0), _fd(0), _nodes(NULL), _n_items(0), _n_nodes(0), _nodes_size(0),
-                  _is_seeded(false), _loaded(false), _verbose(false), _on_disk(false), _built(false)  { }
-   AnnoyIndex(int f) : _f(f) {
+                  _loaded(false), _verbose(false), _on_disk(false), _built(false) { }
+   AnnoyIndex(int f) : _f(f), _seed(Random::default_seed) {
     _s = offsetof(Node, v) + _f * sizeof(T); // Size of each node
     _verbose = false;
     _built = false;
@@ -924,7 +941,7 @@ public:
       return false;
     }
     _nodes_size = 1;
-    if (ftruncate(_fd, FTRUNCATE_SIZE(_s) * FTRUNCATE_SIZE(_nodes_size)) == -1) {
+    if (ftruncate(_fd, ANNOYLIB_FTRUNCATE_SIZE(_s) * ANNOYLIB_FTRUNCATE_SIZE(_nodes_size)) == -1) {
       set_error_from_errno(error, "Unable to truncate");
       return false;
     }
@@ -960,7 +977,7 @@ public:
       memcpy(_get(_n_nodes + (S)i), _get(_roots[i]), _s);
     _n_nodes += _roots.size();
 
-    if (_verbose) showUpdate("has %d nodes\n", _n_nodes);
+    if (_verbose) annoylib_showUpdate("has %d nodes\n", _n_nodes);
     
     if (_on_disk) {
       if (!remap_memory_and_truncate(&_nodes, _fd,
@@ -1029,7 +1046,7 @@ public:
     _n_nodes = 0;
     _nodes_size = 0;
     _on_disk = false;
-    _is_seeded = false;
+    _seed = Random::default_seed;
     _roots.clear();
   }
 
@@ -1048,7 +1065,7 @@ public:
       }
     }
     reinitialize();
-    if (_verbose) showUpdate("unloaded\n");
+    if (_verbose) annoylib_showUpdate("unloaded\n");
   }
 
   bool load(const char* filename, bool prefault=false, char** error=NULL) {
@@ -1076,7 +1093,7 @@ public:
 #ifdef MAP_POPULATE
       flags |= MAP_POPULATE;
 #else
-      showUpdate("prefault is set to true, but MAP_POPULATE is not defined on this platform");
+      annoylib_showUpdate("prefault is set to true, but MAP_POPULATE is not defined on this platform");
 #endif
     }
     _nodes = (Node*)mmap(0, size, PROT_READ, flags, _fd, 0);
@@ -1100,7 +1117,7 @@ public:
     _loaded = true;
     _built = true;
     _n_items = m;
-    if (_verbose) showUpdate("found %lu roots with degree %d\n", _roots.size(), m);
+    if (_verbose) annoylib_showUpdate("found %lu roots with degree %d\n", _roots.size(), m);
     return true;
   }
 
@@ -1136,16 +1153,13 @@ public:
     memcpy(v, m->v, (_f) * sizeof(T));
   }
 
-  void set_seed(int seed) {
-    _is_seeded = true;
+  void set_seed(R seed) {
     _seed = seed;
   }
 
   void thread_build(int q, int thread_idx, ThreadedBuildPolicy& threaded_build_policy) {
-    Random _random;
     // Each thread needs its own seed, otherwise each thread would be building the same tree(s)
-    int seed = _is_seeded ? _seed + thread_idx : thread_idx;
-    _random.set_seed(seed);
+    Random _random(_seed + thread_idx);
 
     vector<S> thread_roots;
     while (1) {
@@ -1162,7 +1176,7 @@ public:
         }
       }
 
-      if (_verbose) showUpdate("pass %zd...\n", thread_roots.size());
+      if (_verbose) annoylib_showUpdate("pass %zd...\n", thread_roots.size());
 
       vector<S> indices;
       threaded_build_policy.lock_shared_nodes();
@@ -1192,14 +1206,14 @@ protected:
           static_cast<size_t>(_s) * static_cast<size_t>(_nodes_size), 
           static_cast<size_t>(_s) * static_cast<size_t>(new_nodes_size)) && 
           _verbose)
-          showUpdate("File truncation error\n");
+          annoylib_showUpdate("File truncation error\n");
     } else {
       _nodes = realloc(_nodes, _s * new_nodes_size);
       memset((char *) _nodes + (_nodes_size * _s) / sizeof(char), 0, (new_nodes_size - _nodes_size) * _s);
     }
     
     _nodes_size = new_nodes_size;
-    if (_verbose) showUpdate("Reallocating to %d nodes: old_address=%p, new_address=%p\n", new_nodes_size, old, _nodes);
+    if (_verbose) annoylib_showUpdate("Reallocating to %d nodes: old_address=%p, new_address=%p\n", new_nodes_size, old, _nodes);
   }
 
   void _allocate_size(S n, ThreadedBuildPolicy& threaded_build_policy) {
@@ -1281,7 +1295,7 @@ protected:
           bool side = D::side(m, n->v, _f, _random);
           children_indices[side].push_back(j);
         } else {
-          showUpdate("No node for index %d?\n", j);
+          annoylib_showUpdate("No node for index %d?\n", j);
         }
       }
 
@@ -1293,7 +1307,7 @@ protected:
     // If we didn't find a hyperplane, just randomize sides as a last option
     while (_split_imbalance(children_indices[0], children_indices[1]) > 0.99) {
       if (_verbose)
-        showUpdate("\tNo hyperplane found (left has %ld children, right has %ld children)\n",
+        annoylib_showUpdate("\tNo hyperplane found (left has %ld children, right has %ld children)\n",
           children_indices[0].size(), children_indices[1].size());
 
       children_indices[0].clear();
@@ -1477,5 +1491,7 @@ public:
 };
 #endif
 
+}
+
 #endif
 // vim: tabstop=2 shiftwidth=2

data/ext/annoy/src/kissrandom.h

@@ -1,5 +1,5 @@
-#ifndef KISSRANDOM_H
-#define KISSRANDOM_H
+#ifndef ANNOY_KISSRANDOM_H
+#define ANNOY_KISSRANDOM_H
 
 #if defined(_MSC_VER) && _MSC_VER == 1500
 typedef unsigned __int32    uint32_t;
@@ -8,6 +8,8 @@ typedef unsigned __int64    uint64_t;
 #include <stdint.h>
 #endif
 
+namespace Annoy {
+
 // KISS = "keep it simple, stupid", but high quality random number generator
 // http://www0.cs.ucl.ac.uk/staff/d.jones/GoodPracticeRNG.pdf -> "Use a good RNG and build it into your code"
 // http://mathforum.org/kb/message.jspa?messageID=6627731
@@ -20,8 +22,13 @@ struct Kiss32Random {
   uint32_t z;
   uint32_t c;
 
+  static const uint32_t default_seed = 123456789;
+#if __cplusplus < 201103L
+  typedef uint32_t seed_type;
+#endif
+
   // seed must be != 0
-  Kiss32Random(uint32_t seed = 123456789) {
+  Kiss32Random(uint32_t seed = default_seed) {
     x = seed;
     y = 362436000;
     z = 521288629;
@@ -64,8 +71,13 @@ struct Kiss64Random {
   uint64_t z;
   uint64_t c;
 
+  static const uint64_t default_seed = 1234567890987654321ULL;
+#if __cplusplus < 201103L
+  typedef uint64_t seed_type;
+#endif
+
   // seed must be != 0
-  Kiss64Random(uint64_t seed = 1234567890987654321ULL) {
+  Kiss64Random(uint64_t seed = default_seed) {
     x = seed;
     y = 362436362436362436ULL;
     z = 1066149217761810ULL;
@@ -97,10 +109,12 @@ struct Kiss64Random {
     // Draw random integer between 0 and n-1 where n is at most the number of data points you have
     return kiss() % n;
   }
-  inline void set_seed(uint32_t seed) {
+  inline void set_seed(uint64_t seed) {
     x = seed;
   }
 };
 
+}
+
 #endif
 // vim: tabstop=2 shiftwidth=2

data/lib/annoy/version.rb

@@ -3,8 +3,8 @@
 # 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.5.0'
+  VERSION = '0.7.0'
 
   # The version of Annoy included with gem.
-  ANNOY_VERSION = '1.17.0'
+  ANNOY_VERSION = '1.17.1'
 end

data/lib/annoy-rb.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'annoy'

data/lib/annoy.rb

@@ -30,30 +30,40 @@ module Annoy
     # @return [String]
     attr_reader :metric
 
+    # Returns the data type of feature.
+    # @return [String]
+    attr_reader :dtype
+
     # Create a new search index.
     #
     # @param n_features [Integer] The number of features (dimensions) of stored vector.
     # @param metric [String] The distance metric between vectors ('angular', 'dot', 'hamming', 'euclidean', or 'manhattan').
-    def initialize(n_features:, metric: 'angular')
+    # @param dtype [String] The data type of features ('float64' and 'float32').
+    #   If metric is given 'hamming', 'uint64' is automatically assigned to this argument.
+    def initialize(n_features:, metric: 'angular', dtype: 'float64') # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
       raise ArgumentError, 'Expect n_features to be Integer.' unless n_features.is_a?(Numeric)
 
       @n_features = n_features.to_i
       @metric = metric
+      @dtype = dtype
 
+      # rubocop:disable Layout/LineLength
       @index = case @metric
                when 'angular'
-                 AnnoyIndexAngular.new(@n_features)
+                 @dtype == 'float64' ? AnnoyIndexAngular.new(@n_features) : AnnoyIndexAngularFloat32.new(@n_features)
                when 'dot'
-                 AnnoyIndexDotProduct.new(@n_features)
+                 @dtype == 'float64' ? AnnoyIndexDotProduct.new(@n_features) : AnnoyIndexDotProductFloat32.new(@n_features)
                when 'hamming'
+                 @dtype = 'uint64'
                  AnnoyIndexHamming.new(@n_features)
                when 'euclidean'
-                 AnnoyIndexEuclidean.new(@n_features)
+                 @dtype == 'float64' ? AnnoyIndexEuclidean.new(@n_features) : AnnoyIndexEuclideanFloat32.new(@n_features)
                when 'manhattan'
-                 AnnoyIndexManhattan.new(@n_features)
+                 @dtype == 'float64' ? AnnoyIndexManhattan.new(@n_features) : AnnoyIndexManhattanFloat32.new(@n_features)
                else
                  raise ArgumentError, "No such metric: #{@metric}."
                end
+      # rubocop:enable Layout/LineLength
     end
 
     # Add item to be indexed.
@@ -69,6 +79,7 @@ module Annoy
     #
     # @param n_trees [Integer] The number of trees. More trees gives higher search precision.
     # @param n_jobs [Integer] The number of threads used to build the trees. If -1 is given, uses all available CPU cores.
+    # This parameter is enabled only if "-DANNOYLIB_MULTITHREADED_BUILD" is specified on gem installation.
     # @return [Boolean]
     def build(n_trees, n_jobs: -1)
       @index.build(n_trees, n_jobs)

data/sig/annoy.rbs

@@ -1,11 +1,13 @@
 module Annoy
   VERSION: String
+  ANNOY_VERSION: String
 
   class AnnoyIndex
     attr_reader n_features: Integer
     attr_reader metric: String
+    attr_reader dtype: String
 
-    def initialize: (n_features: Integer n_features, ?metric: String metric) -> void
+    def initialize: (n_features: Integer n_features, ?metric: String metric, ?dtype: String dtype) -> void
     def add_item: (Integer i, Array[Float | Integer] v) -> bool
     def build: (Integer n_trees, ?n_jobs: Integer n_jobs) -> bool
     def save: (String filename, ?prefault: bool prefault) -> bool
@@ -40,6 +42,24 @@ module Annoy
     def seed: (Integer s) -> nil
   end
 
+  class AnnoyIndexAngularFloat32
+    def initialize: (Integer n_features) -> void
+    def add_item: (Integer i, Array[Float] v) -> bool
+    def build: (Integer n_trees, Integer n_jobs) -> bool
+    def save: (String filename, bool prefault) -> bool
+    def load: (String filename, bool prefault) -> bool
+    def unload: () -> bool
+    def get_nns_by_item: (Integer i, Integer n, Integer search_k, (true | false) include_distances) -> ([Array[Integer], Array[Float]] | Array[Integer])
+    def get_nns_by_vector: (Array[Float] v, Integer n, Integer search_k, (true | false) include_distances) -> ([Array[Integer], Array[Float]] | Array[Integer])
+    def get_item: (Integer i) -> Array[Float]
+    def get_distance: (Integer i, Integer j) -> Float
+    def n_items: () -> Integer
+    def n_trees: () -> Integer
+    def on_disk_build: (String filename) -> bool
+    def verbose: (bool flag) -> nil
+    def seed: (Integer s) -> nil
+  end
+
   class AnnoyIndexDotProduct
     def initialize: (Integer n_features) -> void
     def add_item: (Integer i, Array[Float] v) -> bool
@@ -58,6 +78,24 @@ module Annoy
     def seed: (Integer s) -> nil
   end
 
+  class AnnoyIndexDotProductFloat32
+    def initialize: (Integer n_features) -> void
+    def add_item: (Integer i, Array[Float] v) -> bool
+    def build: (Integer n_trees, Integer n_jobs) -> bool
+    def save: (String filename, bool prefault) -> bool
+    def load: (String filename, bool prefault) -> bool
+    def unload: () -> bool
+    def get_nns_by_item: (Integer i, Integer n, Integer search_k, (true | false) include_distances) -> ([Array[Integer], Array[Float]] | Array[Integer])
+    def get_nns_by_vector: (Array[Float] v, Integer n, Integer search_k, (true | false) include_distances) -> ([Array[Integer], Array[Float]] | Array[Integer])
+    def get_item: (Integer i) -> Array[Float]
+    def get_distance: (Integer i, Integer j) -> Float
+    def n_items: () -> Integer
+    def n_trees: () -> Integer
+    def on_disk_build: (String filename) -> bool
+    def verbose: (bool flag) -> nil
+    def seed: (Integer s) -> nil
+  end
+
   class AnnoyIndexHamming
     def initialize: (Integer n_features) -> void
     def add_item: (Integer i, Array[Integer] v) -> bool
@@ -94,6 +132,24 @@ module Annoy
     def seed: (Integer s) -> nil
   end
 
+  class AnnoyIndexEuclideanFloat32
+    def initialize: (Integer n_features) -> void
+    def add_item: (Integer i, Array[Float] v) -> bool
+    def build: (Integer n_trees, Integer n_jobs) -> bool
+    def save: (String filename, bool prefault) -> bool
+    def load: (String filename, bool prefault) -> bool
+    def unload: () -> bool
+    def get_nns_by_item: (Integer i, Integer n, Integer search_k, (true | false) include_distances) -> ([Array[Integer], Array[Float]] | Array[Integer])
+    def get_nns_by_vector: (Array[Float] v, Integer n, Integer search_k, (true | false) include_distances) -> ([Array[Integer], Array[Float]] | Array[Integer])
+    def get_item: (Integer i) -> Array[Float]
+    def get_distance: (Integer i, Integer j) -> Float
+    def n_items: () -> Integer
+    def n_trees: () -> Integer
+    def on_disk_build: (String filename) -> bool
+    def verbose: (bool flag) -> nil
+    def seed: (Integer s) -> nil
+  end
+
   class AnnoyIndexManhattan
     def initialize: (Integer n_features) -> void
     def add_item: (Integer i, Array[Float] v) -> bool
@@ -111,4 +167,22 @@ module Annoy
     def verbose: (bool flag) -> nil
     def seed: (Integer s) -> nil
   end
+
+  class AnnoyIndexManhattanFloat32
+    def initialize: (Integer n_features) -> void
+    def add_item: (Integer i, Array[Float] v) -> bool
+    def build: (Integer n_trees, Integer n_jobs) -> bool
+    def save: (String filename, bool prefault) -> bool
+    def load: (String filename, bool prefault) -> bool
+    def unload: () -> bool
+    def get_nns_by_item: (Integer i, Integer n, Integer search_k, (true | false) include_distances) -> ([Array[Integer], Array[Float]] | Array[Integer])
+    def get_nns_by_vector: (Array[Float] v, Integer n, Integer search_k, (true | false) include_distances) -> ([Array[Integer], Array[Float]] | Array[Integer])
+    def get_item: (Integer i) -> Array[Float]
+    def get_distance: (Integer i, Integer j) -> Float
+    def n_items: () -> Integer
+    def n_trees: () -> Integer
+    def on_disk_build: (String filename) -> bool
+    def verbose: (bool flag) -> nil
+    def seed: (Integer s) -> nil
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: annoy-rb
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-11-27 00:00:00.000000000 Z
+date: 2022-08-13 00:00:00.000000000 Z
 dependencies: []
 description: Annoy.rb provides Ruby bindings for the Annoy (Approximate Nearest Neighbors
   Oh Yeah).
@@ -19,17 +19,9 @@ extensions:
 - ext/annoy/extconf.rb
 extra_rdoc_files: []
 files:
-- ".github/workflows/build.yml"
-- ".gitignore"
-- ".rspec"
 - CHANGELOG.md
-- CODE_OF_CONDUCT.md
-- Gemfile
 - LICENSE.txt
 - README.md
-- Rakefile
-- Steepfile
-- annoy-rb.gemspec
 - ext/annoy/annoyext.cpp
 - ext/annoy/annoyext.hpp
 - ext/annoy/extconf.rb
@@ -37,17 +29,19 @@ files:
 - ext/annoy/src/annoylib.h
 - ext/annoy/src/kissrandom.h
 - ext/annoy/src/mman.h
+- lib/annoy-rb.rb
 - lib/annoy.rb
 - lib/annoy/version.rb
 - sig/annoy.rbs
-homepage: https://github.com/yoshoku/annoy.rb
+homepage: https://github.com/yoshoku/annoy-rb
 licenses:
 - Apache-2.0
 metadata:
-  homepage_uri: https://github.com/yoshoku/annoy.rb
-  source_code_uri: https://github.com/yoshoku/annoy.rb
-  changelog_uri: https://github.com/yoshoku/annoy.rb/blob/main/CHANGELOG.md
-  documentation_uri: https://yoshoku.github.io/annoy.rb/doc/
+  homepage_uri: https://github.com/yoshoku/annoy-rb
+  source_code_uri: https://github.com/yoshoku/annoy-rb
+  changelog_uri: https://github.com/yoshoku/annoy-rb/blob/main/CHANGELOG.md
+  documentation_uri: https://yoshoku.github.io/annoy-rb/doc/
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -63,7 +57,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
 summary: Ruby bindings for the Annoy (Approximate Nearest Neighbors Oh Yeah).