faiss 0.2.0 → 0.2.4

data/vendor/faiss/faiss/IndexHNSW.cpp

@@ -9,44 +9,51 @@
 
 #include <faiss/IndexHNSW.h>
 
-
-#include <cstdlib>
+#include <omp.h>
 #include <cassert>
-#include <cstring>
-#include <cstdio>
 #include <cinttypes>
 #include <cmath>
-#include <omp.h>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
 
-#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>
 
 #ifdef __SSE__
 #endif
 
-#include <faiss/utils/distances.h>
-#include <faiss/utils/random.h>
-#include <faiss/utils/Heap.h>
-#include <faiss/impl/FaissAssert.h>
+#include <faiss/Index2Layer.h>
 #include <faiss/IndexFlat.h>
 #include <faiss/IndexIVFPQ.h>
-#include <faiss/Index2Layer.h>
 #include <faiss/impl/AuxIndexStructures.h>
-
+#include <faiss/impl/FaissAssert.h>
+#include <faiss/utils/Heap.h>
+#include <faiss/utils/distances.h>
+#include <faiss/utils/random.h>
 
 extern "C" {
 
 /* declare BLAS functions, see http://www.netlib.org/clapack/cblas/ */
 
-int sgemm_ (const char *transa, const char *transb, FINTEGER *m, FINTEGER *
-            n, FINTEGER *k, const float *alpha, const float *a,
-            FINTEGER *lda, const float *b, FINTEGER *
-            ldb, float *beta, float *c, FINTEGER *ldc);
-
+int sgemm_(
+        const char* transa,
+        const char* transb,
+        FINTEGER* m,
+        FINTEGER* n,
+        FINTEGER* k,
+        const float* alpha,
+        const float* a,
+        FINTEGER* lda,
+        const float* b,
+        FINTEGER* ldb,
+        float* beta,
+        float* c,
+        FINTEGER* ldc);
 }
 
 namespace faiss {
@@ -64,42 +71,36 @@ HNSWStats hnsw_stats;
 
 namespace {
 
-
 /* Wrap the distance computer into one that negates the
    distances. This makes supporting INNER_PRODUCE search easier */
 
-struct NegativeDistanceComputer: DistanceComputer {
-
+struct NegativeDistanceComputer : DistanceComputer {
     /// owned by this
-    DistanceComputer *basedis;
+    DistanceComputer* basedis;
 
-    explicit NegativeDistanceComputer(DistanceComputer *basedis):
-        basedis(basedis)
-    {}
+    explicit NegativeDistanceComputer(DistanceComputer* basedis)
+            : basedis(basedis) {}
 
-    void set_query(const float *x) override {
+    void set_query(const float* x) override {
         basedis->set_query(x);
     }
 
-     /// compute distance of vector i to current query
-    float operator () (idx_t i) override {
+    /// compute distance of vector i to current query
+    float operator()(idx_t i) override {
         return -(*basedis)(i);
     }
 
-     /// compute distance between two stored vectors
-    float symmetric_dis (idx_t i, idx_t j) override {
+    /// compute distance between two stored vectors
+    float symmetric_dis(idx_t i, idx_t j) override {
         return -basedis->symmetric_dis(i, j);
     }
 
-    virtual ~NegativeDistanceComputer ()
-    {
+    virtual ~NegativeDistanceComputer() {
         delete basedis;
     }
-
 };
 
-DistanceComputer *storage_distance_computer(const Index *storage)
-{
+DistanceComputer* storage_distance_computer(const Index* storage) {
     if (storage->metric_type == METRIC_INNER_PRODUCT) {
         return new NegativeDistanceComputer(storage->get_distance_computer());
     } else {
@@ -107,21 +108,23 @@ DistanceComputer *storage_distance_computer(const Index *storage)
     }
 }
 
-
-
-void hnsw_add_vertices(IndexHNSW &index_hnsw,
-                       size_t n0,
-                       size_t n, const float *x,
-                       bool verbose,
-                       bool preset_levels = false) {
+void hnsw_add_vertices(
+        IndexHNSW& index_hnsw,
+        size_t n0,
+        size_t n,
+        const float* x,
+        bool verbose,
+        bool preset_levels = false) {
     size_t d = index_hnsw.d;
-    HNSW & hnsw = index_hnsw.hnsw;
+    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));
+               n,
+               n0,
+               int(preset_levels));
     }
 
     if (n == 0) {
@@ -135,7 +138,7 @@ void hnsw_add_vertices(IndexHNSW &index_hnsw,
     }
 
     std::vector<omp_lock_t> locks(ntotal);
-    for(int i = 0; i < ntotal; i++)
+    for (int i = 0; i < ntotal; i++)
         omp_init_lock(&locks[i]);
 
     // add vectors from highest to lowest level
@@ -150,7 +153,7 @@ void hnsw_add_vertices(IndexHNSW &index_hnsw,
             int pt_level = hnsw.levels[pt_id] - 1;
             while (pt_level >= hist.size())
                 hist.push_back(0);
-            hist[pt_level] ++;
+            hist[pt_level]++;
         }
 
         // accumulate
@@ -167,8 +170,8 @@ void hnsw_add_vertices(IndexHNSW &index_hnsw,
         }
     }
 
-    idx_t check_period = InterruptCallback::get_period_hint
-        (max_level * index_hnsw.d * hnsw.efConstruction);
+    idx_t check_period = InterruptCallback::get_period_hint(
+            max_level * index_hnsw.d * hnsw.efConstruction);
 
     { // perform add
         RandomGenerator rng2(789);
@@ -179,8 +182,7 @@ void hnsw_add_vertices(IndexHNSW &index_hnsw,
             int i0 = i1 - hist[pt_level];
 
             if (verbose) {
-                printf("Adding %d elements at level %d\n",
-                       i1 - i0, pt_level);
+                printf("Adding %d elements at level %d\n", i1 - i0, pt_level);
             }
 
             // random permutation to get rid of dataset order bias
@@ -189,20 +191,21 @@ void hnsw_add_vertices(IndexHNSW &index_hnsw,
 
             bool interrupt = false;
 
-#pragma omp parallel if(i1 > i0 + 100)
+#pragma omp parallel if (i1 > i0 + 100)
             {
-                VisitedTable vt (ntotal);
+                VisitedTable vt(ntotal);
 
-                DistanceComputer *dis =
-                    storage_distance_computer (index_hnsw.storage);
+                DistanceComputer* dis =
+                        storage_distance_computer(index_hnsw.storage);
                 ScopeDeleter1<DistanceComputer> del(dis);
-                int prev_display = verbose && omp_get_thread_num() == 0 ? 0 : -1;
+                int prev_display =
+                        verbose && omp_get_thread_num() == 0 ? 0 : -1;
                 size_t counter = 0;
 
-#pragma omp  for schedule(dynamic)
+#pragma omp for schedule(dynamic)
                 for (int i = i0; i < i1; i++) {
                     storage_idx_t pt_id = order[i];
-                    dis->set_query (x + (pt_id - n0) * d);
+                    dis->set_query(x + (pt_id - n0) * d);
 
                     // cannot break
                     if (interrupt) {
@@ -218,16 +221,15 @@ void hnsw_add_vertices(IndexHNSW &index_hnsw,
                     }
 
                     if (counter % check_period == 0) {
-                        if (InterruptCallback::is_interrupted ()) {
+                        if (InterruptCallback::is_interrupted()) {
                             interrupt = true;
                         }
                     }
                     counter++;
                 }
-
             }
             if (interrupt) {
-                FAISS_THROW_MSG ("computation interrupted");
+                FAISS_THROW_MSG("computation interrupted");
             }
             i1 = i0;
         }
@@ -237,36 +239,30 @@ void hnsw_add_vertices(IndexHNSW &index_hnsw,
         printf("Done in %.3f ms\n", getmillisecs() - t0);
     }
 
-    for(int i = 0; i < ntotal; i++) {
+    for (int i = 0; i < ntotal; i++) {
         omp_destroy_lock(&locks[i]);
     }
 }
 
-
-}  // namespace
-
-
-
+} // namespace
 
 /**************************************************************
  * IndexHNSW implementation
  **************************************************************/
 
-IndexHNSW::IndexHNSW(int d, int M, MetricType metric):
-    Index(d, metric),
-    hnsw(M),
-    own_fields(false),
-    storage(nullptr),
-    reconstruct_from_neighbors(nullptr)
-{}
-
-IndexHNSW::IndexHNSW(Index *storage, int M):
-    Index(storage->d, storage->metric_type),
-    hnsw(M),
-    own_fields(false),
-    storage(storage),
-    reconstruct_from_neighbors(nullptr)
-{}
+IndexHNSW::IndexHNSW(int d, int M, MetricType metric)
+        : Index(d, metric),
+          hnsw(M),
+          own_fields(false),
+          storage(nullptr),
+          reconstruct_from_neighbors(nullptr) {}
+
+IndexHNSW::IndexHNSW(Index* storage, int M)
+        : Index(storage->d, storage->metric_type),
+          hnsw(M),
+          own_fields(false),
+          storage(storage),
+          reconstruct_from_neighbors(nullptr) {}
 
 IndexHNSW::~IndexHNSW() {
     if (own_fields) {
@@ -274,68 +270,75 @@ IndexHNSW::~IndexHNSW() {
     }
 }
 
-void IndexHNSW::train(idx_t n, const float* x)
-{
-    FAISS_THROW_IF_NOT_MSG(storage,
-       "Please use IndexHNSWFlat (or variants) instead of IndexHNSW directly");
+void IndexHNSW::train(idx_t n, const float* x) {
+    FAISS_THROW_IF_NOT_MSG(
+            storage,
+            "Please use IndexHNSWFlat (or variants) instead of IndexHNSW directly");
     // hnsw structure does not require training
-    storage->train (n, x);
+    storage->train(n, x);
     is_trained = true;
 }
 
-void IndexHNSW::search (idx_t n, const float *x, idx_t k,
-                        float *distances, idx_t *labels) const
+void IndexHNSW::search(
+        idx_t n,
+        const float* x,
+        idx_t k,
+        float* distances,
+        idx_t* labels) const
 
 {
-    FAISS_THROW_IF_NOT_MSG(storage,
-       "Please use IndexHNSWFlat (or variants) instead of IndexHNSW directly");
+    FAISS_THROW_IF_NOT(k > 0);
+
+    FAISS_THROW_IF_NOT_MSG(
+            storage,
+            "Please use IndexHNSWFlat (or variants) instead of IndexHNSW directly");
     size_t n1 = 0, n2 = 0, n3 = 0, ndis = 0, nreorder = 0;
 
-    idx_t check_period = InterruptCallback::get_period_hint (
-          hnsw.max_level * d * hnsw.efSearch);
+    idx_t check_period = InterruptCallback::get_period_hint(
+            hnsw.max_level * d * hnsw.efSearch);
 
     for (idx_t i0 = 0; i0 < n; i0 += check_period) {
         idx_t i1 = std::min(i0 + check_period, n);
 
 #pragma omp parallel
         {
-            VisitedTable vt (ntotal);
+            VisitedTable vt(ntotal);
 
-            DistanceComputer *dis = storage_distance_computer(storage);
+            DistanceComputer* dis = storage_distance_computer(storage);
             ScopeDeleter1<DistanceComputer> del(dis);
 
-#pragma omp for reduction (+ : n1, n2, n3, ndis, nreorder)
-            for(idx_t i = i0; i < i1; i++) {
-                idx_t * idxi = labels + i * k;
-                float * simi = distances + i * k;
+#pragma omp for reduction(+ : n1, n2, n3, ndis, nreorder)
+            for (idx_t i = i0; i < i1; i++) {
+                idx_t* idxi = labels + i * k;
+                float* simi = distances + i * k;
                 dis->set_query(x + i * d);
 
-                maxheap_heapify (k, simi, idxi);
+                maxheap_heapify(k, simi, idxi);
                 HNSWStats stats = hnsw.search(*dis, k, idxi, simi, vt);
                 n1 += stats.n1;
                 n2 += stats.n2;
                 n3 += stats.n3;
                 ndis += stats.ndis;
                 nreorder += stats.nreorder;
-                maxheap_reorder (k, simi, idxi);
+                maxheap_reorder(k, simi, idxi);
 
                 if (reconstruct_from_neighbors &&
                     reconstruct_from_neighbors->k_reorder != 0) {
                     int k_reorder = reconstruct_from_neighbors->k_reorder;
-                    if (k_reorder == -1 || k_reorder > k) k_reorder = k;
+                    if (k_reorder == -1 || k_reorder > k)
+                        k_reorder = k;
 
                     nreorder += reconstruct_from_neighbors->compute_distances(
-                             k_reorder, idxi, x + i * d, simi);
+                            k_reorder, idxi, x + i * d, simi);
 
                     // sort top k_reorder
-                    maxheap_heapify (k_reorder, simi, idxi, simi, idxi, k_reorder);
-                    maxheap_reorder (k_reorder, simi, idxi);
+                    maxheap_heapify(
+                            k_reorder, simi, idxi, simi, idxi, k_reorder);
+                    maxheap_reorder(k_reorder, simi, idxi);
                 }
-
             }
-
         }
-        InterruptCallback::check ();
+        InterruptCallback::check();
     }
 
     if (metric_type == METRIC_INNER_PRODUCT) {
@@ -348,42 +351,36 @@ void IndexHNSW::search (idx_t n, const float *x, idx_t k,
     hnsw_stats.combine({n1, n2, n3, ndis, nreorder});
 }
 
-
-void IndexHNSW::add(idx_t n, const float *x)
-{
-    FAISS_THROW_IF_NOT_MSG(storage,
-       "Please use IndexHNSWFlat (or variants) instead of IndexHNSW directly");
+void IndexHNSW::add(idx_t n, const float* x) {
+    FAISS_THROW_IF_NOT_MSG(
+            storage,
+            "Please use IndexHNSWFlat (or variants) instead of IndexHNSW directly");
     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 IndexHNSW::reset()
-{
+void IndexHNSW::reset() {
     hnsw.reset();
     storage->reset();
     ntotal = 0;
 }
 
-void IndexHNSW::reconstruct (idx_t key, float* recons) const
-{
+void IndexHNSW::reconstruct(idx_t key, float* recons) const {
     storage->reconstruct(key, recons);
 }
 
-void IndexHNSW::shrink_level_0_neighbors(int new_size)
-{
+void IndexHNSW::shrink_level_0_neighbors(int new_size) {
 #pragma omp parallel
     {
-        DistanceComputer *dis = storage_distance_computer(storage);
+        DistanceComputer* dis = storage_distance_computer(storage);
         ScopeDeleter1<DistanceComputer> del(dis);
 
 #pragma omp for
         for (idx_t i = 0; i < ntotal; i++) {
-
             size_t begin, end;
             hnsw.neighbor_range(i, 0, &begin, &end);
 
@@ -391,15 +388,16 @@ void IndexHNSW::shrink_level_0_neighbors(int new_size)
 
             for (size_t j = begin; j < end; j++) {
                 int v1 = hnsw.neighbors[j];
-                if (v1 < 0) break;
+                if (v1 < 0)
+                    break;
                 initial_list.emplace(dis->symmetric_dis(i, v1), v1);
 
                 // initial_list.emplace(qdis(v1), v1);
             }
 
             std::vector<NodeDistFarther> shrunk_list;
-            HNSW::shrink_neighbor_list(*dis, initial_list,
-                                       shrunk_list, new_size);
+            HNSW::shrink_neighbor_list(
+                    *dis, initial_list, shrunk_list, new_size);
 
             for (size_t j = begin; j < end; j++) {
                 if (j - begin < shrunk_list.size())
@@ -409,44 +407,50 @@ void IndexHNSW::shrink_level_0_neighbors(int new_size)
             }
         }
     }
-
 }
 
 void IndexHNSW::search_level_0(
-    idx_t n, const float *x, idx_t k,
-    const storage_idx_t *nearest, const float *nearest_d,
-    float *distances, idx_t *labels, int nprobe,
-    int search_type) const
-{
+        idx_t n,
+        const float* x,
+        idx_t k,
+        const storage_idx_t* nearest,
+        const float* nearest_d,
+        float* distances,
+        idx_t* labels,
+        int nprobe,
+        int search_type) const {
+    FAISS_THROW_IF_NOT(k > 0);
+    FAISS_THROW_IF_NOT(nprobe > 0);
 
     storage_idx_t ntotal = hnsw.levels.size();
     size_t n1 = 0, n2 = 0, n3 = 0, ndis = 0, nreorder = 0;
 
 #pragma omp parallel
     {
-        DistanceComputer *qdis = storage_distance_computer(storage);
+        DistanceComputer* qdis = storage_distance_computer(storage);
         ScopeDeleter1<DistanceComputer> del(qdis);
 
-        VisitedTable vt (ntotal);
+        VisitedTable vt(ntotal);
 
-#pragma omp for reduction (+ : n1, n2, n3, ndis, nreorder)
-        for(idx_t i = 0; i < n; i++) {
-            idx_t * idxi = labels + i * k;
-            float * simi = distances + i * k;
+#pragma omp for reduction(+ : n1, n2, n3, ndis, nreorder)
+        for (idx_t i = 0; i < n; i++) {
+            idx_t* idxi = labels + i * k;
+            float* simi = distances + i * k;
 
             qdis->set_query(x + i * d);
-            maxheap_heapify (k, simi, idxi);
+            maxheap_heapify(k, simi, idxi);
 
             if (search_type == 1) {
-
                 int nres = 0;
 
-                for(int j = 0; j < nprobe; j++) {
+                for (int j = 0; j < nprobe; j++) {
                     storage_idx_t cj = nearest[i * nprobe + j];
 
-                    if (cj < 0) break;
+                    if (cj < 0)
+                        break;
 
-                    if (vt.get(cj)) continue;
+                    if (vt.get(cj))
+                        continue;
 
                     int candidates_size = std::max(hnsw.efSearch, int(k));
                     MinimaxHeap candidates(candidates_size);
@@ -455,45 +459,46 @@ void IndexHNSW::search_level_0(
 
                     HNSWStats search_stats;
                     nres = hnsw.search_from_candidates(
-                      *qdis, k, idxi, simi,
-                      candidates, vt, search_stats, 0, nres
-                    );
+                            *qdis,
+                            k,
+                            idxi,
+                            simi,
+                            candidates,
+                            vt,
+                            search_stats,
+                            0,
+                            nres);
                     n1 += search_stats.n1;
                     n2 += search_stats.n2;
                     n3 += search_stats.n3;
                     ndis += search_stats.ndis;
                     nreorder += search_stats.nreorder;
-
                 }
             } else if (search_type == 2) {
-
                 int candidates_size = std::max(hnsw.efSearch, int(k));
                 candidates_size = std::max(candidates_size, nprobe);
 
                 MinimaxHeap candidates(candidates_size);
-                for(int j = 0; j < nprobe; j++) {
+                for (int j = 0; j < nprobe; j++) {
                     storage_idx_t cj = nearest[i * nprobe + j];
 
-                    if (cj < 0) break;
+                    if (cj < 0)
+                        break;
                     candidates.push(cj, nearest_d[i * nprobe + j]);
                 }
 
                 HNSWStats search_stats;
                 hnsw.search_from_candidates(
-                  *qdis, k, idxi, simi,
-                  candidates, vt, search_stats, 0
-                );
+                        *qdis, k, idxi, simi, candidates, vt, search_stats, 0);
                 n1 += search_stats.n1;
                 n2 += search_stats.n2;
                 n3 += search_stats.n3;
                 ndis += search_stats.ndis;
                 nreorder += search_stats.nreorder;
-
             }
             vt.advance();
 
-            maxheap_reorder (k, simi, idxi);
-
+            maxheap_reorder(k, simi, idxi);
         }
     }
 
@@ -501,13 +506,14 @@ void IndexHNSW::search_level_0(
 }
 
 void IndexHNSW::init_level_0_from_knngraph(
-       int k, const float *D, const idx_t *I)
-{
-    int dest_size = hnsw.nb_neighbors (0);
+        int k,
+        const float* D,
+        const idx_t* I) {
+    int dest_size = hnsw.nb_neighbors(0);
 
 #pragma omp parallel for
     for (idx_t i = 0; i < ntotal; i++) {
-        DistanceComputer *qdis = storage_distance_computer(storage);
+        DistanceComputer* qdis = storage_distance_computer(storage);
         std::vector<float> vec(d);
         storage->reconstruct(i, vec.data());
         qdis->set_query(vec.data());
@@ -516,8 +522,10 @@ void IndexHNSW::init_level_0_from_knngraph(
 
         for (size_t j = 0; j < k; j++) {
             int v1 = I[i * k + j];
-            if (v1 == i) continue;
-            if (v1 < 0) break;
+            if (v1 == i)
+                continue;
+            if (v1 < 0)
+                break;
             initial_list.emplace(D[i * k + j], v1);
         }
 
@@ -536,35 +544,31 @@ void IndexHNSW::init_level_0_from_knngraph(
     }
 }
 
-
-
 void IndexHNSW::init_level_0_from_entry_points(
-          int n, const storage_idx_t *points,
-          const storage_idx_t *nearests)
-{
-
+        int n,
+        const storage_idx_t* points,
+        const storage_idx_t* nearests) {
     std::vector<omp_lock_t> locks(ntotal);
-    for(int i = 0; i < ntotal; i++)
+    for (int i = 0; i < ntotal; i++)
         omp_init_lock(&locks[i]);
 
 #pragma omp parallel
     {
-        VisitedTable vt (ntotal);
+        VisitedTable vt(ntotal);
 
-        DistanceComputer *dis = storage_distance_computer(storage);
+        DistanceComputer* dis = storage_distance_computer(storage);
         ScopeDeleter1<DistanceComputer> del(dis);
         std::vector<float> vec(storage->d);
 
-#pragma omp  for schedule(dynamic)
+#pragma omp for schedule(dynamic)
         for (int i = 0; i < n; i++) {
             storage_idx_t pt_id = points[i];
             storage_idx_t nearest = nearests[i];
-            storage->reconstruct (pt_id, vec.data());
-            dis->set_query (vec.data());
+            storage->reconstruct(pt_id, vec.data());
+            dis->set_query(vec.data());
 
-            hnsw.add_links_starting_from(*dis, pt_id,
-                                         nearest, (*dis)(nearest),
-                                         0, locks.data(), vt);
+            hnsw.add_links_starting_from(
+                    *dis, pt_id, nearest, (*dis)(nearest), 0, locks.data(), vt);
 
             if (verbose && i % 10000 == 0) {
                 printf("  %d / %d\r", i, n);
@@ -576,25 +580,23 @@ void IndexHNSW::init_level_0_from_entry_points(
         printf("\n");
     }
 
-    for(int i = 0; i < ntotal; i++)
+    for (int i = 0; i < ntotal; i++)
         omp_destroy_lock(&locks[i]);
 }
 
-void IndexHNSW::reorder_links()
-{
+void IndexHNSW::reorder_links() {
     int M = hnsw.nb_neighbors(0);
 
 #pragma omp parallel
     {
-        std::vector<float> distances (M);
-        std::vector<size_t> order (M);
-        std::vector<storage_idx_t> tmp (M);
-        DistanceComputer *dis = storage_distance_computer(storage);
+        std::vector<float> distances(M);
+        std::vector<size_t> order(M);
+        std::vector<storage_idx_t> tmp(M);
+        DistanceComputer* dis = storage_distance_computer(storage);
         ScopeDeleter1<DistanceComputer> del(dis);
 
 #pragma omp for
-        for(storage_idx_t i = 0; i < ntotal; i++) {
-
+        for (storage_idx_t i = 0; i < ntotal; i++) {
             size_t begin, end;
             hnsw.neighbor_range(i, 0, &begin, &end);
 
@@ -605,21 +607,18 @@ void IndexHNSW::reorder_links()
                     break;
                 }
                 distances[j - begin] = dis->symmetric_dis(i, nj);
-                tmp [j - begin] = nj;
+                tmp[j - begin] = nj;
             }
 
-            fvec_argsort (end - begin, distances.data(), order.data());
+            fvec_argsort(end - begin, distances.data(), order.data());
             for (size_t j = begin; j < end; j++) {
                 hnsw.neighbors[j] = tmp[order[j - begin]];
             }
         }
-
     }
 }
 
-
-void IndexHNSW::link_singletons()
-{
+void IndexHNSW::link_singletons() {
     printf("search for singletons\n");
 
     std::vector<bool> seen(ntotal);
@@ -629,7 +628,8 @@ void IndexHNSW::link_singletons()
         hnsw.neighbor_range(i, 0, &begin, &end);
         for (size_t j = begin; j < end; j++) {
             storage_idx_t ni = hnsw.neighbors[j];
-            if (ni >= 0) seen[ni] = true;
+            if (ni >= 0)
+                seen[ni] = true;
         }
     }
 
@@ -645,27 +645,25 @@ void IndexHNSW::link_singletons()
     }
 
     printf("  Found %d / %" PRId64 " singletons (%d appear in a level above)\n",
-           n_sing, ntotal, n_sing_l1);
+           n_sing,
+           ntotal,
+           n_sing_l1);
 
-    std::vector<float>recons(singletons.size() * d);
+    std::vector<float> recons(singletons.size() * d);
     for (int i = 0; i < singletons.size(); i++) {
-
         FAISS_ASSERT(!"not implemented");
-
     }
-
-
 }
 
-
 /**************************************************************
  * ReconstructFromNeighbors implementation
  **************************************************************/
 
-
 ReconstructFromNeighbors::ReconstructFromNeighbors(
-             const IndexHNSW & index, size_t k, size_t nsq):
-    index(index), k(k), nsq(nsq) {
+        const IndexHNSW& index,
+        size_t k,
+        size_t nsq)
+        : index(index), k(k), nsq(nsq) {
     M = index.hnsw.nb_neighbors(0);
     FAISS_ASSERT(k <= 256);
     code_size = k == 1 ? 0 : nsq;
@@ -676,16 +674,16 @@ ReconstructFromNeighbors::ReconstructFromNeighbors(
     k_reorder = -1;
 }
 
-void ReconstructFromNeighbors::reconstruct(storage_idx_t i, float *x, float *tmp) const
-{
-
-
-    const HNSW & hnsw = index.hnsw;
+void ReconstructFromNeighbors::reconstruct(
+        storage_idx_t i,
+        float* x,
+        float* tmp) const {
+    const HNSW& hnsw = index.hnsw;
     size_t begin, end;
     hnsw.neighbor_range(i, 0, &begin, &end);
 
     if (k == 1 || nsq == 1) {
-        const float * beta;
+        const float* beta;
         if (k == 1) {
             beta = codebook.data();
         } else {
@@ -700,9 +698,9 @@ void ReconstructFromNeighbors::reconstruct(storage_idx_t i, float *x, float *tmp
             x[l] = w0 * tmp[l];
 
         for (size_t j = begin; j < end; j++) {
-
             storage_idx_t ji = hnsw.neighbors[j];
-            if (ji < 0) ji = i;
+            if (ji < 0)
+                ji = i;
             float w = beta[j - begin + 1];
             index.storage->reconstruct(ji, tmp);
             for (int l = 0; l < d; l++)
@@ -712,8 +710,8 @@ void ReconstructFromNeighbors::reconstruct(storage_idx_t i, float *x, float *tmp
         int idx0 = codes[2 * i];
         int idx1 = codes[2 * i + 1];
 
-        const float *beta0 = codebook.data() +  idx0 * (M + 1);
-        const float *beta1 = codebook.data() + (idx1 + k) * (M + 1);
+        const float* beta0 = codebook.data() + idx0 * (M + 1);
+        const float* beta1 = codebook.data() + (idx1 + k) * (M + 1);
 
         index.storage->reconstruct(i, tmp);
 
@@ -729,7 +727,8 @@ void ReconstructFromNeighbors::reconstruct(storage_idx_t i, float *x, float *tmp
 
         for (size_t j = begin; j < end; j++) {
             storage_idx_t ji = hnsw.neighbors[j];
-            if (ji < 0) ji = i;
+            if (ji < 0)
+                ji = i;
             index.storage->reconstruct(ji, tmp);
             float w;
             w = beta0[j - begin + 1];
@@ -741,10 +740,10 @@ void ReconstructFromNeighbors::reconstruct(storage_idx_t i, float *x, float *tmp
                 x[l] += w * tmp[l];
         }
     } else {
-        std::vector<const float *> betas(nsq);
+        std::vector<const float*> betas(nsq);
         {
-            const float *b = codebook.data();
-            const uint8_t *c = &codes[i * code_size];
+            const float* b = codebook.data();
+            const uint8_t* c = &codes[i * code_size];
             for (int sq = 0; sq < nsq; sq++) {
                 betas[sq] = b + (*c++) * (M + 1);
                 b += (M + 1) * k;
@@ -766,7 +765,8 @@ void ReconstructFromNeighbors::reconstruct(storage_idx_t i, float *x, float *tmp
 
         for (size_t j = begin; j < end; j++) {
             storage_idx_t ji = hnsw.neighbors[j];
-            if (ji < 0) ji = i;
+            if (ji < 0)
+                ji = i;
 
             index.storage->reconstruct(ji, tmp);
             int d0 = 0;
@@ -782,10 +782,10 @@ void ReconstructFromNeighbors::reconstruct(storage_idx_t i, float *x, float *tmp
     }
 }
 
-void ReconstructFromNeighbors::reconstruct_n(storage_idx_t n0,
-                                             storage_idx_t ni,
-                                             float *x) const
-{
+void ReconstructFromNeighbors::reconstruct_n(
+        storage_idx_t n0,
+        storage_idx_t ni,
+        float* x) const {
 #pragma omp parallel
     {
         std::vector<float> tmp(index.d);
@@ -797,13 +797,15 @@ void ReconstructFromNeighbors::reconstruct_n(storage_idx_t n0,
 }
 
 size_t ReconstructFromNeighbors::compute_distances(
-    size_t n, const idx_t *shortlist,
-    const float *query, float *distances) const
-{
+        size_t n,
+        const idx_t* shortlist,
+        const float* query,
+        float* distances) const {
     std::vector<float> tmp(2 * index.d);
     size_t ncomp = 0;
     for (int i = 0; i < n; i++) {
-        if (shortlist[i] < 0) break;
+        if (shortlist[i] < 0)
+            break;
         reconstruct(shortlist[i], tmp.data(), tmp.data() + index.d);
         distances[i] = fvec_L2sqr(query, tmp.data(), index.d);
         ncomp++;
@@ -811,9 +813,9 @@ size_t ReconstructFromNeighbors::compute_distances(
     return ncomp;
 }
 
-void ReconstructFromNeighbors::get_neighbor_table(storage_idx_t i, float *tmp1) const
-{
-    const HNSW & hnsw = index.hnsw;
+void ReconstructFromNeighbors::get_neighbor_table(storage_idx_t i, float* tmp1)
+        const {
+    const HNSW& hnsw = index.hnsw;
     size_t begin, end;
     hnsw.neighbor_range(i, 0, &begin, &end);
     size_t d = index.d;
@@ -822,25 +824,24 @@ void ReconstructFromNeighbors::get_neighbor_table(storage_idx_t i, float *tmp1)
 
     for (size_t j = begin; j < end; j++) {
         storage_idx_t ji = hnsw.neighbors[j];
-        if (ji < 0) ji = i;
+        if (ji < 0)
+            ji = i;
         index.storage->reconstruct(ji, tmp1 + (j - begin + 1) * d);
     }
-
 }
 
-
 /// called by add_codes
 void ReconstructFromNeighbors::estimate_code(
-       const float *x, storage_idx_t i, uint8_t *code) const
-{
-
+        const float* x,
+        storage_idx_t i,
+        uint8_t* code) const {
     // fill in tmp table with the neighbor values
-    float *tmp1 = new float[d * (M + 1) + (d * k)];
-    float *tmp2 = tmp1 + d * (M + 1);
+    float* tmp1 = new float[d * (M + 1) + (d * k)];
+    float* tmp2 = tmp1 + d * (M + 1);
     ScopeDeleter<float> del(tmp1);
 
     // collect coordinates of base
-    get_neighbor_table (i, tmp1);
+    get_neighbor_table(i, tmp1);
 
     for (size_t sq = 0; sq < nsq; sq++) {
         int d0 = sq * dsub;
@@ -850,10 +851,19 @@ void ReconstructFromNeighbors::estimate_code(
             FINTEGER dsubi = dsub;
             float zero = 0, one = 1;
 
-            sgemm_ ("N", "N", &dsubi, &ki, &m1, &one,
-                    tmp1 + d0, &di,
-                    codebook.data() + sq * (m1 * k), &m1,
-                    &zero, tmp2, &dsubi);
+            sgemm_("N",
+                   "N",
+                   &dsubi,
+                   &ki,
+                   &m1,
+                   &one,
+                   tmp1 + d0,
+                   &di,
+                   codebook.data() + sq * (m1 * k),
+                   &m1,
+                   &zero,
+                   tmp2,
+                   &dsubi);
         }
 
         float min = HUGE_VAL;
@@ -867,11 +877,9 @@ void ReconstructFromNeighbors::estimate_code(
         }
         code[sq] = argmin;
     }
-
 }
 
-void ReconstructFromNeighbors::add_codes(size_t n, const float *x)
-{
+void ReconstructFromNeighbors::add_codes(size_t n, const float* x) {
     if (k == 1) { // nothing to encode
         ntotal += n;
         return;
@@ -879,98 +887,94 @@ void ReconstructFromNeighbors::add_codes(size_t n, const float *x)
     codes.resize(codes.size() + code_size * n);
 #pragma omp parallel for
     for (int i = 0; i < n; i++) {
-        estimate_code(x + i * index.d, ntotal + i,
-                      codes.data() + (ntotal + i) * code_size);
+        estimate_code(
+                x + i * index.d,
+                ntotal + i,
+                codes.data() + (ntotal + i) * code_size);
     }
     ntotal += n;
-    FAISS_ASSERT (codes.size() == ntotal * code_size);
+    FAISS_ASSERT(codes.size() == ntotal * code_size);
 }
 
-
 /**************************************************************
  * IndexHNSWFlat implementation
  **************************************************************/
 
-
-IndexHNSWFlat::IndexHNSWFlat()
-{
+IndexHNSWFlat::IndexHNSWFlat() {
     is_trained = true;
 }
 
-IndexHNSWFlat::IndexHNSWFlat(int d, int M, MetricType metric):
-    IndexHNSW(new IndexFlat(d, metric), M)
-{
+IndexHNSWFlat::IndexHNSWFlat(int d, int M, MetricType metric)
+        : IndexHNSW(new IndexFlat(d, metric), M) {
     own_fields = true;
     is_trained = true;
 }
 
-
 /**************************************************************
  * IndexHNSWPQ implementation
  **************************************************************/
 
-
 IndexHNSWPQ::IndexHNSWPQ() {}
 
-IndexHNSWPQ::IndexHNSWPQ(int d, int pq_m, int M):
-    IndexHNSW(new IndexPQ(d, pq_m, 8), M)
-{
+IndexHNSWPQ::IndexHNSWPQ(int d, int pq_m, int M)
+        : IndexHNSW(new IndexPQ(d, pq_m, 8), M) {
     own_fields = true;
     is_trained = false;
 }
 
-void IndexHNSWPQ::train(idx_t n, const float* x)
-{
-    IndexHNSW::train (n, x);
-    (dynamic_cast<IndexPQ*> (storage))->pq.compute_sdc_table();
+void IndexHNSWPQ::train(idx_t n, const float* x) {
+    IndexHNSW::train(n, x);
+    (dynamic_cast<IndexPQ*>(storage))->pq.compute_sdc_table();
 }
 
-
 /**************************************************************
  * IndexHNSWSQ implementation
  **************************************************************/
 
-
-IndexHNSWSQ::IndexHNSWSQ(int d, ScalarQuantizer::QuantizerType qtype, int M,
-                         MetricType metric):
-    IndexHNSW (new IndexScalarQuantizer (d, qtype, metric), M)
-{
+IndexHNSWSQ::IndexHNSWSQ(
+        int d,
+        ScalarQuantizer::QuantizerType qtype,
+        int M,
+        MetricType metric)
+        : IndexHNSW(new IndexScalarQuantizer(d, qtype, metric), M) {
     is_trained = false;
     own_fields = true;
 }
 
 IndexHNSWSQ::IndexHNSWSQ() {}
 
-
 /**************************************************************
  * IndexHNSW2Level implementation
  **************************************************************/
 
-
-IndexHNSW2Level::IndexHNSW2Level(Index *quantizer, size_t nlist, int m_pq, int M):
-    IndexHNSW (new Index2Layer (quantizer, nlist, m_pq), M)
-{
+IndexHNSW2Level::IndexHNSW2Level(
+        Index* quantizer,
+        size_t nlist,
+        int m_pq,
+        int M)
+        : IndexHNSW(new Index2Layer(quantizer, nlist, m_pq), M) {
     own_fields = true;
     is_trained = false;
 }
 
 IndexHNSW2Level::IndexHNSW2Level() {}
 
-
 namespace {
 
-
 // same as search_from_candidates but uses v
 // visno -> is in result list
 // visno + 1 -> in result list + in candidates
-int search_from_candidates_2(const HNSW & hnsw,
-                             DistanceComputer & qdis, int k,
-                             idx_t *I, float * D,
-                             MinimaxHeap &candidates,
-                             VisitedTable &vt,
-                             HNSWStats &stats,
-                             int level, int nres_in = 0)
-{
+int search_from_candidates_2(
+        const HNSW& hnsw,
+        DistanceComputer& qdis,
+        int k,
+        idx_t* I,
+        float* D,
+        MinimaxHeap& candidates,
+        VisitedTable& vt,
+        HNSWStats& stats,
+        int level,
+        int nres_in = 0) {
     int nres = nres_in;
     int ndis = 0;
     for (int i = 0; i < candidates.size(); i++) {
@@ -990,7 +994,8 @@ int search_from_candidates_2(const HNSW & hnsw,
 
         for (size_t j = begin; j < end; j++) {
             int v1 = hnsw.neighbors[j];
-            if (v1 < 0) break;
+            if (v1 < 0)
+                break;
             if (vt.visited[v1] == vt.visno + 1) {
                 // nothing to do
             } else {
@@ -1001,9 +1006,9 @@ int search_from_candidates_2(const HNSW & hnsw,
                 // never seen before --> add to heap
                 if (vt.visited[v1] < vt.visno) {
                     if (nres < k) {
-                        faiss::maxheap_push (++nres, D, I, d, v1);
+                        faiss::maxheap_push(++nres, D, I, d, v1);
                     } else if (d < D[0]) {
-                        faiss::maxheap_replace_top (nres, D, I, d, v1);
+                        faiss::maxheap_replace_top(nres, D, I, d, v1);
                     }
                 }
                 vt.visited[v1] = vt.visno + 1;
@@ -1016,65 +1021,76 @@ int search_from_candidates_2(const HNSW & hnsw,
         }
     }
 
-    stats.n1 ++;
+    stats.n1++;
     if (candidates.size() == 0)
-        stats.n2 ++;
+        stats.n2++;
 
     return nres;
 }
 
+} // namespace
 
-}  // namespace
+void IndexHNSW2Level::search(
+        idx_t n,
+        const float* x,
+        idx_t k,
+        float* distances,
+        idx_t* labels) const {
+    FAISS_THROW_IF_NOT(k > 0);
 
-void IndexHNSW2Level::search (idx_t n, const float *x, idx_t k,
-                              float *distances, idx_t *labels) const
-{
     if (dynamic_cast<const Index2Layer*>(storage)) {
-        IndexHNSW::search (n, x, k, distances, labels);
+        IndexHNSW::search(n, x, k, distances, labels);
 
     } else { // "mixed" search
         size_t n1 = 0, n2 = 0, n3 = 0, ndis = 0, nreorder = 0;
 
-        const IndexIVFPQ *index_ivfpq =
-            dynamic_cast<const IndexIVFPQ*>(storage);
+        const IndexIVFPQ* index_ivfpq =
+                dynamic_cast<const IndexIVFPQ*>(storage);
 
         int nprobe = index_ivfpq->nprobe;
 
         std::unique_ptr<idx_t[]> coarse_assign(new idx_t[n * nprobe]);
         std::unique_ptr<float[]> coarse_dis(new float[n * nprobe]);
 
-        index_ivfpq->quantizer->search (n, x, nprobe, coarse_dis.get(),
-                                        coarse_assign.get());
+        index_ivfpq->quantizer->search(
+                n, x, nprobe, coarse_dis.get(), coarse_assign.get());
 
-        index_ivfpq->search_preassigned (n, x, k, coarse_assign.get(),
-                                         coarse_dis.get(), distances, labels,
-                                         false);
+        index_ivfpq->search_preassigned(
+                n,
+                x,
+                k,
+                coarse_assign.get(),
+                coarse_dis.get(),
+                distances,
+                labels,
+                false);
 
 #pragma omp parallel
         {
-            VisitedTable vt (ntotal);
-            DistanceComputer *dis = storage_distance_computer(storage);
+            VisitedTable vt(ntotal);
+            DistanceComputer* dis = storage_distance_computer(storage);
             ScopeDeleter1<DistanceComputer> del(dis);
 
             int candidates_size = hnsw.upper_beam;
             MinimaxHeap candidates(candidates_size);
 
-#pragma omp for reduction (+ : n1, n2, n3, ndis, nreorder)
-            for(idx_t i = 0; i < n; i++) {
-                idx_t * idxi = labels + i * k;
-                float * simi = distances + i * k;
+#pragma omp for reduction(+ : n1, n2, n3, ndis, nreorder)
+            for (idx_t i = 0; i < n; i++) {
+                idx_t* idxi = labels + i * k;
+                float* simi = distances + i * k;
                 dis->set_query(x + i * d);
 
                 // mark all inverted list elements as visited
 
                 for (int j = 0; j < nprobe; j++) {
                     idx_t key = coarse_assign[j + i * nprobe];
-                    if (key < 0) break;
-                    size_t list_length = index_ivfpq->get_list_size (key);
-                    const idx_t * ids = index_ivfpq->invlists->get_ids (key);
+                    if (key < 0)
+                        break;
+                    size_t list_length = index_ivfpq->get_list_size(key);
+                    const idx_t* ids = index_ivfpq->invlists->get_ids(key);
 
                     for (int jj = 0; jj < list_length; jj++) {
-                        vt.set (ids[jj]);
+                        vt.set(ids[jj]);
                     }
                 }
 
@@ -1084,23 +1100,29 @@ void IndexHNSW2Level::search (idx_t n, const float *x, idx_t k,
                 int search_policy = 2;
 
                 if (search_policy == 1) {
-
-                    for (int j = 0 ; j < hnsw.upper_beam && j < k; j++) {
-                        if (idxi[j] < 0) break;
-                        candidates.push (idxi[j], simi[j]);
+                    for (int j = 0; j < hnsw.upper_beam && j < k; j++) {
+                        if (idxi[j] < 0)
+                            break;
+                        candidates.push(idxi[j], simi[j]);
                         // search_from_candidates adds them back
                         idxi[j] = -1;
                         simi[j] = HUGE_VAL;
                     }
 
                     // reorder from sorted to heap
-                    maxheap_heapify (k, simi, idxi, simi, idxi, k);
+                    maxheap_heapify(k, simi, idxi, simi, idxi, k);
 
                     HNSWStats search_stats;
                     hnsw.search_from_candidates(
-                      *dis, k, idxi, simi,
-                      candidates, vt, search_stats, 0, k
-                    );
+                            *dis,
+                            k,
+                            idxi,
+                            simi,
+                            candidates,
+                            vt,
+                            search_stats,
+                            0,
+                            k);
                     n1 += search_stats.n1;
                     n2 += search_stats.n2;
                     n3 += search_stats.n3;
@@ -1110,63 +1132,65 @@ void IndexHNSW2Level::search (idx_t n, const float *x, idx_t k,
                     vt.advance();
 
                 } else if (search_policy == 2) {
-
-                    for (int j = 0 ; j < hnsw.upper_beam && j < k; j++) {
-                        if (idxi[j] < 0) break;
-                        candidates.push (idxi[j], simi[j]);
+                    for (int j = 0; j < hnsw.upper_beam && j < k; j++) {
+                        if (idxi[j] < 0)
+                            break;
+                        candidates.push(idxi[j], simi[j]);
                     }
 
                     // reorder from sorted to heap
-                    maxheap_heapify (k, simi, idxi, simi, idxi, k);
+                    maxheap_heapify(k, simi, idxi, simi, idxi, k);
 
                     HNSWStats search_stats;
-                    search_from_candidates_2 (
-                        hnsw, *dis, k, idxi, simi,
-                        candidates, vt, search_stats, 0, k);
+                    search_from_candidates_2(
+                            hnsw,
+                            *dis,
+                            k,
+                            idxi,
+                            simi,
+                            candidates,
+                            vt,
+                            search_stats,
+                            0,
+                            k);
                     n1 += search_stats.n1;
                     n2 += search_stats.n2;
                     n3 += search_stats.n3;
                     ndis += search_stats.ndis;
                     nreorder += search_stats.nreorder;
 
-                    vt.advance ();
-                    vt.advance ();
-
+                    vt.advance();
+                    vt.advance();
                 }
 
-                maxheap_reorder (k, simi, idxi);
+                maxheap_reorder(k, simi, idxi);
             }
         }
 
         hnsw_stats.combine({n1, n2, n3, ndis, nreorder});
     }
-
-
 }
 
+void IndexHNSW2Level::flip_to_ivf() {
+    Index2Layer* storage2l = dynamic_cast<Index2Layer*>(storage);
 
-void IndexHNSW2Level::flip_to_ivf ()
-{
-    Index2Layer *storage2l =
-        dynamic_cast<Index2Layer*>(storage);
+    FAISS_THROW_IF_NOT(storage2l);
 
-    FAISS_THROW_IF_NOT (storage2l);
-
-    IndexIVFPQ * index_ivfpq =
-        new IndexIVFPQ (storage2l->q1.quantizer,
-                        d, storage2l->q1.nlist,
-                        storage2l->pq.M, 8);
+    IndexIVFPQ* index_ivfpq = new IndexIVFPQ(
+            storage2l->q1.quantizer,
+            d,
+            storage2l->q1.nlist,
+            storage2l->pq.M,
+            8);
     index_ivfpq->pq = storage2l->pq;
     index_ivfpq->is_trained = storage2l->is_trained;
     index_ivfpq->precompute_table();
     index_ivfpq->own_fields = storage2l->q1.own_fields;
     storage2l->transfer_to_IVFPQ(*index_ivfpq);
-    index_ivfpq->make_direct_map (true);
+    index_ivfpq->make_direct_map(true);
 
     storage = index_ivfpq;
     delete storage2l;
-
 }
 
-
-}  // namespace faiss
+} // namespace faiss