faiss 0.2.0 → 0.2.4

data/vendor/faiss/faiss/utils/distances.cpp

@@ -10,10 +10,10 @@
 #include <faiss/utils/distances.h>
 
 #include <algorithm>
-#include <cstdio>
 #include <cassert>
-#include <cstring>
 #include <cmath>
+#include <cstdio>
+#include <cstring>
 
 #include <omp.h>
 
@@ -21,186 +21,153 @@
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/ResultHandler.h>
 
-
-
 #ifndef FINTEGER
 #define FINTEGER long
 #endif
 
-
 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 {
 
-
-
 /***************************************************************************
  * Matrix/vector ops
  ***************************************************************************/
 
-
-
-
 /* Compute the L2 norm of a set of nx vectors */
-void fvec_norms_L2 (float * __restrict nr,
-                    const float * __restrict x,
-                    size_t d, size_t nx)
-{
-
+void fvec_norms_L2(
+        float* __restrict nr,
+        const float* __restrict x,
+        size_t d,
+        size_t nx) {
 #pragma omp parallel for
     for (int64_t i = 0; i < nx; i++) {
-        nr[i] = sqrtf (fvec_norm_L2sqr (x + i * d, d));
+        nr[i] = sqrtf(fvec_norm_L2sqr(x + i * d, d));
     }
 }
 
-void fvec_norms_L2sqr (float * __restrict nr,
-                       const float * __restrict x,
-                       size_t d, size_t nx)
-{
+void fvec_norms_L2sqr(
+        float* __restrict nr,
+        const float* __restrict x,
+        size_t d,
+        size_t nx) {
 #pragma omp parallel for
     for (int64_t i = 0; i < nx; i++)
-        nr[i] = fvec_norm_L2sqr (x + i * d, d);
+        nr[i] = fvec_norm_L2sqr(x + i * d, d);
 }
 
-
-
-void fvec_renorm_L2 (size_t d, size_t nx, float * __restrict x)
-{
+void fvec_renorm_L2(size_t d, size_t nx, float* __restrict x) {
 #pragma omp parallel for
     for (int64_t i = 0; i < nx; i++) {
-        float * __restrict xi = x + i * d;
+        float* __restrict xi = x + i * d;
 
-        float nr = fvec_norm_L2sqr (xi, d);
+        float nr = fvec_norm_L2sqr(xi, d);
 
         if (nr > 0) {
             size_t j;
-            const float inv_nr = 1.0 / sqrtf (nr);
+            const float inv_nr = 1.0 / sqrtf(nr);
             for (j = 0; j < d; j++)
                 xi[j] *= inv_nr;
         }
     }
 }
 
-
-
-
-
-
-
-
-
-
-
-
 /***************************************************************************
  * KNN functions
  ***************************************************************************/
 
 namespace {
 
-
-
 /* Find the nearest neighbors for nx queries in a set of ny vectors */
-template<class ResultHandler>
-void exhaustive_inner_product_seq (
-        const float * x,
-        const float * y,
-        size_t d, size_t nx, size_t ny,
-        ResultHandler &res)
-{
-    size_t check_period = InterruptCallback::get_period_hint (ny * d);
-
-    check_period *= omp_get_max_threads();
-
+template <class ResultHandler>
+void exhaustive_inner_product_seq(
+        const float* x,
+        const float* y,
+        size_t d,
+        size_t nx,
+        size_t ny,
+        ResultHandler& res) {
     using SingleResultHandler = typename ResultHandler::SingleResultHandler;
+    int nt = std::min(int(nx), omp_get_max_threads());
 
-    for (size_t i0 = 0; i0 < nx; i0 += check_period) {
-        size_t i1 = std::min(i0 + check_period, nx);
-
-#pragma omp parallel
-        {
-            SingleResultHandler resi(res);
+#pragma omp parallel num_threads(nt)
+    {
+        SingleResultHandler resi(res);
 #pragma omp for
-            for (int64_t i = i0; i < i1; i++) {
-                const float * x_i = x + i * d;
-                const float * y_j = y;
+        for (int64_t i = 0; i < nx; i++) {
+            const float* x_i = x + i * d;
+            const float* y_j = y;
 
-                resi.begin(i);
+            resi.begin(i);
 
-                for (size_t j = 0; j < ny; j++) {
-                    float ip = fvec_inner_product (x_i, y_j, d);
-                    resi.add_result(ip, j);
-                    y_j += d;
-                }
-                resi.end();
+            for (size_t j = 0; j < ny; j++) {
+                float ip = fvec_inner_product(x_i, y_j, d);
+                resi.add_result(ip, j);
+                y_j += d;
             }
+            resi.end();
         }
-        InterruptCallback::check ();
     }
-
 }
 
-template<class ResultHandler>
-void exhaustive_L2sqr_seq (
-                const float * x,
-                const float * y,
-                size_t d, size_t nx, size_t ny,
-                ResultHandler & res)
-{
-
-    size_t check_period = InterruptCallback::get_period_hint (ny * d);
-    check_period *= omp_get_max_threads();
+template <class ResultHandler>
+void exhaustive_L2sqr_seq(
+        const float* x,
+        const float* y,
+        size_t d,
+        size_t nx,
+        size_t ny,
+        ResultHandler& res) {
     using SingleResultHandler = typename ResultHandler::SingleResultHandler;
+    int nt = std::min(int(nx), omp_get_max_threads());
 
-    for (size_t i0 = 0; i0 < nx; i0 += check_period) {
-        size_t i1 = std::min(i0 + check_period, nx);
-
-#pragma omp parallel
-        {
-            SingleResultHandler resi(res);
+#pragma omp parallel num_threads(nt)
+    {
+        SingleResultHandler resi(res);
 #pragma omp for
-            for (int64_t i = i0; i < i1; i++) {
-                const float * x_i = x + i * d;
-                const float * y_j = y;
-                resi.begin(i);
-                for (size_t j = 0; j < ny; j++) {
-                    float disij = fvec_L2sqr (x_i, y_j, d);
-                    resi.add_result(disij, j);
-                    y_j += d;
-                }
-                resi.end();
+        for (int64_t i = 0; i < nx; i++) {
+            const float* x_i = x + i * d;
+            const float* y_j = y;
+            resi.begin(i);
+            for (size_t j = 0; j < ny; j++) {
+                float disij = fvec_L2sqr(x_i, y_j, d);
+                resi.add_result(disij, j);
+                y_j += d;
             }
+            resi.end();
         }
-        InterruptCallback::check ();
     }
-
-};
-
-
-
-
+}
 
 /** Find the nearest neighbors for nx queries in a set of ny vectors */
-template<class ResultHandler>
-void exhaustive_inner_product_blas (
-        const float * x,
-        const float * y,
-        size_t d, size_t nx, size_t ny,
-        ResultHandler & res)
-{
+template <class ResultHandler>
+void exhaustive_inner_product_blas(
+        const float* x,
+        const float* y,
+        size_t d,
+        size_t nx,
+        size_t ny,
+        ResultHandler& res) {
     // BLAS does not like empty matrices
-    if (nx == 0 || ny == 0) return;
+    if (nx == 0 || ny == 0)
+        return;
 
     /* block sizes */
     const size_t bs_x = distance_compute_blas_query_bs;
@@ -209,86 +176,105 @@ void exhaustive_inner_product_blas (
 
     for (size_t i0 = 0; i0 < nx; i0 += bs_x) {
         size_t i1 = i0 + bs_x;
-        if(i1 > nx) i1 = nx;
+        if (i1 > nx)
+            i1 = nx;
 
         res.begin_multiple(i0, i1);
 
         for (size_t j0 = 0; j0 < ny; j0 += bs_y) {
             size_t j1 = j0 + bs_y;
-            if (j1 > ny) j1 = ny;
+            if (j1 > ny)
+                j1 = ny;
             /* compute the actual dot products */
             {
                 float one = 1, zero = 0;
                 FINTEGER nyi = j1 - j0, nxi = i1 - i0, di = d;
-                sgemm_ ("Transpose", "Not transpose", &nyi, &nxi, &di, &one,
-                        y + j0 * d, &di,
-                        x + i0 * d, &di, &zero,
-                        ip_block.get(), &nyi);
+                sgemm_("Transpose",
+                       "Not transpose",
+                       &nyi,
+                       &nxi,
+                       &di,
+                       &one,
+                       y + j0 * d,
+                       &di,
+                       x + i0 * d,
+                       &di,
+                       &zero,
+                       ip_block.get(),
+                       &nyi);
             }
 
             res.add_results(j0, j1, ip_block.get());
-
         }
         res.end_multiple();
-        InterruptCallback::check ();
-
+        InterruptCallback::check();
     }
 }
 
-
-
-
 // distance correction is an operator that can be applied to transform
 // the distances
-template<class ResultHandler>
-void exhaustive_L2sqr_blas (
-        const float * x,
-        const float * y,
-        size_t d, size_t nx, size_t ny,
-        ResultHandler & res,
-        const float *y_norms = nullptr)
-{
+template <class ResultHandler>
+void exhaustive_L2sqr_blas(
+        const float* x,
+        const float* y,
+        size_t d,
+        size_t nx,
+        size_t ny,
+        ResultHandler& res,
+        const float* y_norms = nullptr) {
     // BLAS does not like empty matrices
-    if (nx == 0 || ny == 0) return;
+    if (nx == 0 || ny == 0)
+        return;
 
     /* block sizes */
     const size_t bs_x = distance_compute_blas_query_bs;
     const size_t bs_y = distance_compute_blas_database_bs;
     // const size_t bs_x = 16, bs_y = 16;
-    std::unique_ptr<float []> ip_block(new float[bs_x * bs_y]);
-    std::unique_ptr<float []> x_norms(new float[nx]);
-    std::unique_ptr<float []> del2;
+    std::unique_ptr<float[]> ip_block(new float[bs_x * bs_y]);
+    std::unique_ptr<float[]> x_norms(new float[nx]);
+    std::unique_ptr<float[]> del2;
 
-    fvec_norms_L2sqr (x_norms.get(), x, d, nx);
+    fvec_norms_L2sqr(x_norms.get(), x, d, nx);
 
     if (!y_norms) {
-        float *y_norms2 = new float[ny];
+        float* y_norms2 = new float[ny];
         del2.reset(y_norms2);
-        fvec_norms_L2sqr (y_norms2, y, d, ny);
+        fvec_norms_L2sqr(y_norms2, y, d, ny);
         y_norms = y_norms2;
     }
 
     for (size_t i0 = 0; i0 < nx; i0 += bs_x) {
         size_t i1 = i0 + bs_x;
-        if(i1 > nx) i1 = nx;
+        if (i1 > nx)
+            i1 = nx;
 
         res.begin_multiple(i0, i1);
 
         for (size_t j0 = 0; j0 < ny; j0 += bs_y) {
             size_t j1 = j0 + bs_y;
-            if (j1 > ny) j1 = ny;
+            if (j1 > ny)
+                j1 = ny;
             /* compute the actual dot products */
             {
                 float one = 1, zero = 0;
                 FINTEGER nyi = j1 - j0, nxi = i1 - i0, di = d;
-                sgemm_ ("Transpose", "Not transpose", &nyi, &nxi, &di, &one,
-                        y + j0 * d, &di,
-                        x + i0 * d, &di, &zero,
-                        ip_block.get(), &nyi);
+                sgemm_("Transpose",
+                       "Not transpose",
+                       &nyi,
+                       &nxi,
+                       &di,
+                       &one,
+                       y + j0 * d,
+                       &di,
+                       x + i0 * d,
+                       &di,
+                       &zero,
+                       ip_block.get(),
+                       &nyi);
             }
-
+#pragma omp parallel for
             for (int64_t i = i0; i < i1; i++) {
-                float *ip_line = ip_block.get() + (i - i0) * (j1 - j0);
+                float* ip_line = ip_block.get() + (i - i0) * (j1 - j0);
 
                 for (size_t j = j0; j < j1; j++) {
                     float ip = *ip_line;
@@ -296,7 +282,8 @@ void exhaustive_L2sqr_blas (
 
                     // negative values can occur for identical vectors
                     // due to roundoff errors
-                    if (dis < 0) dis = 0;
+                    if (dis < 0)
+                        dis = 0;
 
                     *ip_line = dis;
                     ip_line++;
@@ -305,18 +292,12 @@ void exhaustive_L2sqr_blas (
             res.add_results(j0, j1, ip_block.get());
         }
         res.end_multiple();
-        InterruptCallback::check ();
+        InterruptCallback::check();
     }
 }
 
-
-
 } // anonymous namespace
 
-
-
-
-
 /*******************************************************
  * KNN driver functions
  *******************************************************/
@@ -326,268 +307,275 @@ int distance_compute_blas_query_bs = 4096;
 int distance_compute_blas_database_bs = 1024;
 int distance_compute_min_k_reservoir = 100;
 
-void knn_inner_product (const float * x,
-        const float * y,
-        size_t d, size_t nx, size_t ny,
-        float_minheap_array_t * ha)
-{
+void knn_inner_product(
+        const float* x,
+        const float* y,
+        size_t d,
+        size_t nx,
+        size_t ny,
+        float_minheap_array_t* ha) {
     if (ha->k < distance_compute_min_k_reservoir) {
         HeapResultHandler<CMin<float, int64_t>> res(
-            ha->nh, ha->val, ha->ids, ha->k);
+                ha->nh, ha->val, ha->ids, ha->k);
         if (nx < distance_compute_blas_threshold) {
-            exhaustive_inner_product_seq (x, y, d, nx, ny, res);
+            exhaustive_inner_product_seq(x, y, d, nx, ny, res);
         } else {
-            exhaustive_inner_product_blas (x, y, d, nx, ny, res);
+            exhaustive_inner_product_blas(x, y, d, nx, ny, res);
         }
     } else {
         ReservoirResultHandler<CMin<float, int64_t>> res(
-            ha->nh, ha->val, ha->ids, ha->k);
+                ha->nh, ha->val, ha->ids, ha->k);
         if (nx < distance_compute_blas_threshold) {
-            exhaustive_inner_product_seq (x, y, d, nx, ny, res);
+            exhaustive_inner_product_seq(x, y, d, nx, ny, res);
         } else {
-            exhaustive_inner_product_blas (x, y, d, nx, ny, res);
+            exhaustive_inner_product_blas(x, y, d, nx, ny, res);
         }
     }
 }
 
-
-
-
-void knn_L2sqr (
-        const float * x,
-        const float * y,
-        size_t d, size_t nx, size_t ny,
-        float_maxheap_array_t * ha,
-        const float *y_norm2
-) {
-
+void knn_L2sqr(
+        const float* x,
+        const float* y,
+        size_t d,
+        size_t nx,
+        size_t ny,
+        float_maxheap_array_t* ha,
+        const float* y_norm2) {
     if (ha->k < distance_compute_min_k_reservoir) {
         HeapResultHandler<CMax<float, int64_t>> res(
-            ha->nh, ha->val, ha->ids, ha->k);
+                ha->nh, ha->val, ha->ids, ha->k);
 
         if (nx < distance_compute_blas_threshold) {
-            exhaustive_L2sqr_seq (x, y, d, nx, ny, res);
+            exhaustive_L2sqr_seq(x, y, d, nx, ny, res);
         } else {
-            exhaustive_L2sqr_blas (x, y, d, nx, ny, res, y_norm2);
+            exhaustive_L2sqr_blas(x, y, d, nx, ny, res, y_norm2);
         }
     } else {
         ReservoirResultHandler<CMax<float, int64_t>> res(
-            ha->nh, ha->val, ha->ids, ha->k);
+                ha->nh, ha->val, ha->ids, ha->k);
         if (nx < distance_compute_blas_threshold) {
-            exhaustive_L2sqr_seq (x, y, d, nx, ny, res);
+            exhaustive_L2sqr_seq(x, y, d, nx, ny, res);
         } else {
-            exhaustive_L2sqr_blas (x, y, d, nx, ny, res, y_norm2);
+            exhaustive_L2sqr_blas(x, y, d, nx, ny, res, y_norm2);
         }
     }
 }
 
-
 /***************************************************************************
  * Range search
  ***************************************************************************/
 
-
-
-
-void range_search_L2sqr (
-        const float * x,
-        const float * y,
-        size_t d, size_t nx, size_t ny,
+void range_search_L2sqr(
+        const float* x,
+        const float* y,
+        size_t d,
+        size_t nx,
+        size_t ny,
         float radius,
-        RangeSearchResult *res)
-{
+        RangeSearchResult* res) {
     RangeSearchResultHandler<CMax<float, int64_t>> resh(res, radius);
     if (nx < distance_compute_blas_threshold) {
-        exhaustive_L2sqr_seq (x, y, d, nx, ny, resh);
+        exhaustive_L2sqr_seq(x, y, d, nx, ny, resh);
     } else {
-        exhaustive_L2sqr_blas (x, y, d, nx, ny, resh);
+        exhaustive_L2sqr_blas(x, y, d, nx, ny, resh);
     }
 }
 
-void range_search_inner_product (
-        const float * x,
-        const float * y,
-        size_t d, size_t nx, size_t ny,
+void range_search_inner_product(
+        const float* x,
+        const float* y,
+        size_t d,
+        size_t nx,
+        size_t ny,
         float radius,
-        RangeSearchResult *res)
-{
-
+        RangeSearchResult* res) {
     RangeSearchResultHandler<CMin<float, int64_t>> resh(res, radius);
     if (nx < distance_compute_blas_threshold) {
-        exhaustive_inner_product_seq (x, y, d, nx, ny, resh);
+        exhaustive_inner_product_seq(x, y, d, nx, ny, resh);
     } else {
-        exhaustive_inner_product_blas (x, y, d, nx, ny, resh);
+        exhaustive_inner_product_blas(x, y, d, nx, ny, resh);
     }
 }
 
-
 /***************************************************************************
  * compute a subset of  distances
  ***************************************************************************/
 
 /* compute the inner product between x and a subset y of ny vectors,
    whose indices are given by idy.  */
-void fvec_inner_products_by_idx (float * __restrict ip,
-                                 const float * x,
-                                 const float * y,
-                                 const int64_t * __restrict ids, /* for y vecs */
-                                 size_t d, size_t nx, size_t ny)
-{
+void fvec_inner_products_by_idx(
+        float* __restrict ip,
+        const float* x,
+        const float* y,
+        const int64_t* __restrict ids, /* for y vecs */
+        size_t d,
+        size_t nx,
+        size_t ny) {
 #pragma omp parallel for
     for (int64_t j = 0; j < nx; j++) {
-        const int64_t * __restrict idsj = ids + j * ny;
-        const float * xj = x + j * d;
-        float * __restrict ipj = ip + j * ny;
+        const int64_t* __restrict idsj = ids + j * ny;
+        const float* xj = x + j * d;
+        float* __restrict ipj = ip + j * ny;
         for (size_t i = 0; i < ny; i++) {
             if (idsj[i] < 0)
                 continue;
-            ipj[i] = fvec_inner_product (xj, y + d * idsj[i], d);
+            ipj[i] = fvec_inner_product(xj, y + d * idsj[i], d);
         }
     }
 }
 
-
-
 /* compute the inner product between x and a subset y of ny vectors,
    whose indices are given by idy.  */
-void fvec_L2sqr_by_idx (float * __restrict dis,
-                        const float * x,
-                        const float * y,
-                        const int64_t * __restrict ids, /* ids of y vecs */
-                        size_t d, size_t nx, size_t ny)
-{
+void fvec_L2sqr_by_idx(
+        float* __restrict dis,
+        const float* x,
+        const float* y,
+        const int64_t* __restrict ids, /* ids of y vecs */
+        size_t d,
+        size_t nx,
+        size_t ny) {
 #pragma omp parallel for
     for (int64_t j = 0; j < nx; j++) {
-        const int64_t * __restrict idsj = ids + j * ny;
-        const float * xj = x + j * d;
-        float * __restrict disj = dis + j * ny;
+        const int64_t* __restrict idsj = ids + j * ny;
+        const float* xj = x + j * d;
+        float* __restrict disj = dis + j * ny;
         for (size_t i = 0; i < ny; i++) {
             if (idsj[i] < 0)
                 continue;
-            disj[i] = fvec_L2sqr (xj, y + d * idsj[i], d);
+            disj[i] = fvec_L2sqr(xj, y + d * idsj[i], d);
         }
     }
 }
 
-void pairwise_indexed_L2sqr (
-        size_t d, size_t n,
-        const float * x, const int64_t *ix,
-        const float * y, const int64_t *iy,
-        float *dis)
-{
+void pairwise_indexed_L2sqr(
+        size_t d,
+        size_t n,
+        const float* x,
+        const int64_t* ix,
+        const float* y,
+        const int64_t* iy,
+        float* dis) {
 #pragma omp parallel for
     for (int64_t j = 0; j < n; j++) {
         if (ix[j] >= 0 && iy[j] >= 0) {
-            dis[j] = fvec_L2sqr (x + d * ix[j], y + d * iy[j], d);
+            dis[j] = fvec_L2sqr(x + d * ix[j], y + d * iy[j], d);
         }
     }
 }
 
-void pairwise_indexed_inner_product (
-        size_t d, size_t n,
-        const float * x, const int64_t *ix,
-        const float * y, const int64_t *iy,
-        float *dis)
-{
+void pairwise_indexed_inner_product(
+        size_t d,
+        size_t n,
+        const float* x,
+        const int64_t* ix,
+        const float* y,
+        const int64_t* iy,
+        float* dis) {
 #pragma omp parallel for
     for (int64_t j = 0; j < n; j++) {
         if (ix[j] >= 0 && iy[j] >= 0) {
-            dis[j] = fvec_inner_product (x + d * ix[j], y + d * iy[j], d);
+            dis[j] = fvec_inner_product(x + d * ix[j], y + d * iy[j], d);
         }
     }
 }
 
-
 /* Find the nearest neighbors for nx queries in a set of ny vectors
    indexed by ids. May be useful for re-ranking a pre-selected vector list */
-void knn_inner_products_by_idx (const float * x,
-                                const float * y,
-                                const int64_t * ids,
-                                size_t d, size_t nx, size_t ny,
-                                float_minheap_array_t * res)
-{
+void knn_inner_products_by_idx(
+        const float* x,
+        const float* y,
+        const int64_t* ids,
+        size_t d,
+        size_t nx,
+        size_t ny,
+        float_minheap_array_t* res) {
     size_t k = res->k;
 
 #pragma omp parallel for
     for (int64_t i = 0; i < nx; i++) {
-        const float * x_ = x + i * d;
-        const int64_t * idsi = ids + i * ny;
+        const float* x_ = x + i * d;
+        const int64_t* idsi = ids + i * ny;
         size_t j;
-        float * __restrict simi = res->get_val(i);
-        int64_t * __restrict idxi = res->get_ids (i);
-        minheap_heapify (k, simi, idxi);
+        float* __restrict simi = res->get_val(i);
+        int64_t* __restrict idxi = res->get_ids(i);
+        minheap_heapify(k, simi, idxi);
 
         for (j = 0; j < ny; j++) {
-            if (idsi[j] < 0) break;
-            float ip = fvec_inner_product (x_, y + d * idsi[j], d);
+            if (idsi[j] < 0)
+                break;
+            float ip = fvec_inner_product(x_, y + d * idsi[j], d);
 
             if (ip > simi[0]) {
-                minheap_replace_top (k, simi, idxi, ip, idsi[j]);
+                minheap_replace_top(k, simi, idxi, ip, idsi[j]);
             }
         }
-        minheap_reorder (k, simi, idxi);
+        minheap_reorder(k, simi, idxi);
     }
-
 }
 
-void knn_L2sqr_by_idx (const float * x,
-                       const float * y,
-                       const int64_t * __restrict ids,
-                       size_t d, size_t nx, size_t ny,
-                       float_maxheap_array_t * res)
-{
+void knn_L2sqr_by_idx(
+        const float* x,
+        const float* y,
+        const int64_t* __restrict ids,
+        size_t d,
+        size_t nx,
+        size_t ny,
+        float_maxheap_array_t* res) {
     size_t k = res->k;
 
 #pragma omp parallel for
     for (int64_t i = 0; i < nx; i++) {
-        const float * x_ = x + i * d;
-        const int64_t * __restrict idsi = ids + i * ny;
-        float * __restrict simi = res->get_val(i);
-        int64_t * __restrict idxi = res->get_ids (i);
-        maxheap_heapify (res->k, simi, idxi);
+        const float* x_ = x + i * d;
+        const int64_t* __restrict idsi = ids + i * ny;
+        float* __restrict simi = res->get_val(i);
+        int64_t* __restrict idxi = res->get_ids(i);
+        maxheap_heapify(res->k, simi, idxi);
         for (size_t j = 0; j < ny; j++) {
-            float disij = fvec_L2sqr (x_, y + d * idsi[j], d);
+            float disij = fvec_L2sqr(x_, y + d * idsi[j], d);
 
             if (disij < simi[0]) {
-                maxheap_replace_top (k, simi, idxi, disij, idsi[j]);
+                maxheap_replace_top(k, simi, idxi, disij, idsi[j]);
             }
         }
-        maxheap_reorder (res->k, simi, idxi);
+        maxheap_reorder(res->k, simi, idxi);
     }
-
 }
 
-
-
-
-
-void pairwise_L2sqr (int64_t d,
-                     int64_t nq, const float *xq,
-                     int64_t nb, const float *xb,
-                     float *dis,
-                     int64_t ldq, int64_t ldb, int64_t ldd)
-{
-    if (nq == 0 || nb == 0) return;
-    if (ldq == -1) ldq = d;
-    if (ldb == -1) ldb = d;
-    if (ldd == -1) ldd = nb;
+void pairwise_L2sqr(
+        int64_t d,
+        int64_t nq,
+        const float* xq,
+        int64_t nb,
+        const float* xb,
+        float* dis,
+        int64_t ldq,
+        int64_t ldb,
+        int64_t ldd) {
+    if (nq == 0 || nb == 0)
+        return;
+    if (ldq == -1)
+        ldq = d;
+    if (ldb == -1)
+        ldb = d;
+    if (ldd == -1)
+        ldd = nb;
 
     // store in beginning of distance matrix to avoid malloc
-    float *b_norms = dis;
+    float* b_norms = dis;
 
 #pragma omp parallel for
     for (int64_t i = 0; i < nb; i++)
-        b_norms [i] = fvec_norm_L2sqr (xb + i * ldb, d);
+        b_norms[i] = fvec_norm_L2sqr(xb + i * ldb, d);
 
 #pragma omp parallel for
     for (int64_t i = 1; i < nq; i++) {
-        float q_norm = fvec_norm_L2sqr (xq + i * ldq, d);
+        float q_norm = fvec_norm_L2sqr(xq + i * ldq, d);
         for (int64_t j = 0; j < nb; j++)
-            dis[i * ldd + j] = q_norm + b_norms [j];
+            dis[i * ldd + j] = q_norm + b_norms[j];
     }
 
     {
-        float q_norm = fvec_norm_L2sqr (xq, d);
+        float q_norm = fvec_norm_L2sqr(xq, d);
         for (int64_t j = 0; j < nb; j++)
             dis[j] += q_norm;
     }
@@ -596,22 +584,28 @@ void pairwise_L2sqr (int64_t d,
         FINTEGER nbi = nb, nqi = nq, di = d, ldqi = ldq, ldbi = ldb, lddi = ldd;
         float one = 1.0, minus_2 = -2.0;
 
-        sgemm_ ("Transposed", "Not transposed",
-                &nbi, &nqi, &di,
-                &minus_2,
-                xb, &ldbi,
-                xq, &ldqi,
-                &one, dis, &lddi);
+        sgemm_("Transposed",
+               "Not transposed",
+               &nbi,
+               &nqi,
+               &di,
+               &minus_2,
+               xb,
+               &ldbi,
+               xq,
+               &ldqi,
+               &one,
+               dis,
+               &lddi);
     }
-
 }
 
-void inner_product_to_L2sqr(float* __restrict dis,
-    const float* nr1,
-    const float* nr2,
-    size_t n1, size_t n2)
-{
-
+void inner_product_to_L2sqr(
+        float* __restrict dis,
+        const float* nr1,
+        const float* nr2,
+        size_t n1,
+        size_t n2) {
 #pragma omp parallel for
     for (int64_t j = 0; j < n1; j++) {
         float* disj = dis + j * n2;
@@ -620,5 +614,4 @@ void inner_product_to_L2sqr(float* __restrict dis,
     }
 }
 
-
 } // namespace faiss