faiss 0.2.0 → 0.2.4

data/vendor/faiss/faiss/IndexBinaryFromFloat.cpp

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

data/vendor/faiss/faiss/IndexBinaryFromFloat.h

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