faiss 0.6.2 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f9b24e9b85c954d799a4c19009626bcd90b5071a0b05136a182030920150b5a
-  data.tar.gz: 1fe65e3ee60d8f77471b8dc6dc77354d7d7f9e7a81a4c12be909ca3ac75fcea1
+  metadata.gz: 0ab0ef0079ca7056c6d303b95882757645a81bee9b4c13862f4337dbec1b105a
+  data.tar.gz: d61339d723153ed333a6719001de98fa1742606334684b0f7db26f26ad001b09
 SHA512:
-  metadata.gz: 277f548905897091a697479e256a79d2e2f9c56647be54921ea5fd6caec6381966dd859b58cdc0d09fb9da5670ef9a7248dd5ba487e50eef58f315e96d952986
-  data.tar.gz: 3a837ec44d583d6256f3490da8c6e17eec7e2a3854f4721826f6d03c4949e95163f6d67c70d7626d1b520a4b406fee9a3449b3d8fc7fbdd29fe5ff78dffd2e99
+  metadata.gz: 20ce33982905751c82f05241b94ca500b241ac15f18245e8e14dad29d2fe5f162c7d4fe4e5441e92f79e06eb9519538831fa2c857050e6b3ea8ad5d0b8e63366
+  data.tar.gz: cfd073d25d3067488fdde88e06c5c68eeec6840ea57b9e6222129f4594279a27148b62361bcbd0dcc57727053acd35e4f202558adef03de648d0c8179f05ce07

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.6.3 (2026-08-03)
+
+- Updated Faiss to 1.15.0
+
 ## 0.6.2 (2026-06-13)
 
 - Updated Faiss to 1.14.3

data/lib/faiss/version.rb

@@ -1,3 +1,3 @@
 module Faiss
-  VERSION = "0.6.2"
+  VERSION = "0.6.3"
 end

data/vendor/faiss/faiss/AutoTune.cpp

@@ -45,6 +45,8 @@ void AutoTuneCriterion::set_groundtruth(
         gt_D.resize(nq * gt_nnn_in);
         memcpy(gt_D.data(), gt_D_in, sizeof(gt_D[0]) * nq * gt_nnn_in);
     }
+    FAISS_THROW_IF_NOT_MSG(
+            gt_I_in != nullptr, "set_groundtruth: gt_I must be non-null");
     gt_I.resize(nq * gt_nnn_in);
     memcpy(gt_I.data(), gt_I_in, sizeof(gt_I[0]) * nq * gt_nnn_in);
 }
@@ -148,7 +150,7 @@ bool OperatingPoints::add(
     }
     // remove non-optimal points from array
     for (size_t i = a.size() - 1; i > 0; --i) {
-        if (a[i].t < a[i - 1].t) {
+        if (a[i].t <= a[i - 1].t) {
             a.erase(a.begin() + (i - 1));
         }
     }

data/vendor/faiss/faiss/Clustering.cpp

@@ -367,7 +367,7 @@ void Clustering::train_encoded(
                         ? std::numeric_limits<double>::max()
                         : std::abs(prev_obj - obj) / std::abs(prev_obj);
 
-                if (change >= 0 && change <= early_stop_threshold) {
+                if (change <= early_stop_threshold) {
                     if (verbose) {
                         printf("\n  Converged at iteration %d: "
                                "objective did not change\n",
@@ -439,6 +439,14 @@ float kmeans_clustering(
         size_t k,
         const float* x,
         float* centroids) {
+    FAISS_THROW_IF_NOT_FMT(
+            d <= static_cast<size_t>(std::numeric_limits<int>::max()),
+            "kmeans_clustering: d=%zu exceeds INT_MAX",
+            d);
+    FAISS_THROW_IF_NOT_FMT(
+            k <= static_cast<size_t>(std::numeric_limits<int>::max()),
+            "kmeans_clustering: k=%zu exceeds INT_MAX",
+            k);
     Clustering clus(static_cast<int>(d), static_cast<int>(k));
     clus.verbose = d * n * k > (size_t(1) << 30);
     // display logs if > 1Gflop per iteration

data/vendor/faiss/faiss/IVFlib.cpp

@@ -592,8 +592,12 @@ void handle_ivf(
                 static_cast<faiss::IndexIVF*>(faiss::clone_index(clone));
         if (generate_ids) {
             // Assume the quantizer does not natively support add_with_ids.
-            sharded_index->quantizer =
-                    new IndexIDMap2(sharded_index->quantizer);
+            // The IDMap wraps the cloned quantizer; own_fields makes it delete
+            // that quantizer when sharded_index (which owns the IDMap) is
+            // freed.
+            auto* id_quantizer = new IndexIDMap2(sharded_index->quantizer);
+            id_quantizer->own_fields = true;
+            sharded_index->quantizer = id_quantizer;
             sharded_index->quantizer->add_with_ids(
                     sharded_centroids[i].size() / index->quantizer->d,
                     sharded_centroids[i].data(),
@@ -615,6 +619,7 @@ void handle_ivf(
         faiss::write_index(sharded_index, fname);
         delete sharded_index;
     }
+    delete clone;
 }
 
 void handle_binary_ivf(
@@ -650,8 +655,13 @@ void handle_binary_ivf(
                 faiss::clone_binary_index(clone));
         if (generate_ids) {
             // Assume the quantizer does not natively support add_with_ids.
-            sharded_index->quantizer =
+            // The IDMap wraps the cloned quantizer; own_fields makes it delete
+            // that quantizer when sharded_index (which owns the IDMap) is
+            // freed.
+            auto* id_quantizer =
                     new IndexBinaryIDMap2(sharded_index->quantizer);
+            id_quantizer->own_fields = true;
+            sharded_index->quantizer = id_quantizer;
             sharded_index->quantizer->add_with_ids(
                     sharded_centroids[i].size() / reconstruction_size,
                     sharded_centroids[i].data(),
@@ -673,6 +683,7 @@ void handle_binary_ivf(
         faiss::write_index_binary(sharded_index, fname);
         delete sharded_index;
     }
+    delete clone;
 }
 
 template <typename IndexType>

data/vendor/faiss/faiss/Index.h

@@ -16,8 +16,8 @@
 #include <cstdio>
 
 #define FAISS_VERSION_MAJOR 1
-#define FAISS_VERSION_MINOR 14
-#define FAISS_VERSION_PATCH 3
+#define FAISS_VERSION_MINOR 15
+#define FAISS_VERSION_PATCH 0
 
 // Macro to combine the version components into a single string
 #ifndef FAISS_STRINGIFY

data/vendor/faiss/faiss/IndexAdditiveQuantizer.cpp

@@ -58,8 +58,8 @@ struct AQDistanceComputerDecompress : FlatCodesDistanceComputer {
     }
 
     float symmetric_dis(idx_t i, idx_t j) final {
-        aq.decode(codes + i * d, tmp.data(), 1);
-        aq.decode(codes + j * d, tmp.data() + d, 1);
+        aq.decode(codes + i * code_size, tmp.data(), 1);
+        aq.decode(codes + j * code_size, tmp.data() + d, 1);
         return vd(tmp.data(), tmp.data() + d);
     }
 
@@ -79,7 +79,8 @@ struct AQDistanceComputerLUT : FlatCodesDistanceComputer {
 
     explicit AQDistanceComputerLUT(const IndexAdditiveQuantizer& iaq)
             : FlatCodesDistanceComputer(iaq.codes.data(), iaq.code_size),
-              LUT(iaq.aq->total_codebook_size + iaq.d * 2),
+              LUT(iaq.aq->total_codebook_size // Storage for LUT.
+                  + size_t(iaq.d) * 2), // tmp storage for symmetric distance.
               aq(*iaq.aq),
               d(iaq.d) {}
 
@@ -96,9 +97,9 @@ struct AQDistanceComputerLUT : FlatCodesDistanceComputer {
     }
 
     float symmetric_dis(idx_t i, idx_t j) final {
-        float* tmp = LUT.data();
-        aq.decode(codes + i * d, tmp, 1);
-        aq.decode(codes + j * d, tmp + d, 1);
+        float* tmp = LUT.data() + aq.total_codebook_size;
+        aq.decode(codes + i * code_size, tmp, 1);
+        aq.decode(codes + j * code_size, tmp + d, 1);
         return fvec_L2sqr(tmp, tmp + d, d);
     }
 
@@ -234,8 +235,7 @@ void IndexAdditiveQuantizer::search(
         float* distances,
         idx_t* labels,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+    FAISS_THROW_IF_MSG(params, "search params not supported for this index");
 
     if (aq->search_type == AdditiveQuantizer::ST_decompress) {
         with_VectorDistance(d, metric_type, metric_arg, [&](auto vd) {
@@ -458,8 +458,7 @@ void AdditiveCoarseQuantizer::search(
         float* distances,
         idx_t* labels,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+    FAISS_THROW_IF_MSG(params, "search params not supported for this index");
 
     if (metric_type == METRIC_INNER_PRODUCT) {
         aq->knn_centroids_inner_product(n, x, k, distances, labels);

data/vendor/faiss/faiss/IndexAdditiveQuantizerFastScan.cpp

@@ -36,7 +36,7 @@ void IndexAdditiveQuantizerFastScan::init(
         MetricType metric,
         int bbs_) {
     FAISS_THROW_IF_NOT(aq_init != nullptr);
-    FAISS_THROW_IF_NOT(!aq_init->nbits.empty());
+    FAISS_THROW_IF_MSG(aq_init->nbits.empty(), "nbits must not be empty");
     FAISS_THROW_IF_NOT(aq_init->nbits[0] == 4);
     if (metric == METRIC_INNER_PRODUCT) {
         FAISS_THROW_IF_NOT_MSG(
@@ -192,8 +192,7 @@ void IndexAdditiveQuantizerFastScan::search(
         float* distances,
         idx_t* labels,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+    FAISS_THROW_IF_MSG(params, "search params not supported for this index");
     FAISS_THROW_IF_NOT(k > 0);
     bool rescale = (rescale_norm && norm_scale > 1 && metric_type == METRIC_L2);
     if (!rescale) {

data/vendor/faiss/faiss/IndexBinaryFromFloat.cpp

@@ -55,8 +55,7 @@ void IndexBinaryFromFloat::search(
         int32_t* distances,
         idx_t* labels,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+    FAISS_THROW_IF_MSG(params, "search params not supported for this index");
     FAISS_THROW_IF_NOT(k > 0);
 
     constexpr idx_t bs = 32768;

data/vendor/faiss/faiss/IndexBinaryHNSW.cpp

@@ -24,7 +24,6 @@
 #include <faiss/impl/ResultHandler.h>
 #include <faiss/impl/VisitedTable.h>
 #include <faiss/utils/Heap.h>
-#include <faiss/utils/hamming.h>
 #include <faiss/utils/random.h>
 
 #include <faiss/impl/simd_dispatch.h>
@@ -293,8 +292,8 @@ void IndexBinaryHNSW::reconstruct(idx_t key, uint8_t* recons) const {
 
 DistanceComputer* IndexBinaryHNSW::get_distance_computer() const {
     IndexBinaryFlat* flat_storage = dynamic_cast<IndexBinaryFlat*>(storage);
-    FAISS_THROW_IF_NOT_MSG(
-            flat_storage != nullptr,
+    FAISS_THROW_IF_MSG(
+            flat_storage == nullptr,
             "IndexBinaryHNSW requires IndexBinaryFlat storage");
     return with_simd_level([&]<SIMDLevel SL>() {
         return make_binary_hnsw_distance_computer_fixSL<SL>(
@@ -317,8 +316,8 @@ IndexBinaryHNSWCagra::IndexBinaryHNSWCagra(int d_, int M)
 }
 
 void IndexBinaryHNSWCagra::add(idx_t n, const uint8_t* x) {
-    FAISS_THROW_IF_NOT_MSG(
-            !base_level_only,
+    FAISS_THROW_IF_MSG(
+            base_level_only,
             "Cannot add vectors when base_level_only is set to True");
 
     IndexBinaryHNSW::add(n, x);

data/vendor/faiss/faiss/IndexBinaryHash.cpp

@@ -27,7 +27,7 @@
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 // NOLINTNEXTLINE(facebook-hte-InlineHeader)
 #include <faiss/impl/binary_hamming/IndexBinaryHash_impl.h>
-#include <faiss/utils/hamming_distance/hamming_computer-generic.h>
+#include <faiss/utils/hamming_distance/hamming_computer-generic.h> // IWYU pragma: keep
 #undef THE_SIMD_LEVEL
 
 namespace faiss {
@@ -83,8 +83,7 @@ void IndexBinaryHash::range_search(
         int radius,
         RangeSearchResult* result,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+    FAISS_THROW_IF_MSG(params, "search params not supported for this index");
     size_t nlist = 0, ndis = 0, n0 = 0;
 
 #pragma omp parallel if (n > 100) reduction(+ : ndis, n0, nlist)
@@ -116,8 +115,7 @@ void IndexBinaryHash::search(
         int32_t* distances,
         idx_t* labels,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+    FAISS_THROW_IF_MSG(params, "search params not supported for this index");
     FAISS_THROW_IF_NOT(k > 0);
 
     using HeapForL2 = CMax<int32_t, idx_t>;
@@ -216,8 +214,7 @@ void IndexBinaryMultiHash::range_search(
         int radius,
         RangeSearchResult* result,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+    FAISS_THROW_IF_MSG(params, "search params not supported for this index");
     size_t nlist = 0, ndis = 0, n0 = 0;
 
 #pragma omp parallel if (n > 100) reduction(+ : ndis, n0, nlist)
@@ -249,8 +246,7 @@ void IndexBinaryMultiHash::search(
         int32_t* distances,
         idx_t* labels,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+    FAISS_THROW_IF_MSG(params, "search params not supported for this index");
     FAISS_THROW_IF_NOT(k > 0);
 
     using HeapForL2 = CMax<int32_t, idx_t>;

data/vendor/faiss/faiss/IndexBinaryIVF.cpp

@@ -206,8 +206,7 @@ void IndexBinaryIVF::search_and_reconstruct(
         idx_t* __restrict labels,
         uint8_t* __restrict recons,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+    FAISS_THROW_IF_MSG(params, "search params not supported for this index");
     const size_t nprobe_2 = std::min(nlist, this->nprobe);
     FAISS_THROW_IF_NOT(k > 0);
     FAISS_THROW_IF_NOT(nprobe_2 > 0);
@@ -524,8 +523,7 @@ void IndexBinaryIVF::range_search(
         int radius,
         RangeSearchResult* __restrict res,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+    FAISS_THROW_IF_MSG(params, "search params not supported for this index");
     const size_t nprobe_2 = std::min(nlist, this->nprobe);
     std::unique_ptr<idx_t[]> idx(new idx_t[n * nprobe_2]);
     std::unique_ptr<int32_t[]> coarse_dis(new int32_t[n * nprobe_2]);

data/vendor/faiss/faiss/IndexEDEN.cpp

@@ -0,0 +1,273 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <faiss/IndexEDEN.h>
+
+#include <faiss/impl/FaissAssert.h>
+#include <faiss/impl/ResultHandler.h>
+#include <memory>
+
+namespace faiss {
+
+IndexEDEN::IndexEDEN() = default;
+
+IndexEDEN::IndexEDEN(
+        idx_t d_in,
+        MetricType metric,
+        uint8_t nb_bits_in,
+        EDENScaleType scale_type_in)
+        : IndexFlatCodes(0, d_in, metric),
+          sq(d_in, eden_utils::quantizer_type_for_bits(nb_bits_in)),
+          scale_type(scale_type_in) {
+    FAISS_THROW_IF_NOT_MSG(
+            scale_type == EDENScaleType_UNBIASED ||
+                    scale_type == EDENScaleType_BIASED,
+            "invalid EDEN scale type");
+    sq.train(0, nullptr);
+    code_size = eden_utils::code_size(d, sq.bits);
+    is_trained = false;
+}
+
+void IndexEDEN::train(idx_t n, const float* x) {
+    std::vector<float> centroid(d, 0.0f);
+    for (idx_t i = 0; i < n; i++) {
+        for (size_t j = 0; j < static_cast<size_t>(d); j++) {
+            centroid[j] += x[i * d + j];
+        }
+    }
+
+    if (n != 0) {
+        for (size_t j = 0; j < static_cast<size_t>(d); j++) {
+            centroid[j] /= static_cast<float>(n);
+        }
+    }
+
+    center = std::move(centroid);
+    sq.train(n, x);
+    is_trained = true;
+}
+
+void IndexEDEN::sa_encode(idx_t n, const float* x, uint8_t* bytes) const {
+    FAISS_THROW_IF_NOT(is_trained);
+    eden_utils::compute_codes(
+            sq, metric_type, scale_type, x, bytes, n, center.data());
+}
+
+void IndexEDEN::sa_decode(idx_t n, const uint8_t* bytes, float* x) const {
+    FAISS_THROW_IF_NOT(is_trained);
+    eden_utils::decode(sq, bytes, x, n, center.data());
+}
+
+FlatCodesDistanceComputer* IndexEDEN::get_FlatCodesDistanceComputer() const {
+    FlatCodesDistanceComputer* dc =
+            eden_utils::get_distance_computer(sq, metric_type, center.data());
+    dc->code_size = code_size;
+    dc->codes = codes.data();
+    return dc;
+}
+
+namespace {
+
+bool use_eden_batch_scan(size_t d, size_t nb_bits) {
+    const size_t values_per_byte = 8 / nb_bits;
+    const size_t num_bytes = (d + values_per_byte - 1) / values_per_byte;
+    if (nb_bits == 1) {
+        return num_bytes >= 32;
+    }
+    if (nb_bits == 2) {
+        return num_bytes >= 16;
+    }
+    if (nb_bits == 4) {
+        return num_bytes >= 128;
+    }
+    return false;
+}
+
+struct Run_search_with_eden_dc {
+    using T = void;
+
+    template <class BlockResultHandler>
+    void f(BlockResultHandler& res, const IndexEDEN* index, const float* xq) {
+        const size_t ntotal = index->ntotal;
+        using SingleResultHandler =
+                typename BlockResultHandler::SingleResultHandler;
+        const int d = index->d;
+        const bool use_batch_scan = use_eden_batch_scan(d, index->sq.bits);
+
+#pragma omp parallel
+        {
+            std::unique_ptr<EDENFlatCodesDistanceComputer> dc(
+                    eden_utils::get_distance_computer(
+                            index->sq,
+                            index->metric_type,
+                            index->center.data()));
+            dc->code_size = index->code_size;
+            dc->codes = index->codes.data();
+            SingleResultHandler resi(res);
+
+#pragma omp for
+            for (int64_t q = 0; q < static_cast<int64_t>(res.nq); q++) {
+                resi.begin(q);
+                dc->set_query(xq + d * q);
+
+                if (use_batch_scan) {
+                    size_t i = 0;
+                    for (; i + 16 <= ntotal; i += 16) {
+                        bool keep[16];
+                        bool keep_all = true;
+                        for (size_t j = 0; j < 16; j++) {
+                            keep[j] = res.is_in_selection(i + j);
+                            keep_all &= keep[j];
+                        }
+
+                        if (keep_all) {
+                            float dis[16];
+                            dc->consecutive_distances_batch_16(i, dis);
+                            for (size_t j = 0; j < 16; j++) {
+                                resi.add_result(dis[j], i + j);
+                            }
+                        } else {
+                            for (size_t j = 0; j < 16; j++) {
+                                if (keep[j]) {
+                                    resi.add_result((*dc)(i + j), i + j);
+                                }
+                            }
+                        }
+                    }
+                    for (; i + 8 <= ntotal; i += 8) {
+                        const bool keep0 = res.is_in_selection(i);
+                        const bool keep1 = res.is_in_selection(i + 1);
+                        const bool keep2 = res.is_in_selection(i + 2);
+                        const bool keep3 = res.is_in_selection(i + 3);
+                        const bool keep4 = res.is_in_selection(i + 4);
+                        const bool keep5 = res.is_in_selection(i + 5);
+                        const bool keep6 = res.is_in_selection(i + 6);
+                        const bool keep7 = res.is_in_selection(i + 7);
+                        if (keep0 && keep1 && keep2 && keep3 && keep4 &&
+                            keep5 && keep6 && keep7) {
+                            float dis[8];
+                            dc->consecutive_distances_batch_8(i, dis);
+                            resi.add_result(dis[0], i);
+                            resi.add_result(dis[1], i + 1);
+                            resi.add_result(dis[2], i + 2);
+                            resi.add_result(dis[3], i + 3);
+                            resi.add_result(dis[4], i + 4);
+                            resi.add_result(dis[5], i + 5);
+                            resi.add_result(dis[6], i + 6);
+                            resi.add_result(dis[7], i + 7);
+                        } else {
+                            if (keep0) {
+                                resi.add_result((*dc)(i), i);
+                            }
+                            if (keep1) {
+                                resi.add_result((*dc)(i + 1), i + 1);
+                            }
+                            if (keep2) {
+                                resi.add_result((*dc)(i + 2), i + 2);
+                            }
+                            if (keep3) {
+                                resi.add_result((*dc)(i + 3), i + 3);
+                            }
+                            if (keep4) {
+                                resi.add_result((*dc)(i + 4), i + 4);
+                            }
+                            if (keep5) {
+                                resi.add_result((*dc)(i + 5), i + 5);
+                            }
+                            if (keep6) {
+                                resi.add_result((*dc)(i + 6), i + 6);
+                            }
+                            if (keep7) {
+                                resi.add_result((*dc)(i + 7), i + 7);
+                            }
+                        }
+                    }
+                    for (; i + 4 <= ntotal; i += 4) {
+                        const bool keep0 = res.is_in_selection(i);
+                        const bool keep1 = res.is_in_selection(i + 1);
+                        const bool keep2 = res.is_in_selection(i + 2);
+                        const bool keep3 = res.is_in_selection(i + 3);
+                        if (keep0 && keep1 && keep2 && keep3) {
+                            float dis0;
+                            float dis1;
+                            float dis2;
+                            float dis3;
+                            dc->distances_batch_4(
+                                    i,
+                                    i + 1,
+                                    i + 2,
+                                    i + 3,
+                                    dis0,
+                                    dis1,
+                                    dis2,
+                                    dis3);
+                            resi.add_result(dis0, i);
+                            resi.add_result(dis1, i + 1);
+                            resi.add_result(dis2, i + 2);
+                            resi.add_result(dis3, i + 3);
+                        } else {
+                            if (keep0) {
+                                resi.add_result((*dc)(i), i);
+                            }
+                            if (keep1) {
+                                resi.add_result((*dc)(i + 1), i + 1);
+                            }
+                            if (keep2) {
+                                resi.add_result((*dc)(i + 2), i + 2);
+                            }
+                            if (keep3) {
+                                resi.add_result((*dc)(i + 3), i + 3);
+                            }
+                        }
+                    }
+                    for (; i < ntotal; i++) {
+                        if (res.is_in_selection(i)) {
+                            resi.add_result((*dc)(i), i);
+                        }
+                    }
+                } else {
+                    for (size_t i = 0; i < ntotal; i++) {
+                        if (res.is_in_selection(i)) {
+                            resi.add_result((*dc)(i), i);
+                        }
+                    }
+                }
+
+                resi.end();
+            }
+        }
+    }
+};
+
+} // namespace
+
+void IndexEDEN::search(
+        idx_t n,
+        const float* x,
+        idx_t k,
+        float* distances,
+        idx_t* labels,
+        const SearchParameters* params) const {
+    FAISS_THROW_IF_NOT(is_trained);
+    const IDSelector* sel = params != nullptr ? params->sel : nullptr;
+    Run_search_with_eden_dc r;
+    dispatch_knn_ResultHandler(
+            n, distances, labels, k, metric_type, sel, r, this, x);
+}
+
+void IndexEDEN::range_search(
+        idx_t /*n*/,
+        const float* x,
+        float radius,
+        RangeSearchResult* result,
+        const SearchParameters* params) const {
+    const IDSelector* sel = params != nullptr ? params->sel : nullptr;
+    Run_search_with_eden_dc r;
+    dispatch_range_ResultHandler(result, radius, metric_type, sel, r, this, x);
+}
+
+} // namespace faiss

data/vendor/faiss/faiss/IndexEDEN.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <faiss/IndexFlatCodes.h>
+#include <faiss/impl/EDENQuantizer.h>
+
+namespace faiss {
+
+struct IndexEDEN : IndexFlatCodes {
+    ScalarQuantizer sq;
+    EDENScaleType scale_type = EDENScaleType_UNBIASED;
+
+    // Center of all training points. Random rotation, if desired, is expected
+    // to be supplied externally via IndexPreTransform.
+    std::vector<float> center;
+
+    IndexEDEN();
+
+    // Factory strings: EDEN, EDEN<n>, EDENBIASED, EDEN<n>BIASED.
+    // <n> is the Lloyd-Max bit budget, 1..8. The default is EDEN's original
+    // unbiased scale; the BIASED suffix selects the MSE-minimizing scale.
+    explicit IndexEDEN(
+            idx_t d,
+            MetricType metric = METRIC_L2,
+            uint8_t nb_bits = 1,
+            EDENScaleType scale_type = EDENScaleType_UNBIASED);
+
+    void train(idx_t n, const float* x) override;
+
+    void sa_encode(idx_t n, const float* x, uint8_t* bytes) const override;
+    void sa_decode(idx_t n, const uint8_t* bytes, float* x) const override;
+
+    FlatCodesDistanceComputer* get_FlatCodesDistanceComputer() const override;
+
+    void search(
+            idx_t n,
+            const float* x,
+            idx_t k,
+            float* distances,
+            idx_t* labels,
+            const SearchParameters* params = nullptr) const override;
+
+    void range_search(
+            idx_t n,
+            const float* x,
+            float radius,
+            RangeSearchResult* result,
+            const SearchParameters* params = nullptr) const override;
+};
+
+} // namespace faiss