faiss 0.2.0 → 0.2.1

data/vendor/faiss/faiss/utils/Heap.cpp

@@ -11,86 +11,82 @@
 
 #include <faiss/utils/Heap.h>
 
-
 namespace faiss {
 
-
 template <typename C>
-void HeapArray<C>::heapify ()
-{
+void HeapArray<C>::heapify() {
 #pragma omp parallel for
     for (int64_t j = 0; j < nh; j++)
-        heap_heapify<C> (k, val + j * k, ids + j * k);
+        heap_heapify<C>(k, val + j * k, ids + j * k);
 }
 
 template <typename C>
-void HeapArray<C>::reorder ()
-{
+void HeapArray<C>::reorder() {
 #pragma omp parallel for
     for (int64_t j = 0; j < nh; j++)
-        heap_reorder<C> (k, val + j * k, ids + j * k);
+        heap_reorder<C>(k, val + j * k, ids + j * k);
 }
 
 template <typename C>
-void HeapArray<C>::addn (size_t nj, const T *vin, TI j0,
-                         size_t i0, int64_t ni)
-{
-    if (ni == -1) ni = nh;
-    assert (i0 >= 0 && i0 + ni <= nh);
+void HeapArray<C>::addn(size_t nj, const T* vin, TI j0, size_t i0, int64_t ni) {
+    if (ni == -1)
+        ni = nh;
+    assert(i0 >= 0 && i0 + ni <= nh);
 #pragma omp parallel for
     for (int64_t i = i0; i < i0 + ni; i++) {
-        T * __restrict simi = get_val(i);
-        TI * __restrict idxi = get_ids (i);
-        const T *ip_line = vin + (i - i0) * nj;
+        T* __restrict simi = get_val(i);
+        TI* __restrict idxi = get_ids(i);
+        const T* ip_line = vin + (i - i0) * nj;
 
         for (size_t j = 0; j < nj; j++) {
-            T ip = ip_line [j];
+            T ip = ip_line[j];
             if (C::cmp(simi[0], ip)) {
-                heap_replace_top<C> (k, simi, idxi, ip, j + j0);
+                heap_replace_top<C>(k, simi, idxi, ip, j + j0);
             }
         }
     }
 }
 
 template <typename C>
-void HeapArray<C>::addn_with_ids (
-     size_t nj, const T *vin, const TI *id_in,
-     int64_t id_stride, size_t i0, int64_t ni)
-{
+void HeapArray<C>::addn_with_ids(
+        size_t nj,
+        const T* vin,
+        const TI* id_in,
+        int64_t id_stride,
+        size_t i0,
+        int64_t ni) {
     if (id_in == nullptr) {
-        addn (nj, vin, 0, i0, ni);
+        addn(nj, vin, 0, i0, ni);
         return;
     }
-    if (ni == -1) ni = nh;
-    assert (i0 >= 0 && i0 + ni <= nh);
+    if (ni == -1)
+        ni = nh;
+    assert(i0 >= 0 && i0 + ni <= nh);
 #pragma omp parallel for
     for (int64_t i = i0; i < i0 + ni; i++) {
-        T * __restrict simi = get_val(i);
-        TI * __restrict idxi = get_ids (i);
-        const T *ip_line = vin + (i - i0) * nj;
-        const TI *id_line = id_in + (i - i0) * id_stride;
+        T* __restrict simi = get_val(i);
+        TI* __restrict idxi = get_ids(i);
+        const T* ip_line = vin + (i - i0) * nj;
+        const TI* id_line = id_in + (i - i0) * id_stride;
 
         for (size_t j = 0; j < nj; j++) {
-            T ip = ip_line [j];
+            T ip = ip_line[j];
             if (C::cmp(simi[0], ip)) {
-                heap_replace_top<C> (k, simi, idxi, ip, id_line [j]);
+                heap_replace_top<C>(k, simi, idxi, ip, id_line[j]);
             }
         }
     }
 }
 
 template <typename C>
-void HeapArray<C>::per_line_extrema (
-                   T * out_val,
-                   TI * out_ids) const
-{
+void HeapArray<C>::per_line_extrema(T* out_val, TI* out_ids) const {
 #pragma omp parallel for
     for (int64_t j = 0; j < nh; j++) {
         int64_t imin = -1;
-        typename C::T xval = C::Crev::neutral ();
-        const typename C::T * x_ = val + j * k;
+        typename C::T xval = C::Crev::neutral();
+        const typename C::T* x_ = val + j * k;
         for (size_t i = 0; i < k; i++)
-            if (C::cmp (x_[i], xval)) {
+            if (C::cmp(x_[i], xval)) {
                 xval = x_[i];
                 imin = i;
             }
@@ -99,22 +95,18 @@ void HeapArray<C>::per_line_extrema (
 
         if (out_ids) {
             if (ids && imin != -1)
-                out_ids[j] = ids [j * k + imin];
+                out_ids[j] = ids[j * k + imin];
             else
                 out_ids[j] = imin;
         }
     }
 }
 
-
-
-
 // explicit instanciations
 
-template struct HeapArray<CMin <float, int64_t> >;
-template struct HeapArray<CMax <float, int64_t> >;
-template struct HeapArray<CMin <int, int64_t> >;
-template struct HeapArray<CMax <int, int64_t> >;
-
+template struct HeapArray<CMin<float, int64_t>>;
+template struct HeapArray<CMax<float, int64_t>>;
+template struct HeapArray<CMin<int, int64_t>>;
+template struct HeapArray<CMax<int, int64_t>>;
 
-}  // END namespace fasis
+} // namespace faiss

data/vendor/faiss/faiss/utils/Heap.h

@@ -5,7 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-
 /*
  * C++ support for heaps. The set of functions is tailored for efficient
  * similarity search.
@@ -19,17 +18,16 @@
  * Cmin). The C types are defined in ordered_key_value.h
  */
 
-
 #ifndef FAISS_Heap_h
 #define FAISS_Heap_h
 
 #include <climits>
-#include <cstring>
 #include <cmath>
+#include <cstring>
 
+#include <stdint.h>
 #include <cassert>
 #include <cstdio>
-#include <stdint.h>
 
 #include <limits>
 
@@ -37,9 +35,6 @@
 
 namespace faiss {
 
-
-
-
 /*******************************************************************
  * Basic heap ops: push and pop
  *******************************************************************/
@@ -47,9 +42,8 @@ namespace faiss {
 /** Pops the top element from the heap defined by bh_val[0..k-1] and
  * bh_ids[0..k-1].  on output the element at k-1 is undefined.
  */
-template <class C> inline
-void heap_pop (size_t k, typename C::T * bh_val, typename C::TI * bh_ids)
-{
+template <class C>
+inline void heap_pop(size_t k, typename C::T* bh_val, typename C::TI* bh_ids) {
     bh_val--; /* Use 1-based indexing for easier node->child translation */
     bh_ids--;
     typename C::T val = bh_val[k];
@@ -65,8 +59,7 @@ void heap_pop (size_t k, typename C::T * bh_val, typename C::TI * bh_ids)
             bh_val[i] = bh_val[i1];
             bh_ids[i] = bh_ids[i1];
             i = i1;
-        }
-        else {
+        } else {
             if (C::cmp(val, bh_val[i2]))
                 break;
             bh_val[i] = bh_val[i2];
@@ -78,22 +71,22 @@ void heap_pop (size_t k, typename C::T * bh_val, typename C::TI * bh_ids)
     bh_ids[i] = bh_ids[k];
 }
 
-
-
 /** Pushes the element (val, ids) into the heap bh_val[0..k-2] and
  * bh_ids[0..k-2].  on output the element at k-1 is defined.
  */
-template <class C> inline
-void heap_push (size_t k,
-                typename C::T * bh_val, typename C::TI * bh_ids,
-                typename C::T val, typename C::TI ids)
-{
+template <class C>
+inline void heap_push(
+        size_t k,
+        typename C::T* bh_val,
+        typename C::TI* bh_ids,
+        typename C::T val,
+        typename C::TI ids) {
     bh_val--; /* Use 1-based indexing for easier node->child translation */
     bh_ids--;
     size_t i = k, i_father;
     while (i > 1) {
         i_father = i >> 1;
-        if (!C::cmp (val, bh_val[i_father]))  /* the heap structure is ok */
+        if (!C::cmp(val, bh_val[i_father])) /* the heap structure is ok */
             break;
         bh_val[i] = bh_val[i_father];
         bh_ids[i] = bh_ids[i_father];
@@ -103,16 +96,16 @@ void heap_push (size_t k,
     bh_ids[i] = ids;
 }
 
-
-
 /** Replace the top element from the heap defined by bh_val[0..k-1] and
  * bh_ids[0..k-1].
  */
-template <class C> inline
-void heap_replace_top (size_t k,
-                       typename C::T * bh_val, typename C::TI * bh_ids,
-                       typename C::T val, typename C::TI ids)
-{
+template <class C>
+inline void heap_replace_top(
+        size_t k,
+        typename C::T* bh_val,
+        typename C::TI* bh_ids,
+        typename C::T val,
+        typename C::TI ids) {
     bh_val--; /* Use 1-based indexing for easier node->child translation */
     bh_ids--;
     size_t i = 1, i1, i2;
@@ -127,8 +120,7 @@ void heap_replace_top (size_t k,
             bh_val[i] = bh_val[i1];
             bh_ids[i] = bh_ids[i1];
             i = i1;
-        }
-        else {
+        } else {
             if (C::cmp(val, bh_val[i2]))
                 break;
             bh_val[i] = bh_val[i2];
@@ -140,52 +132,58 @@ void heap_replace_top (size_t k,
     bh_ids[i] = ids;
 }
 
-
-
 /* Partial instanciation for heaps with TI = int64_t */
 
-template <typename T> inline
-void minheap_pop (size_t k, T * bh_val, int64_t * bh_ids)
-{
-    heap_pop<CMin<T, int64_t> > (k, bh_val, bh_ids);
+template <typename T>
+inline void minheap_pop(size_t k, T* bh_val, int64_t* bh_ids) {
+    heap_pop<CMin<T, int64_t>>(k, bh_val, bh_ids);
 }
 
-
-template <typename T> inline
-void minheap_push (size_t k, T * bh_val, int64_t * bh_ids, T val, int64_t ids)
-{
-    heap_push<CMin<T, int64_t> > (k, bh_val, bh_ids, val, ids);
+template <typename T>
+inline void minheap_push(
+        size_t k,
+        T* bh_val,
+        int64_t* bh_ids,
+        T val,
+        int64_t ids) {
+    heap_push<CMin<T, int64_t>>(k, bh_val, bh_ids, val, ids);
 }
 
-
-template <typename T> inline
-void minheap_replace_top (size_t k, T * bh_val, int64_t * bh_ids, T val, int64_t ids)
-{
-    heap_replace_top<CMin<T, int64_t> > (k, bh_val, bh_ids, val, ids);
+template <typename T>
+inline void minheap_replace_top(
+        size_t k,
+        T* bh_val,
+        int64_t* bh_ids,
+        T val,
+        int64_t ids) {
+    heap_replace_top<CMin<T, int64_t>>(k, bh_val, bh_ids, val, ids);
 }
 
-
-template <typename T> inline
-void maxheap_pop (size_t k, T * bh_val, int64_t * bh_ids)
-{
-    heap_pop<CMax<T, int64_t> > (k, bh_val, bh_ids);
+template <typename T>
+inline void maxheap_pop(size_t k, T* bh_val, int64_t* bh_ids) {
+    heap_pop<CMax<T, int64_t>>(k, bh_val, bh_ids);
 }
 
-
-template <typename T> inline
-void maxheap_push (size_t k, T * bh_val, int64_t * bh_ids, T val, int64_t ids)
-{
-    heap_push<CMax<T, int64_t> > (k, bh_val, bh_ids, val, ids);
+template <typename T>
+inline void maxheap_push(
+        size_t k,
+        T* bh_val,
+        int64_t* bh_ids,
+        T val,
+        int64_t ids) {
+    heap_push<CMax<T, int64_t>>(k, bh_val, bh_ids, val, ids);
 }
 
-
-template <typename T> inline
-void maxheap_replace_top (size_t k, T * bh_val, int64_t * bh_ids, T val, int64_t ids)
-{
-    heap_replace_top<CMax<T, int64_t> > (k, bh_val, bh_ids, val, ids);
+template <typename T>
+inline void maxheap_replace_top(
+        size_t k,
+        T* bh_val,
+        int64_t* bh_ids,
+        T val,
+        int64_t ids) {
+    heap_replace_top<CMax<T, int64_t>>(k, bh_val, bh_ids, val, ids);
 }
 
-
 /*******************************************************************
  * Heap initialization
  *******************************************************************/
@@ -193,118 +191,116 @@ void maxheap_replace_top (size_t k, T * bh_val, int64_t * bh_ids, T val, int64_t
 /* Initialization phase for the heap (with unconditionnal pushes).
  * Store k0 elements in a heap containing up to k values. Note that
  * (bh_val, bh_ids) can be the same as (x, ids) */
-template <class C> inline
-void heap_heapify (
+template <class C>
+inline void heap_heapify(
         size_t k,
-        typename C::T *  bh_val,
-        typename C::TI *  bh_ids,
-        const typename C::T * x = nullptr,
-        const typename C::TI * ids = nullptr,
-        size_t k0 = 0)
-{
-   if (k0 > 0) assert (x);
-
-   if (ids) {
-       for (size_t i = 0; i < k0; i++)
-           heap_push<C> (i+1, bh_val, bh_ids, x[i], ids[i]);
-   } else {
-       for (size_t i = 0; i < k0; i++)
-           heap_push<C> (i+1, bh_val, bh_ids, x[i], i);
-   }
-
-   for (size_t i = k0; i < k; i++) {
-       bh_val[i] = C::neutral();
-       bh_ids[i] = -1;
-   }
+        typename C::T* bh_val,
+        typename C::TI* bh_ids,
+        const typename C::T* x = nullptr,
+        const typename C::TI* ids = nullptr,
+        size_t k0 = 0) {
+    if (k0 > 0)
+        assert(x);
+
+    if (ids) {
+        for (size_t i = 0; i < k0; i++)
+            heap_push<C>(i + 1, bh_val, bh_ids, x[i], ids[i]);
+    } else {
+        for (size_t i = 0; i < k0; i++)
+            heap_push<C>(i + 1, bh_val, bh_ids, x[i], i);
+    }
 
+    for (size_t i = k0; i < k; i++) {
+        bh_val[i] = C::neutral();
+        bh_ids[i] = -1;
+    }
 }
 
-template <typename T> inline
-void minheap_heapify (
-        size_t k, T *  bh_val,
-        int64_t * bh_ids,
-        const T * x = nullptr,
-        const int64_t * ids = nullptr,
-        size_t k0 = 0)
-{
-    heap_heapify< CMin<T, int64_t> > (k, bh_val, bh_ids, x, ids, k0);
+template <typename T>
+inline void minheap_heapify(
+        size_t k,
+        T* bh_val,
+        int64_t* bh_ids,
+        const T* x = nullptr,
+        const int64_t* ids = nullptr,
+        size_t k0 = 0) {
+    heap_heapify<CMin<T, int64_t>>(k, bh_val, bh_ids, x, ids, k0);
 }
 
-
-template <typename T> inline
-void maxheap_heapify (
+template <typename T>
+inline void maxheap_heapify(
         size_t k,
-        T * bh_val,
-        int64_t * bh_ids,
-         const T * x = nullptr,
-         const int64_t * ids = nullptr,
-         size_t k0 = 0)
-{
-    heap_heapify< CMax<T, int64_t> > (k, bh_val, bh_ids, x, ids, k0);
+        T* bh_val,
+        int64_t* bh_ids,
+        const T* x = nullptr,
+        const int64_t* ids = nullptr,
+        size_t k0 = 0) {
+    heap_heapify<CMax<T, int64_t>>(k, bh_val, bh_ids, x, ids, k0);
 }
 
-
-
 /*******************************************************************
  * Add n elements to the heap
  *******************************************************************/
 
-
 /* Add some elements to the heap  */
-template <class C> inline
-void heap_addn (size_t k,
-                typename C::T * bh_val, typename C::TI * bh_ids,
-                const typename C::T * x,
-                const typename C::TI * ids,
-                size_t n)
-{
+template <class C>
+inline void heap_addn(
+        size_t k,
+        typename C::T* bh_val,
+        typename C::TI* bh_ids,
+        const typename C::T* x,
+        const typename C::TI* ids,
+        size_t n) {
     size_t i;
     if (ids)
         for (i = 0; i < n; i++) {
-            if (C::cmp (bh_val[0], x[i])) {
-                heap_replace_top<C> (k, bh_val, bh_ids, x[i], ids[i]);
+            if (C::cmp(bh_val[0], x[i])) {
+                heap_replace_top<C>(k, bh_val, bh_ids, x[i], ids[i]);
             }
         }
     else
         for (i = 0; i < n; i++) {
-            if (C::cmp (bh_val[0], x[i])) {
-                heap_replace_top<C> (k, bh_val, bh_ids, x[i], i);
+            if (C::cmp(bh_val[0], x[i])) {
+                heap_replace_top<C>(k, bh_val, bh_ids, x[i], i);
             }
         }
 }
 
-
 /* Partial instanciation for heaps with TI = int64_t */
 
-template <typename T> inline
-void minheap_addn (size_t k, T * bh_val, int64_t * bh_ids,
-                   const T * x, const int64_t * ids, size_t n)
-{
-    heap_addn<CMin<T, int64_t> > (k, bh_val, bh_ids, x, ids, n);
+template <typename T>
+inline void minheap_addn(
+        size_t k,
+        T* bh_val,
+        int64_t* bh_ids,
+        const T* x,
+        const int64_t* ids,
+        size_t n) {
+    heap_addn<CMin<T, int64_t>>(k, bh_val, bh_ids, x, ids, n);
 }
 
-template <typename T> inline
-void maxheap_addn (size_t k, T * bh_val, int64_t * bh_ids,
-                   const T * x, const int64_t * ids, size_t n)
-{
-    heap_addn<CMax<T, int64_t> > (k, bh_val, bh_ids, x, ids, n);
+template <typename T>
+inline void maxheap_addn(
+        size_t k,
+        T* bh_val,
+        int64_t* bh_ids,
+        const T* x,
+        const int64_t* ids,
+        size_t n) {
+    heap_addn<CMax<T, int64_t>>(k, bh_val, bh_ids, x, ids, n);
 }
 
-
-
-
-
-
 /*******************************************************************
  * Heap finalization (reorder elements)
  *******************************************************************/
 
-
 /* This function maps a binary heap into an sorted structure.
    It returns the number  */
-template <typename C> inline
-size_t heap_reorder (size_t k, typename C::T * bh_val, typename C::TI * bh_ids)
-{
+template <typename C>
+inline size_t heap_reorder(
+        size_t k,
+        typename C::T* bh_val,
+        typename C::TI* bh_ids) {
     size_t i, ii;
 
     for (i = 0, ii = 0; i < k; i++) {
@@ -313,16 +309,17 @@ size_t heap_reorder (size_t k, typename C::T * bh_val, typename C::TI * bh_ids)
         typename C::TI id = bh_ids[0];
 
         /* boundary case: we will over-ride this value if not a true element */
-        heap_pop<C> (k-i, bh_val, bh_ids);
-        bh_val[k-ii-1] = val;
-        bh_ids[k-ii-1] = id;
-        if (id != -1) ii++;
+        heap_pop<C>(k - i, bh_val, bh_ids);
+        bh_val[k - ii - 1] = val;
+        bh_ids[k - ii - 1] = id;
+        if (id != -1)
+            ii++;
     }
     /* Count the number of elements which are effectively returned */
     size_t nel = ii;
 
-    memmove (bh_val, bh_val+k-ii, ii * sizeof(*bh_val));
-    memmove (bh_ids, bh_ids+k-ii, ii * sizeof(*bh_ids));
+    memmove(bh_val, bh_val + k - ii, ii * sizeof(*bh_val));
+    memmove(bh_ids, bh_ids + k - ii, ii * sizeof(*bh_ids));
 
     for (; ii < k; ii++) {
         bh_val[ii] = C::neutral();
@@ -331,22 +328,16 @@ size_t heap_reorder (size_t k, typename C::T * bh_val, typename C::TI * bh_ids)
     return nel;
 }
 
-template <typename T> inline
-size_t minheap_reorder (size_t k, T * bh_val, int64_t * bh_ids)
-{
-    return heap_reorder< CMin<T, int64_t> > (k, bh_val, bh_ids);
+template <typename T>
+inline size_t minheap_reorder(size_t k, T* bh_val, int64_t* bh_ids) {
+    return heap_reorder<CMin<T, int64_t>>(k, bh_val, bh_ids);
 }
 
-template <typename T> inline
-size_t maxheap_reorder (size_t k, T * bh_val, int64_t * bh_ids)
-{
-    return heap_reorder< CMax<T, int64_t> > (k, bh_val, bh_ids);
+template <typename T>
+inline size_t maxheap_reorder(size_t k, T* bh_val, int64_t* bh_ids) {
+    return heap_reorder<CMax<T, int64_t>>(k, bh_val, bh_ids);
 }
 
-
-
-
-
 /*******************************************************************
  * Operations on heap arrays
  *******************************************************************/
@@ -360,19 +351,23 @@ struct HeapArray {
     typedef typename C::TI TI;
     typedef typename C::T T;
 
-    size_t nh;    ///< number of heaps
-    size_t k;     ///< allocated size per heap
-    TI * ids;     ///< identifiers (size nh * k)
-    T * val;      ///< values (distances or similarities), size nh * k
+    size_t nh; ///< number of heaps
+    size_t k;  ///< allocated size per heap
+    TI* ids;   ///< identifiers (size nh * k)
+    T* val;    ///< values (distances or similarities), size nh * k
 
     /// Return the list of values for a heap
-    T * get_val (size_t key) { return val + key * k; }
+    T* get_val(size_t key) {
+        return val + key * k;
+    }
 
     /// Correspponding identifiers
-    TI * get_ids (size_t key) { return ids + key * k; }
+    TI* get_ids(size_t key) {
+        return ids + key * k;
+    }
 
     /// prepare all the heaps before adding
-    void heapify ();
+    void heapify();
 
     /** add nj elements to heaps i0:i0+ni, with sequential ids
      *
@@ -382,58 +377,46 @@ struct HeapArray {
      * @param i0    first heap to update
      * @param ni    nb of elements to update (-1 = use nh)
      */
-    void addn (size_t nj, const T *vin, TI j0 = 0,
-               size_t i0 = 0, int64_t ni = -1);
+    void addn(
+            size_t nj,
+            const T* vin,
+            TI j0 = 0,
+            size_t i0 = 0,
+            int64_t ni = -1);
 
     /** same as addn
      *
      * @param id_in     ids of the elements to add, size ni * nj
      * @param id_stride stride for id_in
      */
-    void addn_with_ids (
-        size_t nj, const T *vin, const TI *id_in = nullptr,
-        int64_t id_stride = 0, size_t i0 = 0, int64_t ni = -1);
+    void addn_with_ids(
+            size_t nj,
+            const T* vin,
+            const TI* id_in = nullptr,
+            int64_t id_stride = 0,
+            size_t i0 = 0,
+            int64_t ni = -1);
 
     /// reorder all the heaps
-    void reorder ();
+    void reorder();
 
     /** this is not really a heap function. It just finds the per-line
      *   extrema of each line of array D
      * @param vals_out    extreme value of each line (size nh, or NULL)
      * @param idx_out     index of extreme value (size nh or NULL)
      */
-    void per_line_extrema (T *vals_out, TI *idx_out) const;
-
+    void per_line_extrema(T* vals_out, TI* idx_out) const;
 };
 
-
 /* Define useful heaps */
-typedef HeapArray<CMin<float, int64_t> > float_minheap_array_t;
-typedef HeapArray<CMin<int, int64_t> > int_minheap_array_t;
+typedef HeapArray<CMin<float, int64_t>> float_minheap_array_t;
+typedef HeapArray<CMin<int, int64_t>> int_minheap_array_t;
 
-typedef HeapArray<CMax<float, int64_t> > float_maxheap_array_t;
-typedef HeapArray<CMax<int, int64_t> > int_maxheap_array_t;
+typedef HeapArray<CMax<float, int64_t>> float_maxheap_array_t;
+typedef HeapArray<CMax<int, int64_t>> int_maxheap_array_t;
 
 // The heap templates are instanciated explicitly in Heap.cpp
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 /*********************************************************************
  * Indirect heaps: instead of having
  *
@@ -445,14 +428,11 @@ typedef HeapArray<CMax<int, int64_t> > int_maxheap_array_t;
  *
  *********************************************************************/
 
-
 template <class C>
-inline
-void indirect_heap_pop (
-    size_t k,
-    const typename C::T * bh_val,
-    typename C::TI * bh_ids)
-{
+inline void indirect_heap_pop(
+        size_t k,
+        const typename C::T* bh_val,
+        typename C::TI* bh_ids) {
     bh_ids--; /* Use 1-based indexing for easier node->child translation */
     typename C::T val = bh_val[bh_ids[k]];
     size_t i = 1;
@@ -477,20 +457,18 @@ void indirect_heap_pop (
     bh_ids[i] = bh_ids[k];
 }
 
-
-
 template <class C>
-inline
-void indirect_heap_push (size_t k,
-                         const typename C::T * bh_val, typename C::TI * bh_ids,
-                         typename C::TI id)
-{
+inline void indirect_heap_push(
+        size_t k,
+        const typename C::T* bh_val,
+        typename C::TI* bh_ids,
+        typename C::TI id) {
     bh_ids--; /* Use 1-based indexing for easier node->child translation */
     typename C::T val = bh_val[id];
     size_t i = k;
     while (i > 1) {
         size_t i_father = i >> 1;
-        if (!C::cmp (val, bh_val[bh_ids[i_father]]))
+        if (!C::cmp(val, bh_val[bh_ids[i_father]]))
             break;
         bh_ids[i] = bh_ids[i_father];
         i = i_father;
@@ -498,7 +476,6 @@ void indirect_heap_push (size_t k,
     bh_ids[i] = id;
 }
 
-
 } // namespace faiss
 
-#endif  /* FAISS_Heap_h */
+#endif /* FAISS_Heap_h */