faiss 0.5.3 → 0.6.1

data/vendor/faiss/faiss/IndexAdditiveQuantizer.cpp

@@ -8,13 +8,12 @@
 #include <faiss/IndexAdditiveQuantizer.h>
 
 #include <algorithm>
-#include <cmath>
 #include <cstring>
 
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/ResidualQuantizer.h>
 #include <faiss/impl/ResultHandler.h>
-#include <faiss/utils/distances.h>
+#include <faiss/utils/distances_dispatch.h>
 #include <faiss/utils/extra_distances.h>
 
 namespace faiss {
@@ -24,10 +23,10 @@ namespace faiss {
  **************************************************************************************/
 
 IndexAdditiveQuantizer::IndexAdditiveQuantizer(
-        idx_t d,
-        AdditiveQuantizer* aq,
+        idx_t d_,
+        AdditiveQuantizer* aq_,
         MetricType metric)
-        : IndexFlatCodes(aq->code_size, d, metric), aq(aq) {
+        : IndexFlatCodes(aq_->code_size, d_, metric), aq(aq_) {
     FAISS_THROW_IF_NOT(metric == METRIC_INNER_PRODUCT || metric == METRIC_L2);
 }
 
@@ -46,14 +45,14 @@ struct AQDistanceComputerDecompress : FlatCodesDistanceComputer {
 
     AQDistanceComputerDecompress(
             const IndexAdditiveQuantizer& iaq,
-            VectorDistance vd)
+            VectorDistance vd_)
             : FlatCodesDistanceComputer(iaq.codes.data(), iaq.code_size),
               tmp(iaq.d * 2),
               aq(*iaq.aq),
-              vd(vd),
+              vd(vd_),
               d(iaq.d) {}
 
-    const float* q;
+    const float* q = nullptr;
     void set_query(const float* x) final {
         q = x;
     }
@@ -84,7 +83,7 @@ struct AQDistanceComputerLUT : FlatCodesDistanceComputer {
               aq(*iaq.aq),
               d(iaq.d) {}
 
-    float bias;
+    float bias = 0.0f;
     void set_query(const float* x) final {
         q = x;
         // this is quite sub-optimal for multiple queries
@@ -129,7 +128,7 @@ void search_with_decompress(
             typename BlockResultHandler::SingleResultHandler;
 
 #pragma omp parallel for if (res.nq > 100)
-    for (int64_t q = 0; q < res.nq; q++) {
+    for (int64_t q = 0; q < static_cast<int64_t>(res.nq); q++) {
         SingleResultHandler resi(res);
         resi.begin(q);
         std::vector<float> tmp(ir.d);
@@ -165,7 +164,7 @@ void search_with_LUT(
     aq.compute_LUT(nq, xq, LUT.get());
 
 #pragma omp parallel for if (nq > 100)
-    for (int64_t q = 0; q < nq; q++) {
+    for (int64_t q = 0; q < static_cast<int64_t>(nq); q++) {
         SingleResultHandler resi(res);
         resi.begin(q);
         std::vector<float> tmp(aq.d);
@@ -189,17 +188,14 @@ void search_with_LUT(
 FlatCodesDistanceComputer* IndexAdditiveQuantizer::
         get_FlatCodesDistanceComputer() const {
     if (aq->search_type == AdditiveQuantizer::ST_decompress) {
-        if (metric_type == METRIC_L2) {
-            using VD = VectorDistance<METRIC_L2>;
-            VD vd = {size_t(d), metric_arg};
-            return new AQDistanceComputerDecompress<VD>(*this, vd);
-        } else if (metric_type == METRIC_INNER_PRODUCT) {
-            using VD = VectorDistance<METRIC_INNER_PRODUCT>;
-            VD vd = {size_t(d), metric_arg};
-            return new AQDistanceComputerDecompress<VD>(*this, vd);
-        } else {
-            FAISS_THROW_MSG("unsupported metric");
-        }
+        return with_VectorDistance(
+                d,
+                metric_type,
+                metric_arg,
+                [&](auto vd) -> FlatCodesDistanceComputer* {
+                    return new AQDistanceComputerDecompress<decltype(vd)>(
+                            *this, vd);
+                });
     } else {
         if (metric_type == METRIC_INNER_PRODUCT) {
             return new AQDistanceComputerLUT<
@@ -242,17 +238,17 @@ void IndexAdditiveQuantizer::search(
             !params, "search params not supported for this index");
 
     if (aq->search_type == AdditiveQuantizer::ST_decompress) {
-        if (metric_type == METRIC_L2) {
-            using VD = VectorDistance<METRIC_L2>;
-            VD vd = {size_t(d), metric_arg};
-            HeapBlockResultHandler<VD::C> rh(n, distances, labels, k);
-            search_with_decompress(*this, x, vd, rh);
-        } else if (metric_type == METRIC_INNER_PRODUCT) {
-            using VD = VectorDistance<METRIC_INNER_PRODUCT>;
-            VD vd = {size_t(d), metric_arg};
-            HeapBlockResultHandler<VD::C> rh(n, distances, labels, k);
-            search_with_decompress(*this, x, vd, rh);
-        }
+        with_VectorDistance(d, metric_type, metric_arg, [&](auto vd) {
+            if constexpr (decltype(vd)::is_similarity) {
+                HeapBlockResultHandler<CMin<float, idx_t>> rh(
+                        n, distances, labels, k);
+                search_with_decompress(*this, x, vd, rh);
+            } else {
+                HeapBlockResultHandler<CMax<float, idx_t>> rh(
+                        n, distances, labels, k);
+                search_with_decompress(*this, x, vd, rh);
+            }
+        });
     } else {
         if (metric_type == METRIC_INNER_PRODUCT) {
             HeapBlockResultHandler<CMin<float, idx_t>> rh(
@@ -303,23 +299,23 @@ void IndexAdditiveQuantizer::sa_decode(idx_t n, const uint8_t* bytes, float* x)
  **************************************************************************************/
 
 IndexResidualQuantizer::IndexResidualQuantizer(
-        int d,        ///< dimensionality of the input vectors
+        int d_,       ///< dimensionality of the input vectors
         size_t M,     ///< number of subquantizers
         size_t nbits, ///< number of bit per subvector index
         MetricType metric,
         Search_type_t search_type)
         : IndexResidualQuantizer(
-                  d,
+                  d_,
                   std::vector<size_t>(M, nbits),
                   metric,
                   search_type) {}
 
 IndexResidualQuantizer::IndexResidualQuantizer(
-        int d,
+        int d_,
         const std::vector<size_t>& nbits,
         MetricType metric,
         Search_type_t search_type)
-        : IndexAdditiveQuantizer(d, &rq, metric), rq(d, nbits, search_type) {
+        : IndexAdditiveQuantizer(d_, &rq, metric), rq(d_, nbits, search_type) {
     code_size = rq.code_size;
     is_trained = false;
 }
@@ -337,13 +333,13 @@ void IndexResidualQuantizer::train(idx_t n, const float* x) {
  **************************************************************************************/
 
 IndexLocalSearchQuantizer::IndexLocalSearchQuantizer(
-        int d,
+        int d_,
         size_t M,     ///< number of subquantizers
         size_t nbits, ///< number of bit per subvector index
         MetricType metric,
         Search_type_t search_type)
-        : IndexAdditiveQuantizer(d, &lsq, metric),
-          lsq(d, M, nbits, search_type) {
+        : IndexAdditiveQuantizer(d_, &lsq, metric),
+          lsq(d_, M, nbits, search_type) {
     code_size = lsq.code_size;
     is_trained = false;
 }
@@ -361,14 +357,14 @@ void IndexLocalSearchQuantizer::train(idx_t n, const float* x) {
  **************************************************************************************/
 
 IndexProductResidualQuantizer::IndexProductResidualQuantizer(
-        int d,          ///< dimensionality of the input vectors
+        int d_,         ///< dimensionality of the input vectors
         size_t nsplits, ///< number of residual quantizers
         size_t Msub,    ///< number of subquantizers per RQ
         size_t nbits,   ///< number of bit per subvector index
         MetricType metric,
         Search_type_t search_type)
-        : IndexAdditiveQuantizer(d, &prq, metric),
-          prq(d, nsplits, Msub, nbits, search_type) {
+        : IndexAdditiveQuantizer(d_, &prq, metric),
+          prq(d_, nsplits, Msub, nbits, search_type) {
     code_size = prq.code_size;
     is_trained = false;
 }
@@ -386,14 +382,14 @@ void IndexProductResidualQuantizer::train(idx_t n, const float* x) {
  **************************************************************************************/
 
 IndexProductLocalSearchQuantizer::IndexProductLocalSearchQuantizer(
-        int d,          ///< dimensionality of the input vectors
+        int d_,         ///< dimensionality of the input vectors
         size_t nsplits, ///< number of local search quantizers
         size_t Msub,    ///< number of subquantizers per LSQ
         size_t nbits,   ///< number of bit per subvector index
         MetricType metric,
         Search_type_t search_type)
-        : IndexAdditiveQuantizer(d, &plsq, metric),
-          plsq(d, nsplits, Msub, nbits, search_type) {
+        : IndexAdditiveQuantizer(d_, &plsq, metric),
+          plsq(d_, nsplits, Msub, nbits, search_type) {
     code_size = plsq.code_size;
     is_trained = false;
 }
@@ -411,10 +407,10 @@ void IndexProductLocalSearchQuantizer::train(idx_t n, const float* x) {
  **************************************************************************************/
 
 AdditiveCoarseQuantizer::AdditiveCoarseQuantizer(
-        idx_t d,
-        AdditiveQuantizer* aq,
+        idx_t d_,
+        AdditiveQuantizer* aq_,
         MetricType metric)
-        : Index(d, metric), aq(aq) {}
+        : Index(d_, metric), aq(aq_) {}
 
 void AdditiveCoarseQuantizer::add(idx_t, const float*) {
     FAISS_THROW_MSG("not applicable");
@@ -468,7 +464,8 @@ void AdditiveCoarseQuantizer::search(
     if (metric_type == METRIC_INNER_PRODUCT) {
         aq->knn_centroids_inner_product(n, x, k, distances, labels);
     } else if (metric_type == METRIC_L2) {
-        FAISS_THROW_IF_NOT(centroid_norms.size() == ntotal);
+        FAISS_THROW_IF_NOT(
+                centroid_norms.size() == static_cast<size_t>(ntotal));
         aq->knn_centroids_L2(n, x, k, distances, labels, centroid_norms.data());
     }
 }
@@ -478,20 +475,20 @@ void AdditiveCoarseQuantizer::search(
  **************************************************************************************/
 
 ResidualCoarseQuantizer::ResidualCoarseQuantizer(
-        int d, ///< dimensionality of the input vectors
+        int d_, ///< dimensionality of the input vectors
         const std::vector<size_t>& nbits,
         MetricType metric)
-        : AdditiveCoarseQuantizer(d, &rq, metric), rq(d, nbits) {
+        : AdditiveCoarseQuantizer(d_, &rq, metric), rq(d_, nbits) {
     FAISS_THROW_IF_NOT(rq.tot_bits <= 63);
     is_trained = false;
 }
 
 ResidualCoarseQuantizer::ResidualCoarseQuantizer(
-        int d,
+        int d_,
         size_t M,     ///< number of subquantizers
         size_t nbits, ///< number of bit per subvector index
         MetricType metric)
-        : ResidualCoarseQuantizer(d, std::vector<size_t>(M, nbits), metric) {}
+        : ResidualCoarseQuantizer(d_, std::vector<size_t>(M, nbits), metric) {}
 
 ResidualCoarseQuantizer::ResidualCoarseQuantizer()
         : ResidualCoarseQuantizer(0, 0, 0) {}
@@ -509,7 +506,8 @@ void ResidualCoarseQuantizer::set_beam_factor(float new_beam_factor) {
         // Does not use the cross_products
         rq.codebook_cross_products.resize(0);
         // but the centroid norms are necessary!
-        if (metric_type == METRIC_L2 && ntotal != centroid_norms.size()) {
+        if (metric_type == METRIC_L2 &&
+            static_cast<size_t>(ntotal) != centroid_norms.size()) {
             if (verbose) {
                 printf("AdditiveCoarseQuantizer::train: computing centroid norms for %zd centroids\n",
                        size_t(ntotal));
@@ -545,7 +543,7 @@ void ResidualCoarseQuantizer::search(
 
     int beam_size = int(k * actual_beam_factor);
     if (beam_size > ntotal) {
-        beam_size = ntotal;
+        beam_size = static_cast<int>(ntotal);
     }
     size_t memory_per_point = rq.memory_per_point(beam_size);
 
@@ -578,8 +576,17 @@ void ResidualCoarseQuantizer::search(
         return;
     }
 
-    std::vector<int32_t> codes(beam_size * rq.M * n);
-    std::vector<float> beam_distances(n * beam_size);
+    size_t codes_size = mul_no_overflow(
+            mul_no_overflow(
+                    static_cast<size_t>(beam_size), rq.M, "beam_size * M"),
+            static_cast<size_t>(n),
+            "beam_size * M * n");
+    size_t beam_dist_size = mul_no_overflow(
+            static_cast<size_t>(n),
+            static_cast<size_t>(beam_size),
+            "n * beam_size");
+    std::vector<int32_t> codes(codes_size);
+    std::vector<float> beam_distances(beam_dist_size);
 
     rq.refine_beam(
             n, 1, x, beam_size, codes.data(), nullptr, beam_distances.data());
@@ -595,7 +602,7 @@ void ResidualCoarseQuantizer::search(
         for (idx_t j = 0; j < k; j++) {
             idx_t l = 0;
             int shift = 0;
-            for (int m = 0; m < rq.M; m++) {
+            for (size_t m = 0; m < rq.M; m++) {
                 l |= (*codes_i++) << shift;
                 shift += rq.nbits[m];
             }
@@ -618,11 +625,11 @@ void ResidualCoarseQuantizer::initialize_from(
  **************************************************************************************/
 
 LocalSearchCoarseQuantizer::LocalSearchCoarseQuantizer(
-        int d,        ///< dimensionality of the input vectors
+        int d_,       ///< dimensionality of the input vectors
         size_t M,     ///< number of subquantizers
         size_t nbits, ///< number of bit per subvector index
         MetricType metric)
-        : AdditiveCoarseQuantizer(d, &lsq, metric), lsq(d, M, nbits) {
+        : AdditiveCoarseQuantizer(d_, &lsq, metric), lsq(d_, M, nbits) {
     FAISS_THROW_IF_NOT(lsq.tot_bits <= 63);
     is_trained = false;
 }

data/vendor/faiss/faiss/IndexAdditiveQuantizerFastScan.cpp

@@ -11,11 +11,10 @@
 #include <memory>
 
 #include <faiss/impl/FaissAssert.h>
-#include <faiss/impl/FastScanDistancePostProcessing.h>
 #include <faiss/impl/LocalSearchQuantizer.h>
-#include <faiss/impl/LookupTableScaler.h>
 #include <faiss/impl/ResidualQuantizer.h>
-#include <faiss/impl/pq4_fast_scan.h>
+#include <faiss/impl/fast_scan/FastScanDistancePostProcessing.h>
+#include <faiss/impl/fast_scan/fast_scan.h>
 #include <faiss/utils/quantize_lut.h>
 #include <faiss/utils/utils.h>
 
@@ -26,16 +25,16 @@ inline size_t roundup(size_t a, size_t b) {
 }
 
 IndexAdditiveQuantizerFastScan::IndexAdditiveQuantizerFastScan(
-        AdditiveQuantizer* aq,
+        AdditiveQuantizer* aq_,
         MetricType metric,
-        int bbs) {
-    init(aq, metric, bbs);
+        int bbs_) {
+    init(aq_, metric, bbs_);
 }
 
 void IndexAdditiveQuantizerFastScan::init(
         AdditiveQuantizer* aq_init,
         MetricType metric,
-        int bbs) {
+        int bbs_) {
     FAISS_THROW_IF_NOT(aq_init != nullptr);
     FAISS_THROW_IF_NOT(!aq_init->nbits.empty());
     FAISS_THROW_IF_NOT(aq_init->nbits[0] == 4);
@@ -57,7 +56,7 @@ void IndexAdditiveQuantizerFastScan::init(
     } else {
         M = aq_init->M;
     }
-    init_fastscan(aq_init->d, M, 4, metric, bbs);
+    init_fastscan(static_cast<int>(aq_init->d), M, 4, metric, bbs_);
 
     max_train_points = 1024 * ksub * M;
 }
@@ -70,8 +69,8 @@ IndexAdditiveQuantizerFastScan::IndexAdditiveQuantizerFastScan()
 
 IndexAdditiveQuantizerFastScan::IndexAdditiveQuantizerFastScan(
         const IndexAdditiveQuantizer& orig,
-        int bbs) {
-    init(orig.aq, orig.metric_type, bbs);
+        int bbs_) {
+    init(orig.aq, orig.metric_type, bbs_);
 
     ntotal = orig.ntotal;
     is_trained = orig.is_trained;
@@ -202,9 +201,8 @@ void IndexAdditiveQuantizerFastScan::search(
         return;
     }
 
-    NormTableScaler scaler(norm_scale);
     FastScanDistancePostProcessing context;
-    context.norm_scaler = &scaler;
+    context.pq2x4_scale = norm_scale;
     if (metric_type == METRIC_L2) {
         search_dispatch_implem<true>(n, x, k, distances, labels, context);
     } else {
@@ -219,19 +217,23 @@ void IndexAdditiveQuantizerFastScan::sa_decode(
     aq->decode(bytes, x, n);
 }
 
+size_t IndexAdditiveQuantizerFastScan::fast_scan_code_size() const {
+    return M2 / 2;
+}
+
 /**************************************************************************************
  * IndexResidualQuantizerFastScan
  **************************************************************************************/
 
 IndexResidualQuantizerFastScan::IndexResidualQuantizerFastScan(
-        int d,        ///< dimensionality of the input vectors
-        size_t M,     ///< number of subquantizers
-        size_t nbits, ///< number of bit per subvector index
+        int d_,        ///< dimensionality of the input vectors
+        size_t M_,     ///< number of subquantizers
+        size_t nbits_, ///< number of bit per subvector index
         MetricType metric,
         Search_type_t search_type,
-        int bbs)
-        : rq(d, M, nbits, search_type) {
-    init(&rq, metric, bbs);
+        int bbs_)
+        : rq(d_, M_, nbits_, search_type) {
+    init(&rq, metric, bbs_);
 }
 
 IndexResidualQuantizerFastScan::IndexResidualQuantizerFastScan() {
@@ -243,14 +245,14 @@ IndexResidualQuantizerFastScan::IndexResidualQuantizerFastScan() {
  **************************************************************************************/
 
 IndexLocalSearchQuantizerFastScan::IndexLocalSearchQuantizerFastScan(
-        int d,
-        size_t M,     ///< number of subquantizers
-        size_t nbits, ///< number of bit per subvector index
+        int d_,
+        size_t M_,     ///< number of subquantizers
+        size_t nbits_, ///< number of bit per subvector index
         MetricType metric,
         Search_type_t search_type,
-        int bbs)
-        : lsq(d, M, nbits, search_type) {
-    init(&lsq, metric, bbs);
+        int bbs_)
+        : lsq(d_, M_, nbits_, search_type) {
+    init(&lsq, metric, bbs_);
 }
 
 IndexLocalSearchQuantizerFastScan::IndexLocalSearchQuantizerFastScan() {
@@ -262,15 +264,15 @@ IndexLocalSearchQuantizerFastScan::IndexLocalSearchQuantizerFastScan() {
  **************************************************************************************/
 
 IndexProductResidualQuantizerFastScan::IndexProductResidualQuantizerFastScan(
-        int d,          ///< dimensionality of the input vectors
+        int d_,         ///< dimensionality of the input vectors
         size_t nsplits, ///< number of residual quantizers
         size_t Msub,    ///< number of subquantizers per RQ
-        size_t nbits,   ///< number of bit per subvector index
+        size_t nbits_,  ///< number of bit per subvector index
         MetricType metric,
         Search_type_t search_type,
-        int bbs)
-        : prq(d, nsplits, Msub, nbits, search_type) {
-    init(&prq, metric, bbs);
+        int bbs_)
+        : prq(d_, nsplits, Msub, nbits_, search_type) {
+    init(&prq, metric, bbs_);
 }
 
 IndexProductResidualQuantizerFastScan::IndexProductResidualQuantizerFastScan() {
@@ -283,15 +285,15 @@ IndexProductResidualQuantizerFastScan::IndexProductResidualQuantizerFastScan() {
 
 IndexProductLocalSearchQuantizerFastScan::
         IndexProductLocalSearchQuantizerFastScan(
-                int d,          ///< dimensionality of the input vectors
+                int d_,         ///< dimensionality of the input vectors
                 size_t nsplits, ///< number of local search quantizers
                 size_t Msub,    ///< number of subquantizers per LSQ
-                size_t nbits,   ///< number of bit per subvector index
+                size_t nbits_,  ///< number of bit per subvector index
                 MetricType metric,
                 Search_type_t search_type,
-                int bbs)
-        : plsq(d, nsplits, Msub, nbits, search_type) {
-    init(&plsq, metric, bbs);
+                int bbs_)
+        : plsq(d_, nsplits, Msub, nbits_, search_type) {
+    init(&plsq, metric, bbs_);
 }
 
 IndexProductLocalSearchQuantizerFastScan::

data/vendor/faiss/faiss/IndexAdditiveQuantizerFastScan.h

@@ -28,7 +28,7 @@ namespace faiss {
  */
 
 struct IndexAdditiveQuantizerFastScan : IndexFastScan {
-    AdditiveQuantizer* aq;
+    AdditiveQuantizer* aq = nullptr;
     using Search_type_t = AdditiveQuantizer::Search_type_t;
 
     bool rescale_norm = true;
@@ -86,6 +86,9 @@ struct IndexAdditiveQuantizerFastScan : IndexFastScan {
      * @param x       output vectors, size n * d
      */
     void sa_decode(idx_t n, const uint8_t* bytes, float* x) const override;
+
+    /// Packed code size: M2 / 2 bytes (4-bit AQ sub-quantizer nibbles)
+    size_t fast_scan_code_size() const override;
 };
 
 /** Index based on a residual quantizer. Stored vectors are

data/vendor/faiss/faiss/IndexBinary.cpp

@@ -12,12 +12,15 @@
 
 #include <cinttypes>
 #include <cstring>
+#include <typeinfo>
 
 namespace faiss {
 
-IndexBinary::IndexBinary(idx_t d, MetricType metric)
-        : d(d), code_size(d / 8), metric_type(metric) {
-    FAISS_THROW_IF_NOT(d % 8 == 0);
+IndexBinary::IndexBinary(idx_t d_, MetricType metric)
+        : d(static_cast<int>(d_)),
+          code_size(static_cast<int>(d_ / 8)),
+          metric_type(metric) {
+    FAISS_THROW_IF_NOT(d_ % 8 == 0);
 }
 
 IndexBinary::~IndexBinary() = default;

data/vendor/faiss/faiss/IndexBinary.h

@@ -58,7 +58,7 @@ struct IndexBinary {
         } else {
             FAISS_THROW_MSG("IndexBinary::train: unsupported numeric type");
         }
-    };
+    }
 
     /** Add n vectors of dimension d to the index.
      *
@@ -72,7 +72,7 @@ struct IndexBinary {
         } else {
             FAISS_THROW_MSG("IndexBinary::add: unsupported numeric type");
         }
-    };
+    }
 
     /** Same as add, but stores xids instead of sequential ids.
      *
@@ -93,7 +93,7 @@ struct IndexBinary {
             FAISS_THROW_MSG(
                     "IndexBinary::add_with_ids: unsupported numeric type");
         }
-    };
+    }
 
     /** Query n vectors of dimension d to the index.
      *
@@ -129,7 +129,7 @@ struct IndexBinary {
         } else {
             FAISS_THROW_MSG("IndexBinary::search: unsupported numeric type");
         }
-    };
+    }
 
     /** Query n vectors of dimension d to the index.
      *

data/vendor/faiss/faiss/IndexBinaryFlat.cpp

@@ -18,7 +18,7 @@
 
 namespace faiss {
 
-IndexBinaryFlat::IndexBinaryFlat(idx_t d) : IndexBinary(d) {}
+IndexBinaryFlat::IndexBinaryFlat(idx_t d_) : IndexBinary(d_) {}
 
 void IndexBinaryFlat::add(idx_t n, const uint8_t* x) {
     xb.insert(xb.end(), x, x + n * code_size);

data/vendor/faiss/faiss/IndexBinaryFlat.h

@@ -14,8 +14,8 @@
 
 #include <faiss/IndexBinary.h>
 
+#include <faiss/impl/approx_topk/approx_topk.h>
 #include <faiss/impl/maybe_owned_vector.h>
-#include <faiss/utils/approx_topk/mode.h>
 
 namespace faiss {
 

data/vendor/faiss/faiss/IndexBinaryFromFloat.cpp

@@ -18,10 +18,10 @@ namespace faiss {
 
 IndexBinaryFromFloat::IndexBinaryFromFloat() = default;
 
-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() {