faiss 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61316c4fa0bbf7f85dfaeb6890d75b35e20e013a5ed25b8d87a3d252dfea2f50
-  data.tar.gz: af0de6135077f184092dbfec00f9bf7492eb38da66d5ef5f4f2d020ce0486648
+  metadata.gz: f3306dbb81c9168dcd82435c99d3404ab8501ac9b948adb2db7238ab89c01003
+  data.tar.gz: b14a120e9cc67baba96816b52cf34388aae79fa690fc511918543921b64380d5
 SHA512:
-  metadata.gz: 6d21e6186d57eec3852ab285f0bcd89affacb56577c661b514763478ef6d610f808a7d1e4cbc062278aec6cbc11959b204de237b9669dcfb58de4b3070be2c1e
-  data.tar.gz: a65646746c2f558b48285d8c192d246ce4a95cead1f4413349e8eac4393ac4aa47ad3919764e7caa1abf517edb57153e385d7a012a3dbb22258a98c2795aa5b1
+  metadata.gz: b7af3f6540d283d886301137e5fed5dff32b0c0659e9c46d6c45808439e94a0a91f8c953d5897b480568169ec23cacc4224db523d6ab9b3737d7f0df1ce8190c
+  data.tar.gz: fbe44473d9e3c61427aee597fed40264ba83a8184c0fe5280b6bf181d9bcc396583f033a69e8d3ec643ee0d41ef435dfeef4aa4441ade67703cbd8259326cb81

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.5.0 (2025-11-12)
+
+- Updated Faiss to 1.13.0
+- Added support for releasing GVL
+
 ## 0.4.3 (2025-10-26)
 
 - Fixed error with Rice 4.7

data/ext/faiss/index.cpp

@@ -111,19 +111,28 @@ void init_index(Rice::Module& m) {
       })
     .define_method(
       "train",
-      [](faiss::Index &self, numo::SFloat objects) {
+      [](Rice::Object rb_self, numo::SFloat objects) {
+        rb_check_frozen(rb_self.value());
+
+        auto &self = *Rice::Data_Object<faiss::Index>{rb_self};
         auto n = check_shape(objects, self.d);
         self.train(n, objects.read_ptr());
       })
     .define_method(
       "add",
-      [](faiss::Index &self, numo::SFloat objects) {
+      [](Rice::Object rb_self, numo::SFloat objects) {
+        rb_check_frozen(rb_self.value());
+
+        auto &self = *Rice::Data_Object<faiss::Index>{rb_self};
         auto n = check_shape(objects, self.d);
         self.add(n, objects.read_ptr());
       })
     .define_method(
       "add_with_ids",
-      [](faiss::Index &self, numo::SFloat objects, numo::Int64 ids) {
+      [](Rice::Object rb_self, numo::SFloat objects, numo::Int64 ids) {
+        rb_check_frozen(rb_self.value());
+
+        auto &self = *Rice::Data_Object<faiss::Index>{rb_self};
         auto n = check_shape(objects, self.d);
         if (ids.ndim() != 1 || ids.shape()[0] != n) {
           throw Rice::Exception(rb_eArgError, "expected ids to be 1d array with size %d", n);
@@ -132,13 +141,20 @@ void init_index(Rice::Module& m) {
       })
     .define_method(
       "search",
-      [](faiss::Index &self, numo::SFloat objects, size_t k) {
+      [](Rice::Object rb_self, numo::SFloat objects, size_t k) {
+        auto &self = *Rice::Data_Object<faiss::Index>{rb_self};
         auto n = check_shape(objects, self.d);
 
         auto distances = numo::SFloat({n, k});
         auto labels = numo::Int64({n, k});
 
-        self.search(n, objects.read_ptr(), k, distances.write_ptr(), labels.write_ptr());
+        if (rb_self.is_frozen()) {
+          Rice::detail::no_gvl([&] {
+            self.search(n, objects.read_ptr(), k, distances.write_ptr(), labels.write_ptr());
+          });
+        } else {
+          self.search(n, objects.read_ptr(), k, distances.write_ptr(), labels.write_ptr());
+        }
 
         Rice::Array ret;
         ret.push(std::move(distances), false);
@@ -147,7 +163,10 @@ void init_index(Rice::Module& m) {
       })
     .define_method(
       "nprobe=",
-      [](faiss::Index &self, double val) {
+      [](Rice::Object rb_self, double val) {
+        rb_check_frozen(rb_self.value());
+
+        auto &self = *Rice::Data_Object<faiss::Index>{rb_self};
         faiss::ParameterSpace().set_index_parameter(&self, "nprobe", val);
       })
     .define_method(

data/ext/faiss/index_binary.cpp

@@ -27,25 +27,38 @@ void init_index_binary(Rice::Module& m) {
       })
     .define_method(
       "train",
-      [](faiss::IndexBinary &self, numo::UInt8 objects) {
+      [](Rice::Object rb_self, numo::UInt8 objects) {
+        rb_check_frozen(rb_self.value());
+
+        auto &self = *Rice::Data_Object<faiss::IndexBinary>{rb_self};
         auto n = check_shape(objects, self.d / 8);
         self.train(n, objects.read_ptr());
       })
     .define_method(
       "add",
-      [](faiss::IndexBinary &self, numo::UInt8 objects) {
+      [](Rice::Object rb_self, numo::UInt8 objects) {
+        rb_check_frozen(rb_self.value());
+
+        auto &self = *Rice::Data_Object<faiss::IndexBinary>{rb_self};
         auto n = check_shape(objects, self.d / 8);
         self.add(n, objects.read_ptr());
       })
     .define_method(
       "search",
-      [](faiss::IndexBinary &self, numo::UInt8 objects, size_t k) {
+      [](Rice::Object rb_self, numo::UInt8 objects, size_t k) {
+        auto &self = *Rice::Data_Object<faiss::IndexBinary>{rb_self};
         auto n = check_shape(objects, self.d / 8);
 
         auto distances = numo::Int32({n, k});
         auto labels = numo::Int64({n, k});
 
-        self.search(n, objects.read_ptr(), k, distances.write_ptr(), labels.write_ptr());
+        if (rb_self.is_frozen()) {
+          Rice::detail::no_gvl([&] {
+            self.search(n, objects.read_ptr(), k, distances.write_ptr(), labels.write_ptr());
+          });
+        } else {
+          self.search(n, objects.read_ptr(), k, distances.write_ptr(), labels.write_ptr());
+        }
 
         Rice::Array ret;
         ret.push(std::move(distances), false);

data/ext/faiss/kmeans.cpp

@@ -32,11 +32,11 @@ void init_kmeans(Rice::Module& m) {
       })
     .define_method(
       "train",
-      [](Rice::Object self, numo::SFloat objects) {
-        auto self_ptr = Rice::detail::From_Ruby<faiss::Clustering*>().convert(self.value());
-        auto n = check_shape(objects, self_ptr->d);
-        auto index = faiss::IndexFlatL2(self_ptr->d);
-        self.iv_set("@index", Rice::Object(Rice::detail::To_Ruby<faiss::IndexFlatL2>().convert(index)));
-        self_ptr->train(n, objects.read_ptr(), index);
+      [](Rice::Object rb_self, numo::SFloat objects) {
+        auto &self = *Rice::Data_Object<faiss::Clustering>{rb_self};
+        auto n = check_shape(objects, self.d);
+        auto index = faiss::IndexFlatL2(self.d);
+        rb_self.iv_set("@index", index);
+        self.train(n, objects.read_ptr(), index);
       });
 }

data/lib/faiss/version.rb

@@ -1,3 +1,3 @@
 module Faiss
-  VERSION = "0.4.3"
+  VERSION = "0.5.0"
 end

data/vendor/faiss/faiss/AutoTune.cpp

@@ -20,15 +20,14 @@
 #include <faiss/utils/utils.h>
 
 #include <faiss/IndexHNSW.h>
+#include <faiss/IndexIDMap.h>
 #include <faiss/IndexIVF.h>
-#include <faiss/IndexIVFFlat.h>
 #include <faiss/IndexIVFPQ.h>
 #include <faiss/IndexIVFPQR.h>
 #include <faiss/IndexPQ.h>
 #include <faiss/IndexPreTransform.h>
 #include <faiss/IndexRefine.h>
 #include <faiss/IndexShardsIVF.h>
-#include <faiss/MetaIndexes.h>
 
 namespace faiss {
 
@@ -126,7 +125,7 @@ bool OperatingPoints::add(
         }
     } else {
         int i;
-        // stricto sensu this should be a bissection
+        // stricto sensu this should be a bisection
         for (i = 0; i < a.size(); i++) {
             if (a[i].perf >= perf) {
                 break;

data/vendor/faiss/faiss/AutoTune.h

@@ -32,7 +32,7 @@ struct AutoTuneCriterion {
 
     AutoTuneCriterion(idx_t nq, idx_t nnn);
 
-    /** Intitializes the gt_D and gt_I vectors. Must be called before evaluating
+    /** Initializes the gt_D and gt_I vectors. Must be called before evaluating
      *
      * @param gt_D_in  size nq * gt_nnn
      * @param gt_I_in  size nq * gt_nnn

data/vendor/faiss/faiss/Clustering.cpp

@@ -212,7 +212,7 @@ void compute_centroids(
  * It works by slightly changing the centroids to make 2 clusters from
  * a single one. Takes the same arguments as compute_centroids.
  *
- * @return           nb of spliting operations (larger is worse)
+ * @return           nb of splitting operations (larger is worse)
  */
 int split_clusters(
         size_t d,
@@ -242,7 +242,7 @@ int split_clusters(
                    centroids + cj * d,
                    sizeof(*centroids) * d);
 
-            /* small symmetric pertubation */
+            /* small symmetric perturbation */
             for (size_t j = 0; j < d; j++) {
                 if (j % 2 == 0) {
                     centroids[ci * d + j] *= 1 + EPS;

data/vendor/faiss/faiss/Clustering.h

@@ -73,7 +73,7 @@ struct ClusteringIterationStats {
  * points to the centroids. Therefore, at each iteration the centroids
  * are added to the index.
  *
- * On output, the centoids table is set to the latest version
+ * On output, the centroids table is set to the latest version
  * of the centroids and they are also added to the index. If the
  * centroids table it is not empty on input, it is also used for
  * initialization.
@@ -109,7 +109,7 @@ struct Clustering : ClusteringParameters {
 
     /** run with encoded vectors
      *
-     * win addition to train()'s parameters takes a codec as parameter
+     * in addition to train()'s parameters takes a codec as parameter
      * to decode the input vectors.
      *
      * @param codec      codec used to decode the vectors (nullptr =

data/vendor/faiss/faiss/IVFlib.cpp

@@ -9,7 +9,6 @@
 #include <omp.h>
 
 #include <memory>
-#include <numeric>
 
 #include <faiss/IndexAdditiveQuantizer.h>
 #include <faiss/IndexIVFAdditiveQuantizer.h>
@@ -58,7 +57,7 @@ void check_compatible_for_merge(const Index* index0, const Index* index1) {
         ivf0->check_compatible_for_merge(*ivf1);
     }
 
-    // TODO: check as thoroughfully for other index types
+    // TODO: check as thoroughly for other index types
 }
 
 const IndexIVF* try_extract_index_ivf(const Index* index) {

data/vendor/faiss/faiss/IVFlib.h

@@ -100,7 +100,7 @@ struct SlidingIndexWindow {
     std::vector<std::vector<size_t>> sizes;
 
     /// index should be initially empty and trained
-    SlidingIndexWindow(Index* index);
+    explicit SlidingIndexWindow(Index* index);
 
     /** Add one index to the current index and remove the oldest one.
      *

data/vendor/faiss/faiss/Index.h

@@ -17,7 +17,7 @@
 #include <sstream>
 
 #define FAISS_VERSION_MAJOR 1
-#define FAISS_VERSION_MINOR 12
+#define FAISS_VERSION_MINOR 13
 #define FAISS_VERSION_PATCH 0
 
 // Macro to combine the version components into a single string
@@ -78,7 +78,7 @@ inline size_t get_numeric_type_size(NumericType numeric_type) {
     }
 }
 
-/** Parent class for the optional search paramenters.
+/** Parent class for the optional search parameters.
  *
  * Sub-classes with additional search parameters should inherit this class.
  * Ownership of the object fields is always to the caller.
@@ -125,11 +125,11 @@ struct Index {
     /** Perform training on a representative set of vectors
      *
      * @param n      nb of training vectors
-     * @param x      training vecors, size n * d
+     * @param x      training vectors, size n * d
      */
     virtual void train(idx_t n, const float* x);
 
-    virtual void trainEx(idx_t n, const void* x, NumericType numeric_type) {
+    virtual void train_ex(idx_t n, const void* x, NumericType numeric_type) {
         if (numeric_type == NumericType::Float32) {
             train(n, static_cast<const float*>(x));
         } else {
@@ -147,7 +147,7 @@ struct Index {
      */
     virtual void add(idx_t n, const float* x) = 0;
 
-    virtual void addEx(idx_t n, const void* x, NumericType numeric_type) {
+    virtual void add_ex(idx_t n, const void* x, NumericType numeric_type) {
         if (numeric_type == NumericType::Float32) {
             add(n, static_cast<const float*>(x));
         } else {
@@ -165,7 +165,7 @@ struct Index {
      * @param xids      if non-null, ids to store for the vectors (size n)
      */
     virtual void add_with_ids(idx_t n, const float* x, const idx_t* xids);
-    virtual void add_with_idsEx(
+    virtual void add_with_ids_ex(
             idx_t n,
             const void* x,
             NumericType numeric_type,
@@ -196,7 +196,7 @@ struct Index {
             idx_t* labels,
             const SearchParameters* params = nullptr) const = 0;
 
-    virtual void searchEx(
+    virtual void search_ex(
             idx_t n,
             const void* x,
             NumericType numeric_type,
@@ -258,7 +258,7 @@ struct Index {
      *
      * this function may not be defined for some indexes
      * @param key         id of the vector to reconstruct
-     * @param recons      reconstucted vector (size d)
+     * @param recons      reconstructed vector (size d)
      */
     virtual void reconstruct(idx_t key, float* recons) const;
 
@@ -268,7 +268,7 @@ struct Index {
      * this function may not be defined for some indexes
      * @param n           number of vectors to reconstruct
      * @param keys        ids of the vectors to reconstruct (size n)
-     * @param recons      reconstucted vector (size n * d)
+     * @param recons      reconstructed vector (size n * d)
      */
     virtual void reconstruct_batch(idx_t n, const idx_t* keys, float* recons)
             const;
@@ -278,7 +278,7 @@ struct Index {
      * this function may not be defined for some indexes
      * @param i0          index of the first vector in the sequence
      * @param ni          number of vectors in the sequence
-     * @param recons      reconstucted vector (size ni * d)
+     * @param recons      reconstructed vector (size ni * d)
      */
     virtual void reconstruct_n(idx_t i0, idx_t ni, float* recons) const;
 

data/vendor/faiss/faiss/Index2Layer.cpp

@@ -82,7 +82,7 @@ void Index2Layer::train(idx_t n, const float* x) {
 
     std::unique_ptr<const float[]> del_x(x_in == x ? nullptr : x);
 
-    std::vector<idx_t> assign(n); // assignement to coarse centroids
+    std::vector<idx_t> assign(n); // assignment to coarse centroids
     q1.quantizer->assign(n, x, assign.data());
     std::vector<float> residuals(n * d);
     for (idx_t i = 0; i < n; i++) {

data/vendor/faiss/faiss/Index2Layer.h

@@ -23,7 +23,7 @@ struct IndexIVFPQ;
 /** Same as an IndexIVFPQ without the inverted lists: codes are stored
  * sequentially
  *
- * The class is mainly inteded to store encoded vectors that can be
+ * The class is mainly intended to store encoded vectors that can be
  * accessed randomly, the search function is not implemented.
  */
 struct Index2Layer : IndexFlatCodes {
@@ -47,7 +47,7 @@ struct Index2Layer : IndexFlatCodes {
             MetricType metric = METRIC_L2);
 
     Index2Layer();
-    ~Index2Layer();
+    ~Index2Layer() override;
 
     void train(idx_t n, const float* x) override;
 

data/vendor/faiss/faiss/IndexAdditiveQuantizerFastScan.cpp

@@ -11,6 +11,7 @@
 #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>
@@ -123,7 +124,8 @@ void IndexAdditiveQuantizerFastScan::estimate_norm_scale(
     }
 
     std::vector<float> dis_tables(n * M * ksub);
-    compute_float_LUT(dis_tables.data(), n, x);
+    FastScanDistancePostProcessing empty_context;
+    compute_float_LUT(dis_tables.data(), n, x, empty_context);
 
     // here we compute the mean of scales for each query
     // TODO: try max of scales
@@ -153,7 +155,8 @@ void IndexAdditiveQuantizerFastScan::compute_codes(
 void IndexAdditiveQuantizerFastScan::compute_float_LUT(
         float* lut,
         idx_t n,
-        const float* x) const {
+        const float* x,
+        const FastScanDistancePostProcessing&) const {
     if (metric_type == METRIC_INNER_PRODUCT) {
         aq->compute_LUT(n, x, lut, 1.0f);
     } else {
@@ -200,10 +203,12 @@ void IndexAdditiveQuantizerFastScan::search(
     }
 
     NormTableScaler scaler(norm_scale);
+    FastScanDistancePostProcessing context;
+    context.norm_scaler = &scaler;
     if (metric_type == METRIC_L2) {
-        search_dispatch_implem<true>(n, x, k, distances, labels, &scaler);
+        search_dispatch_implem<true>(n, x, k, distances, labels, context);
     } else {
-        search_dispatch_implem<false>(n, x, k, distances, labels, &scaler);
+        search_dispatch_implem<false>(n, x, k, distances, labels, context);
     }
 }
 

data/vendor/faiss/faiss/IndexAdditiveQuantizerFastScan.h

@@ -62,7 +62,11 @@ struct IndexAdditiveQuantizerFastScan : IndexFastScan {
 
     void compute_codes(uint8_t* codes, idx_t n, const float* x) const override;
 
-    void compute_float_LUT(float* lut, idx_t n, const float* x) const override;
+    void compute_float_LUT(
+            float* lut,
+            idx_t n,
+            const float* x,
+            const FastScanDistancePostProcessing& context) const override;
 
     void search(
             idx_t n,

data/vendor/faiss/faiss/IndexBinary.h

@@ -49,10 +49,10 @@ struct IndexBinary {
     /** Perform training on a representative set of vectors.
      *
      * @param n      nb of training vectors
-     * @param x      training vecors, size n * d / 8
+     * @param x      training vectors, size n * d / 8
      */
     virtual void train(idx_t n, const uint8_t* x);
-    virtual void trainEx(idx_t n, const void* x, NumericType numeric_type) {
+    virtual void train_ex(idx_t n, const void* x, NumericType numeric_type) {
         if (numeric_type == NumericType::UInt8) {
             train(n, static_cast<const uint8_t*>(x));
         } else {
@@ -66,7 +66,7 @@ struct IndexBinary {
      * @param x      input matrix, size n * d / 8
      */
     virtual void add(idx_t n, const uint8_t* x) = 0;
-    virtual void addEx(idx_t n, const void* x, NumericType numeric_type) {
+    virtual void add_ex(idx_t n, const void* x, NumericType numeric_type) {
         if (numeric_type == NumericType::UInt8) {
             add(n, static_cast<const uint8_t*>(x));
         } else {
@@ -82,7 +82,7 @@ struct IndexBinary {
      * @param xids if non-null, ids to store for the vectors (size n)
      */
     virtual void add_with_ids(idx_t n, const uint8_t* x, const idx_t* xids);
-    virtual void add_with_idsEx(
+    virtual void add_with_ids_ex(
             idx_t n,
             const void* x,
             NumericType numeric_type,
@@ -111,7 +111,7 @@ struct IndexBinary {
             int32_t* distances,
             idx_t* labels,
             const SearchParameters* params = nullptr) const = 0;
-    virtual void searchEx(
+    virtual void search_ex(
             idx_t n,
             const void* x,
             NumericType numeric_type,
@@ -172,14 +172,14 @@ struct IndexBinary {
      *
      * This function may not be defined for some indexes.
      * @param key         id of the vector to reconstruct
-     * @param recons      reconstucted vector (size d / 8)
+     * @param recons      reconstructed vector (size d / 8)
      */
     virtual void reconstruct(idx_t key, uint8_t* recons) const;
 
     /** Reconstruct vectors i0 to i0 + ni - 1.
      *
      * This function may not be defined for some indexes.
-     * @param recons      reconstucted vectors (size ni * d / 8)
+     * @param recons      reconstructed vectors (size ni * d / 8)
      */
     virtual void reconstruct_n(idx_t i0, idx_t ni, uint8_t* recons) const;
 

data/vendor/faiss/faiss/IndexBinaryFromFloat.h

@@ -32,7 +32,7 @@ struct IndexBinaryFromFloat : IndexBinary {
 
     explicit IndexBinaryFromFloat(Index* index);
 
-    ~IndexBinaryFromFloat();
+    ~IndexBinaryFromFloat() override;
 
     void add(idx_t n, const uint8_t* x) override;
 

data/vendor/faiss/faiss/IndexBinaryHNSW.cpp

@@ -290,7 +290,9 @@ struct FlatHammingDis : DistanceComputer {
 
     ~FlatHammingDis() override {
 #pragma omp critical
-        { hnsw_stats.ndis += ndis; }
+        {
+            hnsw_stats.ndis += ndis;
+        }
     }
 };
 

data/vendor/faiss/faiss/IndexBinaryHNSW.h

@@ -36,7 +36,7 @@ struct IndexBinaryHNSW : IndexBinary {
 
     // When set to true, all neighbors in level 0 are filled up
     // to the maximum size allowed (2 * M). This option is used by
-    // IndexBinaryHHNSW to create a full base layer graph that is
+    // IndexBinaryHNSW to create a full base layer graph that is
     // used when GpuIndexBinaryCagra::copyFrom(IndexBinaryHNSW*) is called.
     bool keep_max_size_level0 = false;
 

data/vendor/faiss/faiss/IndexBinaryHash.cpp

@@ -177,8 +177,8 @@ void search_single_query_template(
 struct Run_search_single_query {
     using T = void;
     template <class HammingComputer, class... Types>
-    T f(Types... args) {
-        search_single_query_template<HammingComputer>(args...);
+    T f(Types*... args) {
+        search_single_query_template<HammingComputer>(*args...);
     }
 };
 
@@ -192,7 +192,7 @@ void search_single_query(
         size_t& ndis) {
     Run_search_single_query r;
     dispatch_HammingComputer(
-            index.code_size, r, index, q, res, n0, nlist, ndis);
+            index.code_size, r, &index, &q, &res, &n0, &nlist, &ndis);
 }
 
 } // anonymous namespace

data/vendor/faiss/faiss/IndexBinaryHash.h

@@ -66,10 +66,10 @@ struct IndexBinaryHash : IndexBinary {
 };
 
 struct IndexBinaryHashStats {
-    size_t nq;    // nb of queries run
-    size_t n0;    // nb of empty lists
-    size_t nlist; // nb of non-empty inverted lists scanned
-    size_t ndis;  // nb of distancs computed
+    size_t nq;     // nb of queries run
+    size_t n0;     // nb of empty lists
+    size_t nlist;  // nb of non-empty inverted lists scanned
+    size_t ndis{}; // nb of distances computed
 
     IndexBinaryHashStats() {
         reset();
@@ -99,7 +99,7 @@ struct IndexBinaryMultiHash : IndexBinary {
 
     IndexBinaryMultiHash();
 
-    ~IndexBinaryMultiHash();
+    ~IndexBinaryMultiHash() override;
 
     void reset() override;
 

data/vendor/faiss/faiss/IndexBinaryIVF.cpp

@@ -492,12 +492,13 @@ void search_knn_hamming_count(
 
     std::vector<HCounterState<HammingComputer>> cs;
     for (size_t i = 0; i < nx; ++i) {
-        cs.push_back(HCounterState<HammingComputer>(
-                all_counters.data() + i * nBuckets,
-                all_ids_per_dis.get() + i * nBuckets * k,
-                x + i * ivf->code_size,
-                ivf->d,
-                k));
+        cs.push_back(
+                HCounterState<HammingComputer>(
+                        all_counters.data() + i * nBuckets,
+                        all_ids_per_dis.get() + i * nBuckets * k,
+                        x + i * ivf->code_size,
+                        ivf->d,
+                        k));
     }
 
     size_t nlistv = 0, ndis = 0;