faiss 0.2.0 → 0.2.4

data/vendor/faiss/faiss/utils/hamming.h

@@ -24,13 +24,11 @@
 #ifndef FAISS_hamming_h
 #define FAISS_hamming_h
 
-
 #include <stdint.h>
 
 #include <faiss/impl/platform_macros.h>
 #include <faiss/utils/Heap.h>
 
-
 /* The Hamming distance type */
 typedef int32_t hamdis_t;
 
@@ -42,8 +40,7 @@ namespace faiss {
 
 struct RangeSearchResult;
 
-void bitvec_print (const uint8_t * b, size_t d);
-
+void bitvec_print(const uint8_t* b, size_t d);
 
 /* Functions for casting vectors of regular types to compact bits.
    They assume proper allocation done beforehand, meaning that b
@@ -52,53 +49,45 @@ void bitvec_print (const uint8_t * b, size_t d);
 /* Makes an array of bits from the signs of a float array. The length
    of the output array b is rounded up to byte size (allocate
    accordingly) */
-void fvecs2bitvecs (
-        const float * x,
-        uint8_t * b,
-        size_t d,
-        size_t n);
-
-void bitvecs2fvecs (
-        const uint8_t * b,
-        float * x,
-        size_t d,
-        size_t n);
+void fvecs2bitvecs(const float* x, uint8_t* b, size_t d, size_t n);
 
+void bitvecs2fvecs(const uint8_t* b, float* x, size_t d, size_t n);
 
-void fvec2bitvec (const float * x, uint8_t * b, size_t d);
+void fvec2bitvec(const float* x, uint8_t* b, size_t d);
 
 /** Shuffle the bits from b(i, j) := a(i, order[j])
  */
-void bitvec_shuffle (size_t n, size_t da, size_t db,
-                     const int *order,
-                     const uint8_t *a,
-                     uint8_t *b);
-
+void bitvec_shuffle(
+        size_t n,
+        size_t da,
+        size_t db,
+        const int* order,
+        const uint8_t* a,
+        uint8_t* b);
 
 /***********************************************
  * Generic reader/writer for bit strings
  ***********************************************/
 
-
 struct BitstringWriter {
-    uint8_t *code;
+    uint8_t* code;
     size_t code_size;
     size_t i; // current bit offset
 
     // code_size in bytes
-    BitstringWriter(uint8_t *code, size_t code_size);
+    BitstringWriter(uint8_t* code, size_t code_size);
 
     // write the nbit low bits of x
     void write(uint64_t x, int nbit);
 };
 
 struct BitstringReader {
-    const uint8_t *code;
+    const uint8_t* code;
     size_t code_size;
     size_t i;
 
     // code_size in bytes
-    BitstringReader(const uint8_t *code, size_t code_size);
+    BitstringReader(const uint8_t* code, size_t code_size);
 
     // read nbit bits from the code
     uint64_t read(int nbit);
@@ -108,15 +97,12 @@ struct BitstringReader {
  * Hamming distance computation functions
  **************************************************/
 
-
-
 FAISS_API extern size_t hamming_batch_size;
 
 inline int popcount64(uint64_t x) {
     return __builtin_popcountl(x);
 }
 
-
 /** Compute a set of Hamming distances between na and nb binary vectors
  *
  * @param  a             size na * nbytespercode
@@ -124,15 +110,13 @@ inline int popcount64(uint64_t x) {
  * @param  nbytespercode should be multiple of 8
  * @param  dis           output distances, size na * nb
  */
-void hammings (
-        const uint8_t * a,
-        const uint8_t * b,
-        size_t na, size_t nb,
+void hammings(
+        const uint8_t* a,
+        const uint8_t* b,
+        size_t na,
+        size_t nb,
         size_t nbytespercode,
-        hamdis_t * dis);
-
-
-
+        hamdis_t* dis);
 
 /** Return the k smallest Hamming distances for a set of binary query vectors,
  * using a max heap.
@@ -142,22 +126,22 @@ void hammings (
  * @param ncodes  size of the binary codes (bytes)
  * @param ordered if != 0: order the results by decreasing distance
  *                (may be bottleneck for k/n > 0.01) */
-void hammings_knn_hc (
-        int_maxheap_array_t * ha,
-        const uint8_t * a,
-        const uint8_t * b,
+void hammings_knn_hc(
+        int_maxheap_array_t* ha,
+        const uint8_t* a,
+        const uint8_t* b,
         size_t nb,
         size_t ncodes,
         int ordered);
 
 /* Legacy alias to hammings_knn_hc. */
-void hammings_knn (
-  int_maxheap_array_t * ha,
-  const uint8_t * a,
-  const uint8_t * b,
-  size_t nb,
-  size_t ncodes,
-  int ordered);
+void hammings_knn(
+        int_maxheap_array_t* ha,
+        const uint8_t* a,
+        const uint8_t* b,
+        size_t nb,
+        size_t ncodes,
+        int ordered);
 
 /** Return the k smallest Hamming distances for a set of binary query vectors,
  * using counting max.
@@ -171,66 +155,59 @@ void hammings_knn (
  *                neighbors
  * @param labels  output ids of the k nearest neighbors to each query vector
  */
-void hammings_knn_mc (
-  const uint8_t * a,
-  const uint8_t * b,
-  size_t na,
-  size_t nb,
-  size_t k,
-  size_t ncodes,
-  int32_t *distances,
-  int64_t *labels);
+void hammings_knn_mc(
+        const uint8_t* a,
+        const uint8_t* b,
+        size_t na,
+        size_t nb,
+        size_t k,
+        size_t ncodes,
+        int32_t* distances,
+        int64_t* labels);
 
 /** same as hammings_knn except we are doing a range search with radius */
-void hamming_range_search (
-    const uint8_t * a,
-    const uint8_t * b,
-    size_t na,
-    size_t nb,
-    int radius,
-    size_t ncodes,
-    RangeSearchResult *result);
-
+void hamming_range_search(
+        const uint8_t* a,
+        const uint8_t* b,
+        size_t na,
+        size_t nb,
+        int radius,
+        size_t ncodes,
+        RangeSearchResult* result);
 
 /* Counting the number of matches or of cross-matches (without returning them)
    For use with function that assume pre-allocated memory */
-void hamming_count_thres (
-        const uint8_t * bs1,
-        const uint8_t * bs2,
+void hamming_count_thres(
+        const uint8_t* bs1,
+        const uint8_t* bs2,
         size_t n1,
         size_t n2,
         hamdis_t ht,
         size_t ncodes,
-        size_t * nptr);
+        size_t* nptr);
 
 /* Return all Hamming distances/index passing a thres. Pre-allocation of output
    is required. Use hamming_count_thres to determine the proper size. */
-size_t match_hamming_thres (
-        const uint8_t * bs1,
-        const uint8_t * bs2,
+size_t match_hamming_thres(
+        const uint8_t* bs1,
+        const uint8_t* bs2,
         size_t n1,
         size_t n2,
         hamdis_t ht,
         size_t ncodes,
-        int64_t * idx,
-        hamdis_t * dis);
+        int64_t* idx,
+        hamdis_t* dis);
 
 /* Cross-matching in a set of vectors */
-void crosshamming_count_thres (
-        const uint8_t * dbs,
+void crosshamming_count_thres(
+        const uint8_t* dbs,
         size_t n,
         hamdis_t ht,
         size_t ncodes,
-        size_t * nptr);
-
+        size_t* nptr);
 
 /* compute the Hamming distances between two codewords of nwords*64 bits */
-hamdis_t hamming (
-        const uint64_t * bs1,
-        const uint64_t * bs2,
-        size_t nwords);
-
-
+hamdis_t hamming(const uint64_t* bs1, const uint64_t* bs2, size_t nwords);
 
 } // namespace faiss
 

data/vendor/faiss/faiss/utils/ordered_key_value.h

@@ -5,8 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-
-
 #pragma once
 
 #include <climits>
@@ -14,7 +12,6 @@
 
 #include <limits>
 
-
 namespace faiss {
 
 /*******************************************************************
@@ -34,8 +31,10 @@ namespace faiss {
 template <typename T_, typename TI_>
 struct CMax;
 
-template<typename T> inline T cmin_nextafter(T x);
-template<typename T> inline T cmax_nextafter(T x);
+template <typename T>
+inline T cmin_nextafter(T x);
+template <typename T>
+inline T cmax_nextafter(T x);
 
 // traits of minheaps = heaps where the minimum value is stored on top
 // useful to find the *max* values of an array
@@ -44,10 +43,10 @@ struct CMin {
     typedef T_ T;
     typedef TI_ TI;
     typedef CMax<T_, TI_> Crev; // reference to reverse comparison
-    inline static bool cmp (T a, T b) {
+    inline static bool cmp(T a, T b) {
         return a < b;
     }
-    inline static T neutral () {
+    inline static T neutral() {
         return std::numeric_limits<T>::lowest();
     }
     static const bool is_max = false;
@@ -57,18 +56,15 @@ struct CMin {
     }
 };
 
-
-
-
 template <typename T_, typename TI_>
 struct CMax {
     typedef T_ T;
     typedef TI_ TI;
     typedef CMin<T_, TI_> Crev;
-    inline static bool cmp (T a, T b) {
+    inline static bool cmp(T a, T b) {
         return a > b;
     }
-    inline static T neutral () {
+    inline static T neutral() {
         return std::numeric_limits<T>::max();
     }
     static const bool is_max = true;
@@ -77,22 +73,24 @@ struct CMax {
     }
 };
 
-
-template<> inline float cmin_nextafter<float>(float x) {
+template <>
+inline float cmin_nextafter<float>(float x) {
     return std::nextafterf(x, -HUGE_VALF);
 }
 
-template<> inline float cmax_nextafter<float>(float x) {
+template <>
+inline float cmax_nextafter<float>(float x) {
     return std::nextafterf(x, HUGE_VALF);
 }
 
-template<> inline uint16_t cmin_nextafter<uint16_t>(uint16_t x) {
+template <>
+inline uint16_t cmin_nextafter<uint16_t>(uint16_t x) {
     return x - 1;
 }
 
-template<> inline uint16_t cmax_nextafter<uint16_t>(uint16_t x) {
+template <>
+inline uint16_t cmax_nextafter<uint16_t>(uint16_t x) {
     return x + 1;
 }
 
-
 } // namespace faiss