faiss 0.4.3 → 0.5.1

data/vendor/faiss/faiss/IndexRaBitQFastScan.h

@@ -0,0 +1,175 @@
+/*
+ * 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 <vector>
+
+#include <faiss/IndexFastScan.h>
+#include <faiss/IndexRaBitQ.h>
+#include <faiss/impl/RaBitQStats.h>
+#include <faiss/impl/RaBitQUtils.h>
+#include <faiss/impl/RaBitQuantizer.h>
+#include <faiss/impl/simd_result_handlers.h>
+#include <faiss/utils/Heap.h>
+#include <faiss/utils/simdlib.h>
+
+namespace faiss {
+
+// Import shared utilities from RaBitQUtils
+using rabitq_utils::ExtraBitsFactors;
+using rabitq_utils::QueryFactorsData;
+using rabitq_utils::SignBitFactors;
+using rabitq_utils::SignBitFactorsWithError;
+
+/** Fast-scan version of RaBitQ index that processes 32 database vectors at a
+ * time using SIMD operations. Similar to IndexPQFastScan but adapted for
+ * RaBitQ's bit-level quantization with factors.
+ *
+ * The key differences from IndexRaBitQ:
+ * - Processes vectors in batches of 32
+ * - Uses 4-bit groupings for SIMD optimization (4 dimensions per 4-bit unit)
+ * - Separates factors from quantized bits for efficient processing
+ * - Leverages existing PQ4 FastScan infrastructure where possible
+ */
+struct IndexRaBitQFastScan : IndexFastScan {
+    /// RaBitQ quantizer for encoding/decoding
+    RaBitQuantizer rabitq;
+
+    /// Center of all points (same as IndexRaBitQ)
+    std::vector<float> center;
+
+    /// Per-vector auxiliary data (1-bit codes stored separately in `codes`)
+    ///
+    /// 1-bit codes (sign bits) are stored in the inherited `codes` array from
+    /// IndexFastScan in packed FastScan format for SIMD processing.
+    ///
+    /// This flat_storage holds per-vector factors and refinement-bit codes:
+    /// Layout for 1-bit: [SignBitFactors (8 bytes)]
+    /// Layout for multi-bit: [SignBitFactorsWithError
+    /// (12B)][ref_codes][ExtraBitsFactors (8B)]
+    std::vector<uint8_t> flat_storage;
+
+    /// Default number of bits to quantize a query with
+    uint8_t qb = 8;
+
+    // quantize the query with a zero-centered scalar quantizer.
+    bool centered = false;
+
+    IndexRaBitQFastScan();
+
+    explicit IndexRaBitQFastScan(
+            idx_t d,
+            MetricType metric = METRIC_L2,
+            int bbs = 32,
+            uint8_t nb_bits = 1);
+
+    /// build from an existing IndexRaBitQ
+    explicit IndexRaBitQFastScan(const IndexRaBitQ& orig, int bbs = 32);
+
+    void train(idx_t n, const float* x) override;
+
+    void add(idx_t n, const float* x) override;
+
+    void compute_codes(uint8_t* codes, idx_t n, const float* x) const override;
+
+    /// Compute storage size per vector in flat_storage
+    size_t compute_per_vector_storage_size() const;
+
+    void compute_float_LUT(
+            float* lut,
+            idx_t n,
+            const float* x,
+            const FastScanDistancePostProcessing& context) const override;
+
+    void sa_decode(idx_t n, const uint8_t* bytes, float* x) const override;
+
+    void search(
+            idx_t n,
+            const float* x,
+            idx_t k,
+            float* distances,
+            idx_t* labels,
+            const SearchParameters* params = nullptr) const override;
+
+    /// Override to create RaBitQ-specific handlers
+    SIMDResultHandlerToFloat* make_knn_handler(
+            bool is_max,
+            int /*impl*/,
+            idx_t n,
+            idx_t k,
+            size_t /*ntotal*/,
+            float* distances,
+            idx_t* labels,
+            const IDSelector* sel,
+            const FastScanDistancePostProcessing& context) const override;
+};
+
+/** SIMD result handler for RaBitQ FastScan that applies distance corrections
+ * and maintains heaps directly during SIMD operations.
+ *
+ * This handler processes batches of 32 distance computations from SIMD kernels,
+ * applies RaBitQ-specific adjustments (factors and normalizers), and
+ * immediately updates result heaps without intermediate storage. This
+ * eliminates the need for post-processing and provides significant memory and
+ * performance benefits.
+ *
+ * Key optimizations:
+ * - Direct heap integration (no intermediate result storage)
+ * - Batch-level computation of normalizers and query factors
+ * - Preserves exact mathematical equivalence to original RaBitQ distances
+ * - Runtime boolean for multi-bit support
+ *
+ * @tparam C Comparator type (CMin/CMax) for heap operations
+ * @tparam with_id_map Whether to use id mapping (similar to HeapHandler)
+ */
+template <class C, bool with_id_map = false>
+struct RaBitQHeapHandler
+        : simd_result_handlers::ResultHandlerCompare<C, with_id_map> {
+    using RHC = simd_result_handlers::ResultHandlerCompare<C, with_id_map>;
+    using RHC::normalizers;
+
+    const IndexRaBitQFastScan* rabitq_index;
+    float* heap_distances; // [nq * k]
+    int64_t* heap_labels;  // [nq * k]
+    const size_t nq, k;
+    const FastScanDistancePostProcessing&
+            context;         // Processing context with query offset
+    const bool is_multi_bit; // Runtime flag for multi-bit mode
+
+    // Use float-based comparator for heap operations
+    using Cfloat = typename std::conditional<
+            C::is_max,
+            CMax<float, int64_t>,
+            CMin<float, int64_t>>::type;
+
+    RaBitQHeapHandler(
+            const IndexRaBitQFastScan* index,
+            size_t nq_val,
+            size_t k_val,
+            float* distances,
+            int64_t* labels,
+            const IDSelector* sel_in,
+            const FastScanDistancePostProcessing& context,
+            bool multi_bit);
+
+    void handle(size_t q, size_t b, simd16uint16 d0, simd16uint16 d1) override;
+
+    void begin(const float* norms);
+
+    void end();
+
+   private:
+    /// Compute full multi-bit distance for a candidate vector (multi-bit only)
+    float compute_full_multibit_distance(size_t db_idx, size_t q) const;
+
+    /// Compute lower bound using 1-bit distance and error bound (multi-bit
+    /// only)
+    float compute_lower_bound(float dist_1bit, size_t db_idx, size_t q) const;
+};
+
+} // namespace faiss

data/vendor/faiss/faiss/IndexRefine.cpp

@@ -341,4 +341,53 @@ void IndexRefineFlat::search(
     }
 }
 
+/***************************************************
+ * IndexRefinePanorama
+ ***************************************************/
+
+void IndexRefinePanorama::search(
+        idx_t n,
+        const float* x,
+        idx_t k,
+        float* distances,
+        idx_t* labels,
+        const SearchParameters* params_in) const {
+    const IndexRefineSearchParameters* params = nullptr;
+    if (params_in) {
+        params = dynamic_cast<const IndexRefineSearchParameters*>(params_in);
+        FAISS_THROW_IF_NOT_MSG(
+                params, "IndexRefineFlat params have incorrect type");
+    }
+
+    idx_t k_base = (params != nullptr) ? idx_t(k * params->k_factor)
+                                       : idx_t(k * k_factor);
+    SearchParameters* base_index_params =
+            (params != nullptr) ? params->base_index_params : nullptr;
+
+    FAISS_THROW_IF_NOT(k_base >= k);
+
+    FAISS_THROW_IF_NOT(base_index);
+    FAISS_THROW_IF_NOT(refine_index);
+
+    FAISS_THROW_IF_NOT(k > 0);
+    FAISS_THROW_IF_NOT(is_trained);
+
+    std::unique_ptr<idx_t[]> del1;
+    std::unique_ptr<float[]> del2;
+    idx_t* base_labels = new idx_t[n * k_base];
+    float* base_distances = new float[n * k_base];
+    del1.reset(base_labels);
+    del2.reset(base_distances);
+
+    base_index->search(
+            n, x, k_base, base_distances, base_labels, base_index_params);
+
+    for (int i = 0; i < n * k_base; i++) {
+        assert(base_labels[i] >= -1 && base_labels[i] < ntotal);
+    }
+
+    refine_index->search_subset(
+            n, x, k_base, base_labels, k, distances, labels);
+}
+
 } // namespace faiss

data/vendor/faiss/faiss/IndexRefine.h

@@ -95,4 +95,21 @@ struct IndexRefineFlat : IndexRefine {
             const SearchParameters* params = nullptr) const override;
 };
 
+/** Version where the search calls search_subset, allowing for Panorama
+ * refinement. */
+struct IndexRefinePanorama : IndexRefine {
+    explicit IndexRefinePanorama(Index* base_index, Index* refine_index)
+            : IndexRefine(base_index, refine_index) {}
+
+    IndexRefinePanorama() : IndexRefine() {}
+
+    void search(
+            idx_t n,
+            const float* x,
+            idx_t k,
+            float* distances,
+            idx_t* labels,
+            const SearchParameters* params = nullptr) const override;
+};
+
 } // namespace faiss

data/vendor/faiss/faiss/IndexShards.cpp

@@ -264,7 +264,7 @@ void IndexShardsTemplate<IndexT>::search(
     }
 }
 
-// explicit instanciations
+// explicit instantiations
 template struct IndexShardsTemplate<Index>;
 template struct IndexShardsTemplate<IndexBinary>;
 

data/vendor/faiss/faiss/MatrixStats.cpp

@@ -77,7 +77,7 @@ MatrixStats::MatrixStats(size_t n, size_t d, const float* x) : n(n), d(d) {
     if (d > 1024) {
         do_comment(
                 "indexing this many dimensions is hard, "
-                "please consider dimensionality reducution (with PCAMatrix)\n");
+                "please consider dimensionality reduction (with PCAMatrix)\n");
     }
 
     hash_value = hash_bytes((const uint8_t*)x, n * d * sizeof(*x));
@@ -125,7 +125,7 @@ MatrixStats::MatrixStats(size_t n, size_t d, const float* x) : n(n), d(d) {
         }
     }
 
-    // invalid vecor stats
+    // invalid vector stats
     if (n_valid == n) {
         do_comment("no NaN or Infs in data\n");
     } else {
@@ -229,7 +229,7 @@ MatrixStats::MatrixStats(size_t n, size_t d, const float* x) : n(n), d(d) {
         } else {
             do_comment(
                     "%zd dimensions are too large "
-                    "wrt. their variance, may loose precision "
+                    "wrt. their variance, may lose precision "
                     "in IndexFlatL2 (use CenteringTransform)\n",
                     n_dangerous_range);
         }

data/vendor/faiss/faiss/MetricType.h

@@ -35,7 +35,7 @@ enum MetricType {
 
     /// sum_i(min(a_i, b_i)) / sum_i(max(a_i, b_i)) where a_i, b_i > 0
     METRIC_Jaccard,
-    /// Squared Eucliden distance, ignoring NaNs
+    /// Squared Euclidean distance, ignoring NaNs
     METRIC_NaNEuclidean,
     /// Gower's distance - numeric dimensions are in [0,1] and categorical
     /// dimensions are negative integers

data/vendor/faiss/faiss/VectorTransform.h

@@ -37,7 +37,7 @@ struct VectorTransform {
      * nothing by default.
      *
      * @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);
 
@@ -249,7 +249,7 @@ struct OPQMatrix : LinearTransform {
     void train(idx_t n, const float* x) override;
 };
 
-/** remap dimensions for intput vectors, possibly inserting 0s
+/** remap dimensions for input vectors, possibly inserting 0s
  * strictly speaking this is also a linear transform but we don't want
  * to compute it with matrix multiplies */
 struct RemapDimensionsTransform : VectorTransform {

data/vendor/faiss/faiss/clone_index.cpp

@@ -23,6 +23,7 @@
 #include <faiss/IndexIVF.h>
 #include <faiss/IndexIVFAdditiveQuantizerFastScan.h>
 #include <faiss/IndexIVFFlat.h>
+#include <faiss/IndexIVFFlatPanorama.h>
 #include <faiss/IndexIVFPQ.h>
 #include <faiss/IndexIVFPQFastScan.h>
 #include <faiss/IndexIVFPQR.h>
@@ -97,6 +98,7 @@ IndexIVF* Cloner::clone_IndexIVF(const IndexIVF* ivf) {
 
     TRYCLONE(IndexIVFFlatDedup, ivf)
     TRYCLONE(IndexIVFFlat, ivf)
+    TRYCLONE(IndexIVFFlatPanorama, ivf)
 
     TRYCLONE(IndexIVFSpectralHash, ivf)
 
@@ -127,6 +129,7 @@ IndexIDMap* clone_IndexIDMap(const IndexIDMap* im) {
 
 IndexHNSW* clone_IndexHNSW(const IndexHNSW* ihnsw) {
     TRYCLONE(IndexHNSW2Level, ihnsw)
+    TRYCLONE(IndexHNSWFlatPanorama, ihnsw)
     TRYCLONE(IndexHNSWFlat, ihnsw)
     TRYCLONE(IndexHNSWPQ, ihnsw)
     TRYCLONE(IndexHNSWSQ, ihnsw)
@@ -152,7 +155,7 @@ IndexNSG* clone_IndexNSG(const IndexNSG* insg) {
     TRYCLONE(IndexNSGPQ, insg)
     TRYCLONE(IndexNSGSQ, insg)
     TRYCLONE(IndexNSG, insg) {
-        FAISS_THROW_MSG("clone not supported for this type of IndexNNDescent");
+        FAISS_THROW_MSG("clone not supported for this type of IndexNSG");
     }
 }
 
@@ -274,6 +277,7 @@ Index* Cloner::clone_Index(const Index* index) {
     // IndexFlat
     TRYCLONE(IndexFlat1D, index)
     TRYCLONE(IndexFlatL2, index)
+    TRYCLONE(IndexFlatL2Panorama, index)
     TRYCLONE(IndexFlatIP, index)
     TRYCLONE(IndexFlat, index)
 

data/vendor/faiss/faiss/gpu/GpuCloner.cpp

@@ -239,7 +239,7 @@ Index* ToGpuCloner::clone_Index(const Index* index) {
         config.device = device;
         GpuIndexCagra* res =
                 new GpuIndexCagra(provider, icg->d, icg->metric_type, config);
-        res->copyFromEx(icg, icg->get_numeric_type());
+        res->copyFrom_ex(icg, icg->get_numeric_type());
         return res;
     }
 #endif

data/vendor/faiss/faiss/gpu/GpuClonerOptions.h

@@ -21,8 +21,10 @@ struct GpuClonerOptions {
     /// is the coarse quantizer in float16?
     bool useFloat16CoarseQuantizer = false;
 
-    /// for GpuIndexIVFFlat, is storage in float16?
     /// for GpuIndexIVFPQ, are intermediate calculations in float16?
+    /// Note: for float16 storage, use GpuIndexIVFScalarQuantizer
+    /// or cuVS, not GpuIndexIVFFlat. useFloat16 will not affect
+    /// GpuIndexIVFFlat storage.
     bool useFloat16 = false;
 
     /// use precomputed tables?

data/vendor/faiss/faiss/gpu/GpuIndex.h

@@ -77,13 +77,13 @@ class GpuIndex : public faiss::Index {
     /// as needed
     /// Handles paged adds if the add set is too large; calls addInternal_
     void add(idx_t, const float* x) override;
-    void addEx(idx_t, const void* x, NumericType numeric_type) override;
+    void add_ex(idx_t, const void* x, NumericType numeric_type) override;
 
     /// `x` and `ids` can be resident on the CPU or any GPU; copies are
     /// performed as needed
     /// Handles paged adds if the add set is too large; calls addInternal_
     void add_with_ids(idx_t n, const float* x, const idx_t* ids) override;
-    void add_with_idsEx(
+    void add_with_ids_ex(
             idx_t n,
             const void* x,
             NumericType numeric_type,
@@ -103,7 +103,7 @@ class GpuIndex : public faiss::Index {
             float* distances,
             idx_t* labels,
             const SearchParameters* params = nullptr) const override;
-    void searchEx(
+    void search_ex(
             idx_t n,
             const void* x,
             NumericType numeric_type,
@@ -139,7 +139,7 @@ class GpuIndex : public faiss::Index {
    protected:
     /// Copy what we need from the CPU equivalent
     void copyFrom(const faiss::Index* index);
-    void copyFromEx(const faiss::Index* index, NumericType numeric_type) {
+    void copyFrom_ex(const faiss::Index* index, NumericType numeric_type) {
         if (numeric_type == NumericType::Float32) {
             copyFrom(index);
         } else {
@@ -149,7 +149,7 @@ class GpuIndex : public faiss::Index {
 
     /// Copy what we have to the CPU equivalent
     void copyTo(faiss::Index* index) const;
-    void copyToEx(faiss::Index* index, NumericType numeric_type) {
+    void copyTo_ex(faiss::Index* index, NumericType numeric_type) {
         if (numeric_type == NumericType::Float32) {
             copyTo(index);
         } else {
@@ -165,7 +165,7 @@ class GpuIndex : public faiss::Index {
     /// All data is guaranteed to be resident on our device
     virtual void addImpl_(idx_t n, const float* x, const idx_t* ids) = 0;
 
-    virtual void addImplEx_(
+    virtual void addImpl_ex_(
             idx_t n,
             const void* x,
             NumericType numeric_type,
@@ -187,7 +187,7 @@ class GpuIndex : public faiss::Index {
             idx_t* labels,
             const SearchParameters* params) const = 0;
 
-    virtual void searchImplEx_(
+    virtual void searchImpl_ex_(
             idx_t n,
             const void* x,
             NumericType numeric_type,
@@ -212,7 +212,7 @@ class GpuIndex : public faiss::Index {
     /// Handles paged adds if the add set is too large, passes to
     /// addImpl_ to actually perform the add for the current page
     void addPaged_(idx_t n, const float* x, const idx_t* ids);
-    void addPagedEx_(
+    void addPaged_ex_(
             idx_t n,
             const void* x,
             NumericType numeric_type,
@@ -220,7 +220,7 @@ class GpuIndex : public faiss::Index {
 
     /// Calls addImpl_ for a single page of GPU-resident data
     void addPage_(idx_t n, const float* x, const idx_t* ids);
-    void addPageEx_(
+    void addPage_ex_(
             idx_t n,
             const void* x,
             NumericType numeric_type,
@@ -235,7 +235,7 @@ class GpuIndex : public faiss::Index {
             idx_t* outIndicesData,
             const SearchParameters* params) const;
 
-    void searchNonPagedEx_(
+    void searchNonPaged_ex_(
             idx_t n,
             const void* x,
             NumericType numeric_type,
@@ -253,7 +253,7 @@ class GpuIndex : public faiss::Index {
             float* outDistancesData,
             idx_t* outIndicesData,
             const SearchParameters* params) const;
-    void searchFromCpuPagedEx_(
+    void searchFromCpuPaged_ex_(
             idx_t n,
             const void* x,
             NumericType numeric_type,

data/vendor/faiss/faiss/gpu/GpuIndexBinaryCagra.h

@@ -111,7 +111,7 @@ struct GpuIndexBinaryCagra : public IndexBinary {
             const SearchParameters* search_params) const;
 
    protected:
-    /// Manages streans, cuBLAS handles and scratch memory for devices
+    /// Manages streams, cuBLAS handles and scratch memory for devices
     std::shared_ptr<GpuResources> resources_;
 
     /// Configuration options

data/vendor/faiss/faiss/gpu/GpuIndexBinaryFlat.h

@@ -86,7 +86,7 @@ class GpuIndexBinaryFlat : public IndexBinary {
             idx_t* outIndicesData) const;
 
    protected:
-    /// Manages streans, cuBLAS handles and scratch memory for devices
+    /// Manages streams, cuBLAS handles and scratch memory for devices
     std::shared_ptr<GpuResources> resources_;
 
     /// Configuration options

data/vendor/faiss/faiss/gpu/GpuIndexCagra.h

@@ -99,7 +99,7 @@ struct IVFPQBuildCagraConfig {
     /// Note: if `dim` is not multiple of `pq_dim`, a random rotation is always
     /// applied to the input data and queries to transform the working space
     /// from `dim` to `rot_dim`, which may be slightly larger than the original
-    /// space and and is a multiple of `pq_dim` (`rot_dim % pq_dim == 0`).
+    /// space and is a multiple of `pq_dim` (`rot_dim % pq_dim == 0`).
     /// However, this transform is not necessary when `dim` is multiple of
     /// `pq_dim`
     ///   (`dim == rot_dim`, hence no need in adding "extra" data columns /
@@ -135,7 +135,7 @@ struct IVFPQSearchCagraConfig {
     ///
     /// The use of low-precision types reduces the amount of shared memory
     /// required at search time, so fast shared memory kernels can be used even
-    /// for datasets with large dimansionality. Note that the recall is slightly
+    /// for datasets with large dimensionality. Note that the recall is slightly
     /// degraded when low-precision type is selected.
 
     cudaDataType_t lut_dtype = CUDA_R_32F;
@@ -166,6 +166,10 @@ struct IVFPQSearchCagraConfig {
     /// negative effects on the search performance if tweaked incorrectly.
 
     double preferred_shmem_carveout = 1.0;
+
+    /// Set the internal batch size to improve GPU utilization at the cost of
+    /// larger memory footprint.
+    uint32_t max_internal_batch_size = 4096;
 };
 
 struct GpuIndexCagraConfig : public GpuIndexConfig {
@@ -258,7 +262,7 @@ struct GpuIndexCagra : public GpuIndex {
     /// the base dataset. Use this function when you want to add vectors with
     /// ids. Ref: https://github.com/facebookresearch/faiss/issues/4107
     void add(idx_t n, const float* x) override;
-    void addEx(idx_t n, const void* x, NumericType numeric_type) override;
+    void add_ex(idx_t n, const void* x, NumericType numeric_type) override;
 
     /// Trains CAGRA based on the given vector data.
     /// NB: The use of the train function here is to build the CAGRA graph on
@@ -266,12 +270,12 @@ struct GpuIndexCagra : public GpuIndex {
     /// of vectors (without IDs) to the index. There is no external quantizer to
     /// be trained here.
     void train(idx_t n, const float* x) override;
-    void trainEx(idx_t n, const void* x, NumericType numeric_type) override;
+    void train_ex(idx_t n, const void* x, NumericType numeric_type) override;
 
     /// Initialize ourselves from the given CPU index; will overwrite
     /// all data in ourselves
     void copyFrom(const faiss::IndexHNSWCagra* index);
-    void copyFromEx(
+    void copyFrom_ex(
             const faiss::IndexHNSWCagra* index,
             NumericType numeric_type);
 
@@ -289,7 +293,7 @@ struct GpuIndexCagra : public GpuIndex {
     bool addImplRequiresIDs_() const override;
 
     void addImpl_(idx_t n, const float* x, const idx_t* ids) override;
-    void addImplEx_(
+    void addImpl_ex_(
             idx_t n,
             const void* x,
             NumericType numeric_type,
@@ -303,7 +307,7 @@ struct GpuIndexCagra : public GpuIndex {
             float* distances,
             idx_t* labels,
             const SearchParameters* search_params) const override;
-    void searchImplEx_(
+    void searchImpl_ex_(
             idx_t n,
             const void* x,
             NumericType numeric_type,

data/vendor/faiss/faiss/gpu/StandardGpuResources.cpp

@@ -700,7 +700,7 @@ StandardGpuResourcesImpl::getMemoryInfo() const {
 //
 
 StandardGpuResources::StandardGpuResources()
-        : res_(new StandardGpuResourcesImpl) {}
+        : res_(std::make_shared<StandardGpuResourcesImpl>()) {}
 
 StandardGpuResources::~StandardGpuResources() = default;
 

data/vendor/faiss/faiss/gpu/perf/IndexWrapper-inl.h

@@ -5,6 +5,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#pragma once
+
 #include <faiss/impl/FaissAssert.h>
 
 namespace faiss {

data/vendor/faiss/faiss/gpu/test/TestGpuIcmEncoder.cpp

@@ -1,3 +1,10 @@
+/*
+ * 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/gpu/GpuIcmEncoder.h>
 #include <faiss/gpu/StandardGpuResources.h>
 #include <faiss/gpu/test/TestUtils.h>

data/vendor/faiss/faiss/gpu/test/TestGpuIndexIVFFlat.cpp

@@ -493,7 +493,7 @@ TEST(TestGpuIndexIVFFlat, Float32_negative) {
     // Construct a positive test set
     auto queryVecs = faiss::gpu::randVecs(opt.numQuery, opt.dim);
 
-    // Put all vecs on positive size
+    // Put all vecs on positive side
     for (auto& f : queryVecs) {
         f = std::abs(f);
     }

data/vendor/faiss/faiss/impl/AdditiveQuantizer.cpp

@@ -404,7 +404,7 @@ void AdditiveQuantizer::compute_LUT(
 namespace {
 
 /* compute inner products of one query with all centroids, given a look-up
- * table of all inner producst with codebook entries */
+ * table of all inner products with codebook entries */
 void compute_inner_prod_with_LUT(
         const AdditiveQuantizer& aq,
         const float* LUT,

data/vendor/faiss/faiss/impl/AdditiveQuantizer.h

@@ -212,7 +212,7 @@ struct AdditiveQuantizer : Quantizer {
             idx_t* labels,
             const float* centroid_norms) const;
 
-    virtual ~AdditiveQuantizer();
+    virtual ~AdditiveQuantizer() override;
 };
 
 } // namespace faiss

data/vendor/faiss/faiss/impl/AuxIndexStructures.cpp

@@ -36,7 +36,7 @@ RangeSearchResult::RangeSearchResult(size_t nq, bool alloc_lims) : nq(nq) {
 /// for each query
 void RangeSearchResult::do_allocation() {
     // works only if all the partial results are aggregated
-    // simulatenously
+    // simultaneously
     FAISS_THROW_IF_NOT(labels == nullptr && distances == nullptr);
     size_t ofs = 0;
     for (int i = 0; i < nq; i++) {
@@ -86,7 +86,7 @@ void BufferList::append_buffer() {
     wp = 0;
 }
 
-/// copy elemnts ofs:ofs+n-1 seen as linear data in the buffers to
+/// copy elements ofs:ofs+n-1 seen as linear data in the buffers to
 /// tables dest_ids, dest_dis
 void BufferList::copy_range(
         size_t ofs,

data/vendor/faiss/faiss/impl/AuxIndexStructures.h

@@ -80,7 +80,7 @@ struct BufferList {
     /// add one result, possibly appending a new buffer if needed
     void add(idx_t id, float dis);
 
-    /// copy elemnts ofs:ofs+n-1 seen as linear data in the buffers to
+    /// copy elements ofs:ofs+n-1 seen as linear data in the buffers to
     /// tables dest_ids, dest_dis
     void copy_range(size_t ofs, size_t n, idx_t* dest_ids, float* dest_dis);
 };