faiss 0.1.4 → 0.2.1

data/vendor/faiss/faiss/IndexBinaryFlat.cpp

@@ -9,80 +9,100 @@
 
 #include <faiss/IndexBinaryFlat.h>
 
-#include <cstring>
+#include <faiss/impl/AuxIndexStructures.h>
+#include <faiss/impl/FaissAssert.h>
+#include <faiss/utils/Heap.h>
 #include <faiss/utils/hamming.h>
 #include <faiss/utils/utils.h>
-#include <faiss/utils/Heap.h>
-#include <faiss/impl/FaissAssert.h>
-#include <faiss/impl/AuxIndexStructures.h>
+#include <cstring>
 
 namespace faiss {
 
-IndexBinaryFlat::IndexBinaryFlat(idx_t d)
-    : IndexBinary(d) {}
+IndexBinaryFlat::IndexBinaryFlat(idx_t d) : IndexBinary(d) {}
 
-void IndexBinaryFlat::add(idx_t n, const uint8_t *x) {
-  xb.insert(xb.end(), x, x + n * code_size);
-  ntotal += n;
+void IndexBinaryFlat::add(idx_t n, const uint8_t* x) {
+    xb.insert(xb.end(), x, x + n * code_size);
+    ntotal += n;
 }
 
 void IndexBinaryFlat::reset() {
-  xb.clear();
-  ntotal = 0;
+    xb.clear();
+    ntotal = 0;
 }
 
-void IndexBinaryFlat::search(idx_t n, const uint8_t *x, idx_t k,
-                             int32_t *distances, idx_t *labels) const {
-  const idx_t block_size = query_batch_size;
-  for (idx_t s = 0; s < n; s += block_size) {
-    idx_t nn = block_size;
-    if (s + block_size > n) {
-      nn = n - s;
-    }
+void IndexBinaryFlat::search(
+        idx_t n,
+        const uint8_t* x,
+        idx_t k,
+        int32_t* distances,
+        idx_t* labels) const {
+    FAISS_THROW_IF_NOT(k > 0);
 
-    if (use_heap) {
-      // We see the distances and labels as heaps.
-      int_maxheap_array_t res = {
-        size_t(nn), size_t(k), labels + s * k, distances + s * k
-      };
+    const idx_t block_size = query_batch_size;
+    for (idx_t s = 0; s < n; s += block_size) {
+        idx_t nn = block_size;
+        if (s + block_size > n) {
+            nn = n - s;
+        }
 
-      hammings_knn_hc(&res, x + s * code_size, xb.data(), ntotal, code_size,
-                      /* ordered = */ true);
-    } else {
-      hammings_knn_mc(x + s * code_size, xb.data(), nn, ntotal, k, code_size,
-                      distances + s * k, labels + s * k);
+        if (use_heap) {
+            // We see the distances and labels as heaps.
+            int_maxheap_array_t res = {
+                    size_t(nn), size_t(k), labels + s * k, distances + s * k};
+
+            hammings_knn_hc(
+                    &res,
+                    x + s * code_size,
+                    xb.data(),
+                    ntotal,
+                    code_size,
+                    /* ordered = */ true);
+        } else {
+            hammings_knn_mc(
+                    x + s * code_size,
+                    xb.data(),
+                    nn,
+                    ntotal,
+                    k,
+                    code_size,
+                    distances + s * k,
+                    labels + s * k);
+        }
     }
-  }
 }
 
 size_t IndexBinaryFlat::remove_ids(const IDSelector& sel) {
-  idx_t j = 0;
-  for (idx_t i = 0; i < ntotal; i++) {
-    if (sel.is_member(i)) {
-      // should be removed
-    } else {
-      if (i > j) {
-        memmove(&xb[code_size * j], &xb[code_size * i], sizeof(xb[0]) * code_size);
-      }
-      j++;
+    idx_t j = 0;
+    for (idx_t i = 0; i < ntotal; i++) {
+        if (sel.is_member(i)) {
+            // should be removed
+        } else {
+            if (i > j) {
+                memmove(&xb[code_size * j],
+                        &xb[code_size * i],
+                        sizeof(xb[0]) * code_size);
+            }
+            j++;
+        }
+    }
+    long nremove = ntotal - j;
+    if (nremove > 0) {
+        ntotal = j;
+        xb.resize(ntotal * code_size);
     }
-  }
-  long nremove = ntotal - j;
-  if (nremove > 0) {
-    ntotal = j;
-    xb.resize(ntotal * code_size);
-  }
-  return nremove;
+    return nremove;
 }
 
-void IndexBinaryFlat::reconstruct(idx_t key, uint8_t *recons) const {
-  memcpy(recons, &(xb[code_size * key]), sizeof(*recons) * code_size);
+void IndexBinaryFlat::reconstruct(idx_t key, uint8_t* recons) const {
+    memcpy(recons, &(xb[code_size * key]), sizeof(*recons) * code_size);
 }
 
-void IndexBinaryFlat::range_search(idx_t n, const uint8_t *x, int radius,
-                   RangeSearchResult *result) const
-{
-    hamming_range_search (x, xb.data(), n, ntotal, radius, code_size, result);
+void IndexBinaryFlat::range_search(
+        idx_t n,
+        const uint8_t* x,
+        int radius,
+        RangeSearchResult* result) const {
+    hamming_range_search(x, xb.data(), n, ntotal, radius, code_size, result);
 }
 
-}  // namespace faiss
+} // namespace faiss

data/vendor/faiss/faiss/IndexBinaryFlat.h

@@ -16,42 +16,47 @@
 
 namespace faiss {
 
-
 /** Index that stores the full vectors and performs exhaustive search. */
 struct IndexBinaryFlat : IndexBinary {
-  /// database vectors, size ntotal * d / 8
-  std::vector<uint8_t> xb;
+    /// database vectors, size ntotal * d / 8
+    std::vector<uint8_t> xb;
 
-  /** Select between using a heap or counting to select the k smallest values
-   * when scanning inverted lists.
-   */
-  bool use_heap = true;
+    /** Select between using a heap or counting to select the k smallest values
+     * when scanning inverted lists.
+     */
+    bool use_heap = true;
 
-  size_t query_batch_size = 32;
+    size_t query_batch_size = 32;
 
-  explicit IndexBinaryFlat(idx_t d);
+    explicit IndexBinaryFlat(idx_t d);
 
-  void add(idx_t n, const uint8_t *x) override;
+    void add(idx_t n, const uint8_t* x) override;
 
-  void reset() override;
+    void reset() override;
 
-  void search(idx_t n, const uint8_t *x, idx_t k,
-              int32_t *distances, idx_t *labels) const override;
+    void search(
+            idx_t n,
+            const uint8_t* x,
+            idx_t k,
+            int32_t* distances,
+            idx_t* labels) const override;
 
-  void range_search(idx_t n, const uint8_t *x, int radius,
-                   RangeSearchResult *result) const override;
+    void range_search(
+            idx_t n,
+            const uint8_t* x,
+            int radius,
+            RangeSearchResult* result) const override;
 
-  void reconstruct(idx_t key, uint8_t *recons) const override;
+    void reconstruct(idx_t key, uint8_t* recons) const override;
 
-  /** Remove some ids. Note that because of the indexing structure,
-   * the semantics of this operation are different from the usual ones:
-   * the new ids are shifted. */
-  size_t remove_ids(const IDSelector& sel) override;
+    /** Remove some ids. Note that because of the indexing structure,
+     * the semantics of this operation are different from the usual ones:
+     * the new ids are shifted. */
+    size_t remove_ids(const IDSelector& sel) override;
 
-  IndexBinaryFlat() {}
+    IndexBinaryFlat() {}
 };
 
+} // namespace faiss
 
-}  // namespace faiss
-
-#endif  // INDEX_BINARY_FLAT_H
+#endif // INDEX_BINARY_FLAT_H

data/vendor/faiss/faiss/IndexBinaryFromFloat.cpp

@@ -9,71 +9,74 @@
 
 #include <faiss/IndexBinaryFromFloat.h>
 
+#include <faiss/utils/utils.h>
 #include <algorithm>
 #include <memory>
-#include <faiss/utils/utils.h>
 
 namespace faiss {
 
-
 IndexBinaryFromFloat::IndexBinaryFromFloat() {}
 
-IndexBinaryFromFloat::IndexBinaryFromFloat(Index *index)
-    : IndexBinary(index->d),
-      index(index),
-      own_fields(false) {
-  is_trained = index->is_trained;
-  ntotal = index->ntotal;
+IndexBinaryFromFloat::IndexBinaryFromFloat(Index* index)
+        : IndexBinary(index->d), index(index), own_fields(false) {
+    is_trained = index->is_trained;
+    ntotal = index->ntotal;
 }
 
 IndexBinaryFromFloat::~IndexBinaryFromFloat() {
-  if (own_fields) {
-    delete index;
-  }
+    if (own_fields) {
+        delete index;
+    }
 }
 
-void IndexBinaryFromFloat::add(idx_t n, const uint8_t *x) {
-  constexpr idx_t bs = 32768;
-  std::unique_ptr<float[]> xf(new float[bs * d]);
+void IndexBinaryFromFloat::add(idx_t n, const uint8_t* x) {
+    constexpr idx_t bs = 32768;
+    std::unique_ptr<float[]> xf(new float[bs * d]);
 
-  for (idx_t b = 0; b < n; b += bs) {
-    idx_t bn = std::min(bs, n - b);
-    binary_to_real(bn * d, x + b * code_size, xf.get());
+    for (idx_t b = 0; b < n; b += bs) {
+        idx_t bn = std::min(bs, n - b);
+        binary_to_real(bn * d, x + b * code_size, xf.get());
 
-    index->add(bn, xf.get());
-  }
-  ntotal = index->ntotal;
+        index->add(bn, xf.get());
+    }
+    ntotal = index->ntotal;
 }
 
 void IndexBinaryFromFloat::reset() {
-  index->reset();
-  ntotal = index->ntotal;
+    index->reset();
+    ntotal = index->ntotal;
 }
 
-void IndexBinaryFromFloat::search(idx_t n, const uint8_t *x, idx_t k,
-                                  int32_t *distances, idx_t *labels) const {
-  constexpr idx_t bs = 32768;
-  std::unique_ptr<float[]> xf(new float[bs * d]);
-  std::unique_ptr<float[]> df(new float[bs * k]);
-
-  for (idx_t b = 0; b < n; b += bs) {
-    idx_t bn = std::min(bs, n - b);
-    binary_to_real(bn * d, x + b * code_size, xf.get());
-
-    index->search(bn, xf.get(), k, df.get(), labels + b * k);
-    for (int i = 0; i < bn * k; ++i) {
-      distances[b * k + i] = int32_t(std::round(df[i] / 4.0));
+void IndexBinaryFromFloat::search(
+        idx_t n,
+        const uint8_t* x,
+        idx_t k,
+        int32_t* distances,
+        idx_t* labels) const {
+    FAISS_THROW_IF_NOT(k > 0);
+
+    constexpr idx_t bs = 32768;
+    std::unique_ptr<float[]> xf(new float[bs * d]);
+    std::unique_ptr<float[]> df(new float[bs * k]);
+
+    for (idx_t b = 0; b < n; b += bs) {
+        idx_t bn = std::min(bs, n - b);
+        binary_to_real(bn * d, x + b * code_size, xf.get());
+
+        index->search(bn, xf.get(), k, df.get(), labels + b * k);
+        for (int i = 0; i < bn * k; ++i) {
+            distances[b * k + i] = int32_t(std::round(df[i] / 4.0));
+        }
     }
-  }
 }
 
-void IndexBinaryFromFloat::train(idx_t n, const uint8_t *x) {
-  std::unique_ptr<float[]> xf(new float[n * d]);
-  binary_to_real(n * d, x, xf.get());
+void IndexBinaryFromFloat::train(idx_t n, const uint8_t* x) {
+    std::unique_ptr<float[]> xf(new float[n * d]);
+    binary_to_real(n * d, x, xf.get());
 
-  index->train(n, xf.get());
-  is_trained = true;
-  ntotal = index->ntotal;
+    index->train(n, xf.get());
+    is_trained = true;
+    ntotal = index->ntotal;
 }
 
-}  // namespace faiss
+} // namespace faiss

data/vendor/faiss/faiss/IndexBinaryFromFloat.h

@@ -12,10 +12,8 @@
 
 #include <faiss/IndexBinary.h>
 
-
 namespace faiss {
 
-
 struct Index;
 
 /** IndexBinary backed by a float Index.
@@ -26,27 +24,30 @@ struct Index;
  * vectors.
  */
 struct IndexBinaryFromFloat : IndexBinary {
-  Index *index = nullptr;
+    Index* index = nullptr;
 
-  bool own_fields = false; ///< Whether object owns the index pointer.
+    bool own_fields = false; ///< Whether object owns the index pointer.
 
-  IndexBinaryFromFloat();
+    IndexBinaryFromFloat();
 
-  explicit IndexBinaryFromFloat(Index *index);
+    explicit IndexBinaryFromFloat(Index* index);
 
-  ~IndexBinaryFromFloat();
+    ~IndexBinaryFromFloat();
 
-  void add(idx_t n, const uint8_t *x) override;
+    void add(idx_t n, const uint8_t* x) override;
 
-  void reset() override;
+    void reset() override;
 
-  void search(idx_t n, const uint8_t *x, idx_t k,
-              int32_t *distances, idx_t *labels) const override;
+    void search(
+            idx_t n,
+            const uint8_t* x,
+            idx_t k,
+            int32_t* distances,
+            idx_t* labels) const override;
 
-  void train(idx_t n, const uint8_t *x) override;
+    void train(idx_t n, const uint8_t* x) override;
 };
 
+} // namespace faiss
 
-}  // namespace faiss
-
-#endif  // FAISS_INDEX_BINARY_FROM_FLOAT_H
+#endif // FAISS_INDEX_BINARY_FROM_FLOAT_H

data/vendor/faiss/faiss/IndexBinaryHNSW.cpp

@@ -9,316 +9,299 @@
 
 #include <faiss/IndexBinaryHNSW.h>
 
-
-#include <memory>
-#include <cstdlib>
+#include <omp.h>
 #include <cassert>
-#include <cstring>
-#include <cstdio>
 #include <cmath>
-#include <omp.h>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <memory>
 
-#include <unordered_set>
 #include <queue>
+#include <unordered_set>
 
-#include <sys/types.h>
-#include <sys/stat.h>
 #include <stdint.h>
+#include <sys/stat.h>
+#include <sys/types.h>
 
-#include <faiss/utils/random.h>
-#include <faiss/utils/Heap.h>
-#include <faiss/impl/FaissAssert.h>
 #include <faiss/IndexBinaryFlat.h>
-#include <faiss/utils/hamming.h>
 #include <faiss/impl/AuxIndexStructures.h>
+#include <faiss/impl/FaissAssert.h>
+#include <faiss/utils/Heap.h>
+#include <faiss/utils/hamming.h>
+#include <faiss/utils/random.h>
 
 namespace faiss {
 
-
 /**************************************************************
  * add / search blocks of descriptors
  **************************************************************/
 
 namespace {
 
+void hnsw_add_vertices(
+        IndexBinaryHNSW& index_hnsw,
+        size_t n0,
+        size_t n,
+        const uint8_t* x,
+        bool verbose,
+        bool preset_levels = false) {
+    HNSW& hnsw = index_hnsw.hnsw;
+    size_t ntotal = n0 + n;
+    double t0 = getmillisecs();
+    if (verbose) {
+        printf("hnsw_add_vertices: adding %zd elements on top of %zd "
+               "(preset_levels=%d)\n",
+               n,
+               n0,
+               int(preset_levels));
+    }
+
+    int max_level = hnsw.prepare_level_tab(n, preset_levels);
 
-void hnsw_add_vertices(IndexBinaryHNSW& index_hnsw,
-                       size_t n0,
-                       size_t n, const uint8_t *x,
-                       bool verbose,
-                       bool preset_levels = false) {
-  HNSW& hnsw = index_hnsw.hnsw;
-  size_t ntotal = n0 + n;
-  double t0 = getmillisecs();
-  if (verbose) {
-    printf("hnsw_add_vertices: adding %zd elements on top of %zd "
-           "(preset_levels=%d)\n",
-           n, n0, int(preset_levels));
-  }
-
-  int max_level = hnsw.prepare_level_tab(n, preset_levels);
-
-  if (verbose) {
-    printf("  max_level = %d\n", max_level);
-  }
-
-  std::vector<omp_lock_t> locks(ntotal);
-  for(int i = 0; i < ntotal; i++) {
-    omp_init_lock(&locks[i]);
-  }
-
-  // add vectors from highest to lowest level
-  std::vector<int> hist;
-  std::vector<int> order(n);
-
-  { // make buckets with vectors of the same level
-
-    // build histogram
-    for (int i = 0; i < n; i++) {
-      HNSW::storage_idx_t pt_id = i + n0;
-      int pt_level = hnsw.levels[pt_id] - 1;
-      while (pt_level >= hist.size()) {
-        hist.push_back(0);
-      }
-      hist[pt_level] ++;
+    if (verbose) {
+        printf("  max_level = %d\n", max_level);
     }
 
-    // accumulate
-    std::vector<int> offsets(hist.size() + 1, 0);
-    for (int i = 0; i < hist.size() - 1; i++) {
-      offsets[i + 1] = offsets[i] + hist[i];
+    std::vector<omp_lock_t> locks(ntotal);
+    for (int i = 0; i < ntotal; i++) {
+        omp_init_lock(&locks[i]);
     }
 
-    // bucket sort
-    for (int i = 0; i < n; i++) {
-      HNSW::storage_idx_t pt_id = i + n0;
-      int pt_level = hnsw.levels[pt_id] - 1;
-      order[offsets[pt_level]++] = pt_id;
+    // add vectors from highest to lowest level
+    std::vector<int> hist;
+    std::vector<int> order(n);
+
+    { // make buckets with vectors of the same level
+
+        // build histogram
+        for (int i = 0; i < n; i++) {
+            HNSW::storage_idx_t pt_id = i + n0;
+            int pt_level = hnsw.levels[pt_id] - 1;
+            while (pt_level >= hist.size()) {
+                hist.push_back(0);
+            }
+            hist[pt_level]++;
+        }
+
+        // accumulate
+        std::vector<int> offsets(hist.size() + 1, 0);
+        for (int i = 0; i < hist.size() - 1; i++) {
+            offsets[i + 1] = offsets[i] + hist[i];
+        }
+
+        // bucket sort
+        for (int i = 0; i < n; i++) {
+            HNSW::storage_idx_t pt_id = i + n0;
+            int pt_level = hnsw.levels[pt_id] - 1;
+            order[offsets[pt_level]++] = pt_id;
+        }
     }
-  }
 
-  { // perform add
-    RandomGenerator rng2(789);
+    { // perform add
+        RandomGenerator rng2(789);
 
-    int i1 = n;
+        int i1 = n;
 
-    for (int pt_level = hist.size() - 1; pt_level >= 0; pt_level--) {
-      int i0 = i1 - hist[pt_level];
+        for (int pt_level = hist.size() - 1; pt_level >= 0; pt_level--) {
+            int i0 = i1 - hist[pt_level];
 
-      if (verbose) {
-        printf("Adding %d elements at level %d\n",
-               i1 - i0, pt_level);
-      }
+            if (verbose) {
+                printf("Adding %d elements at level %d\n", i1 - i0, pt_level);
+            }
 
-      // random permutation to get rid of dataset order bias
-      for (int j = i0; j < i1; j++) {
-        std::swap(order[j], order[j + rng2.rand_int(i1 - j)]);
-      }
+            // random permutation to get rid of dataset order bias
+            for (int j = i0; j < i1; j++) {
+                std::swap(order[j], order[j + rng2.rand_int(i1 - j)]);
+            }
 
 #pragma omp parallel
-      {
-        VisitedTable vt (ntotal);
-
-        std::unique_ptr<DistanceComputer> dis(
-          index_hnsw.get_distance_computer()
-        );
-        int prev_display = verbose && omp_get_thread_num() == 0 ? 0 : -1;
-
-#pragma omp  for schedule(dynamic)
-        for (int i = i0; i < i1; i++) {
-          HNSW::storage_idx_t pt_id = order[i];
-          dis->set_query((float *)(x + (pt_id - n0) * index_hnsw.code_size));
-
-          hnsw.add_with_locks(*dis, pt_level, pt_id, locks, vt);
-
-          if (prev_display >= 0 && i - i0 > prev_display + 10000) {
-            prev_display = i - i0;
-            printf("  %d / %d\r", i - i0, i1 - i0);
-            fflush(stdout);
-          }
+            {
+                VisitedTable vt(ntotal);
+
+                std::unique_ptr<DistanceComputer> dis(
+                        index_hnsw.get_distance_computer());
+                int prev_display =
+                        verbose && omp_get_thread_num() == 0 ? 0 : -1;
+
+#pragma omp for schedule(dynamic)
+                for (int i = i0; i < i1; i++) {
+                    HNSW::storage_idx_t pt_id = order[i];
+                    dis->set_query(
+                            (float*)(x + (pt_id - n0) * index_hnsw.code_size));
+
+                    hnsw.add_with_locks(*dis, pt_level, pt_id, locks, vt);
+
+                    if (prev_display >= 0 && i - i0 > prev_display + 10000) {
+                        prev_display = i - i0;
+                        printf("  %d / %d\r", i - i0, i1 - i0);
+                        fflush(stdout);
+                    }
+                }
+            }
+            i1 = i0;
         }
-      }
-      i1 = i0;
+        FAISS_ASSERT(i1 == 0);
+    }
+    if (verbose) {
+        printf("Done in %.3f ms\n", getmillisecs() - t0);
     }
-    FAISS_ASSERT(i1 == 0);
-  }
-  if (verbose) {
-    printf("Done in %.3f ms\n", getmillisecs() - t0);
-  }
-
-  for(int i = 0; i < ntotal; i++)
-    omp_destroy_lock(&locks[i]);
-}
 
+    for (int i = 0; i < ntotal; i++)
+        omp_destroy_lock(&locks[i]);
+}
 
 } // anonymous namespace
 
-
 /**************************************************************
  * IndexBinaryHNSW implementation
  **************************************************************/
 
-IndexBinaryHNSW::IndexBinaryHNSW()
-{
-  is_trained = true;
+IndexBinaryHNSW::IndexBinaryHNSW() {
+    is_trained = true;
 }
 
 IndexBinaryHNSW::IndexBinaryHNSW(int d, int M)
-    : IndexBinary(d),
-      hnsw(M),
-      own_fields(true),
-      storage(new IndexBinaryFlat(d))
-{
-  is_trained = true;
+        : IndexBinary(d),
+          hnsw(M),
+          own_fields(true),
+          storage(new IndexBinaryFlat(d)) {
+    is_trained = true;
 }
 
-IndexBinaryHNSW::IndexBinaryHNSW(IndexBinary *storage, int M)
-    : IndexBinary(storage->d),
-      hnsw(M),
-      own_fields(false),
-      storage(storage)
-{
-  is_trained = true;
+IndexBinaryHNSW::IndexBinaryHNSW(IndexBinary* storage, int M)
+        : IndexBinary(storage->d),
+          hnsw(M),
+          own_fields(false),
+          storage(storage) {
+    is_trained = true;
 }
 
 IndexBinaryHNSW::~IndexBinaryHNSW() {
-  if (own_fields) {
-    delete storage;
-  }
+    if (own_fields) {
+        delete storage;
+    }
 }
 
-void IndexBinaryHNSW::train(idx_t n, const uint8_t *x)
-{
-  // hnsw structure does not require training
-  storage->train(n, x);
-  is_trained = true;
+void IndexBinaryHNSW::train(idx_t n, const uint8_t* x) {
+    // hnsw structure does not require training
+    storage->train(n, x);
+    is_trained = true;
 }
 
-void IndexBinaryHNSW::search(idx_t n, const uint8_t *x, idx_t k,
-                             int32_t *distances, idx_t *labels) const
-{
+void IndexBinaryHNSW::search(
+        idx_t n,
+        const uint8_t* x,
+        idx_t k,
+        int32_t* distances,
+        idx_t* labels) const {
+    FAISS_THROW_IF_NOT(k > 0);
+
 #pragma omp parallel
-  {
-    VisitedTable vt(ntotal);
-    std::unique_ptr<DistanceComputer> dis(get_distance_computer());
+    {
+        VisitedTable vt(ntotal);
+        std::unique_ptr<DistanceComputer> dis(get_distance_computer());
 
 #pragma omp for
-    for(idx_t i = 0; i < n; i++) {
-      idx_t *idxi = labels + i * k;
-      float *simi = (float *)(distances + i * k);
+        for (idx_t i = 0; i < n; i++) {
+            idx_t* idxi = labels + i * k;
+            float* simi = (float*)(distances + i * k);
 
-      dis->set_query((float *)(x + i * code_size));
+            dis->set_query((float*)(x + i * code_size));
 
-      maxheap_heapify(k, simi, idxi);
-      hnsw.search(*dis, k, idxi, simi, vt);
-      maxheap_reorder(k, simi, idxi);
+            maxheap_heapify(k, simi, idxi);
+            hnsw.search(*dis, k, idxi, simi, vt);
+            maxheap_reorder(k, simi, idxi);
+        }
     }
-  }
 
 #pragma omp parallel for
-  for (int i = 0; i < n * k; ++i) {
-    distances[i] = std::round(((float *)distances)[i]);
-  }
+    for (int i = 0; i < n * k; ++i) {
+        distances[i] = std::round(((float*)distances)[i]);
+    }
 }
 
+void IndexBinaryHNSW::add(idx_t n, const uint8_t* x) {
+    FAISS_THROW_IF_NOT(is_trained);
+    int n0 = ntotal;
+    storage->add(n, x);
+    ntotal = storage->ntotal;
 
-void IndexBinaryHNSW::add(idx_t n, const uint8_t *x)
-{
-  FAISS_THROW_IF_NOT(is_trained);
-  int n0 = ntotal;
-  storage->add(n, x);
-  ntotal = storage->ntotal;
-
-  hnsw_add_vertices(*this, n0, n, x, verbose,
-                    hnsw.levels.size() == ntotal);
+    hnsw_add_vertices(*this, n0, n, x, verbose, hnsw.levels.size() == ntotal);
 }
 
-void IndexBinaryHNSW::reset()
-{
-  hnsw.reset();
-  storage->reset();
-  ntotal = 0;
+void IndexBinaryHNSW::reset() {
+    hnsw.reset();
+    storage->reset();
+    ntotal = 0;
 }
 
-void IndexBinaryHNSW::reconstruct(idx_t key, uint8_t *recons) const
-{
-  storage->reconstruct(key, recons);
+void IndexBinaryHNSW::reconstruct(idx_t key, uint8_t* recons) const {
+    storage->reconstruct(key, recons);
 }
 
-
 namespace {
 
-
-template<class HammingComputer>
+template <class HammingComputer>
 struct FlatHammingDis : DistanceComputer {
-  const int code_size;
-  const uint8_t *b;
-  size_t ndis;
-  HammingComputer hc;
-
-  float operator () (idx_t i) override {
-    ndis++;
-    return hc.hamming(b + i * code_size);
-  }
-
-  float symmetric_dis(idx_t i, idx_t j) override {
-    return HammingComputerDefault(b + j * code_size, code_size)
-      .hamming(b + i * code_size);
-  }
-
-
-  explicit FlatHammingDis(const IndexBinaryFlat& storage)
-      : code_size(storage.code_size),
-        b(storage.xb.data()),
-        ndis(0),
-        hc() {}
-
-  // NOTE: Pointers are cast from float in order to reuse the floating-point
-  //   DistanceComputer.
-  void set_query(const float *x) override {
-    hc.set((uint8_t *)x, code_size);
-  }
-
-  ~FlatHammingDis() override {
+    const int code_size;
+    const uint8_t* b;
+    size_t ndis;
+    HammingComputer hc;
+
+    float operator()(idx_t i) override {
+        ndis++;
+        return hc.hamming(b + i * code_size);
+    }
+
+    float symmetric_dis(idx_t i, idx_t j) override {
+        return HammingComputerDefault(b + j * code_size, code_size)
+                .hamming(b + i * code_size);
+    }
+
+    explicit FlatHammingDis(const IndexBinaryFlat& storage)
+            : code_size(storage.code_size),
+              b(storage.xb.data()),
+              ndis(0),
+              hc() {}
+
+    // NOTE: Pointers are cast from float in order to reuse the floating-point
+    //   DistanceComputer.
+    void set_query(const float* x) override {
+        hc.set((uint8_t*)x, code_size);
+    }
+
+    ~FlatHammingDis() override {
 #pragma omp critical
-    {
-      hnsw_stats.ndis += ndis;
+        { hnsw_stats.ndis += ndis; }
     }
-  }
 };
 
+} // namespace
+
+DistanceComputer* IndexBinaryHNSW::get_distance_computer() const {
+    IndexBinaryFlat* flat_storage = dynamic_cast<IndexBinaryFlat*>(storage);
+
+    FAISS_ASSERT(flat_storage != nullptr);
+
+    switch (code_size) {
+        case 4:
+            return new FlatHammingDis<HammingComputer4>(*flat_storage);
+        case 8:
+            return new FlatHammingDis<HammingComputer8>(*flat_storage);
+        case 16:
+            return new FlatHammingDis<HammingComputer16>(*flat_storage);
+        case 20:
+            return new FlatHammingDis<HammingComputer20>(*flat_storage);
+        case 32:
+            return new FlatHammingDis<HammingComputer32>(*flat_storage);
+        case 64:
+            return new FlatHammingDis<HammingComputer64>(*flat_storage);
+        default:
+            break;
+    }
 
-}  // namespace
-
-
-DistanceComputer *IndexBinaryHNSW::get_distance_computer() const {
-  IndexBinaryFlat *flat_storage = dynamic_cast<IndexBinaryFlat *>(storage);
-
-  FAISS_ASSERT(flat_storage != nullptr);
-
-  switch(code_size) {
-    case 4:
-      return new FlatHammingDis<HammingComputer4>(*flat_storage);
-    case 8:
-      return new FlatHammingDis<HammingComputer8>(*flat_storage);
-    case 16:
-      return new FlatHammingDis<HammingComputer16>(*flat_storage);
-    case 20:
-      return new FlatHammingDis<HammingComputer20>(*flat_storage);
-    case 32:
-      return new FlatHammingDis<HammingComputer32>(*flat_storage);
-    case 64:
-      return new FlatHammingDis<HammingComputer64>(*flat_storage);
-    default:
-      if (code_size % 8 == 0) {
-        return new FlatHammingDis<HammingComputerM8>(*flat_storage);
-      } else if (code_size % 4 == 0) {
-        return new FlatHammingDis<HammingComputerM4>(*flat_storage);
-      }
-  }
-
-  return new FlatHammingDis<HammingComputerDefault>(*flat_storage);
+    return new FlatHammingDis<HammingComputerDefault>(*flat_storage);
 }
 
-
 } // namespace faiss