faiss 0.4.3 → 0.5.1

data/vendor/faiss/faiss/impl/IDSelector.h

@@ -116,7 +116,7 @@ struct IDSelectorBitmap : IDSelector {
 /** reverts the membership test of another selector */
 struct IDSelectorNot : IDSelector {
     const IDSelector* sel;
-    IDSelectorNot(const IDSelector* sel) : sel(sel) {}
+    explicit IDSelectorNot(const IDSelector* sel) : sel(sel) {}
     bool is_member(idx_t id) const final {
         return !sel->is_member(id);
     }
@@ -131,7 +131,7 @@ struct IDSelectorAll : IDSelector {
     virtual ~IDSelectorAll() {}
 };
 
-/// does an AND operation on the the two given IDSelector's is_membership
+/// does an AND operation on the two given IDSelector's is_membership
 /// results.
 struct IDSelectorAnd : IDSelector {
     const IDSelector* lhs;
@@ -144,7 +144,7 @@ struct IDSelectorAnd : IDSelector {
     virtual ~IDSelectorAnd() {}
 };
 
-/// does an OR operation on the the two given IDSelector's is_membership
+/// does an OR operation on the two given IDSelector's is_membership
 /// results.
 struct IDSelectorOr : IDSelector {
     const IDSelector* lhs;
@@ -157,7 +157,7 @@ struct IDSelectorOr : IDSelector {
     virtual ~IDSelectorOr() {}
 };
 
-/// does an XOR operation on the the two given IDSelector's is_membership
+/// does an XOR operation on the two given IDSelector's is_membership
 /// results.
 struct IDSelectorXOr : IDSelector {
     const IDSelector* lhs;

data/vendor/faiss/faiss/impl/LocalSearchQuantizer.cpp

@@ -30,7 +30,7 @@
 #endif
 
 extern "C" {
-// LU decomoposition of a general matrix
+// LU decomposition of a general matrix
 void sgetrf_(
         FINTEGER* m,
         FINTEGER* n,
@@ -65,7 +65,7 @@ int sgemm_(
         float* c,
         FINTEGER* ldc);
 
-// LU decomoposition of a general matrix
+// LU decomposition of a general matrix
 void dgetrf_(
         FINTEGER* m,
         FINTEGER* n,
@@ -189,7 +189,7 @@ void LocalSearchQuantizer::train(size_t n, const float* x) {
     std::vector<int32_t> codes(n * M); // [n, M]
     random_int32(codes, 0, K - 1, gen);
 
-    // compute standard derivations of each dimension
+    // compute standard deviations of each dimension
     std::vector<float> stddev(d, 0);
 
 #pragma omp parallel for
@@ -487,7 +487,7 @@ void LocalSearchQuantizer::update_codebooks(
  *     L = (X - \sum cj)^2, j = 1, ..., M
  *     L = X^2 - 2X * \sum cj + (\sum cj)^2
  *
- * X^2 is negligable since it is the same for all possible value
+ * X^2 is negligible since it is the same for all possible value
  * k of the m-th subcode.
  *
  * 2X * \sum cj is the unary term

data/vendor/faiss/faiss/impl/LocalSearchQuantizer.h

@@ -138,7 +138,7 @@ struct LocalSearchQuantizer : AdditiveQuantizer {
     /** Add some perturbation to codebooks
      *
      * @param T         temperature of simulated annealing
-     * @param stddev    standard derivations of each dimension in training data
+     * @param stddev    standard deviations of each dimension in training data
      */
     void perturb_codebooks(
             float T,

data/vendor/faiss/faiss/impl/LookupTableScaler.h

@@ -63,7 +63,7 @@ struct DummyScaler {
 };
 
 /// consumes 2x4 bits to encode a norm as a scalar additive quantizer
-/// the norm is scaled because its range if larger than other components
+/// the norm is scaled because its range is larger than other components
 struct NormTableScaler {
     static constexpr int nscale = 2;
     int scale_int;

data/vendor/faiss/faiss/impl/NNDescent.cpp

@@ -177,7 +177,7 @@ void NNDescent::join(DistanceComputer& qdis) {
     }
 }
 
-/// Sample neighbors for each node to peform local join later
+/// Sample neighbors for each node to perform local join later
 /// Store them in nn_new and nn_old
 void NNDescent::update() {
     // Step 1.

data/vendor/faiss/faiss/impl/NNDescent.h

@@ -34,7 +34,7 @@ namespace faiss {
  *
  *  Dong, Wei, Charikar Moses, and Kai Li, WWW 2011
  *
- * This implmentation is heavily influenced by the efanna
+ * This implementation is heavily influenced by the efanna
  * implementation by Cong Fu and the KGraph library by Wei Dong
  * (https://github.com/ZJULearning/efanna_graph)
  * (https://github.com/aaalgo/kgraph)
@@ -117,7 +117,7 @@ struct NNDescent {
     /// Perform local join on each node
     void join(DistanceComputer& qdis);
 
-    /// Sample new neighbors for each node to peform local join later
+    /// Sample new neighbors for each node to perform local join later
     void update();
 
     /// Sample a small number of points to evaluate the quality of KNNG built

data/vendor/faiss/faiss/impl/NSG.cpp

@@ -621,7 +621,7 @@ int NSG::attach_unlinked(
         }
     }
 
-    // randomly choice annother node
+    // randomly choice another node
     if (!found) {
         do {
             node = rng.rand_int(ntotal);

data/vendor/faiss/faiss/impl/Panorama.cpp

@@ -0,0 +1,193 @@
+/*
+ * 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/impl/Panorama.h>
+
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+#include <vector>
+
+namespace faiss {
+
+/**************************************************************
+ * Panorama structure implementation
+ **************************************************************/
+
+Panorama::Panorama(size_t code_size, size_t n_levels, size_t batch_size)
+        : code_size(code_size), n_levels(n_levels), batch_size(batch_size) {
+    set_derived_values();
+}
+
+void Panorama::set_derived_values() {
+    this->d = code_size / sizeof(float);
+    this->level_width_floats = ((d + n_levels - 1) / n_levels);
+    this->level_width = this->level_width_floats * sizeof(float);
+}
+
+/**
+ * @brief Copy codes to level-oriented layout
+ * @param codes The base pointer to codes
+ * @param offset Where to start writing new data (in number of vectors)
+ * @param n_entry The number of new vectors to write
+ * @param code The new vector data
+ */
+void Panorama::copy_codes_to_level_layout(
+        uint8_t* codes,
+        size_t offset,
+        size_t n_entry,
+        const uint8_t* code) {
+    for (size_t entry_idx = 0; entry_idx < n_entry; entry_idx++) {
+        size_t current_pos = offset + entry_idx;
+
+        // Determine which batch we're in and position within that batch.
+        size_t batch_no = current_pos / batch_size;
+        size_t pos_in_batch = current_pos % batch_size;
+
+        // Copy entry into level-oriented layout for this batch.
+        size_t batch_offset = batch_no * batch_size * code_size;
+        for (size_t level = 0; level < n_levels; level++) {
+            size_t level_offset = level * level_width * batch_size;
+            size_t start_byte = level * level_width;
+            size_t actual_level_width =
+                    std::min(level_width, code_size - level * level_width);
+
+            const uint8_t* src = code + entry_idx * code_size + start_byte;
+            uint8_t* dest = codes + batch_offset + level_offset +
+                    pos_in_batch * actual_level_width;
+
+            memcpy(dest, src, actual_level_width);
+        }
+    }
+}
+
+void Panorama::compute_cumulative_sums(
+        float* cumsum_base,
+        size_t offset,
+        size_t n_entry,
+        const float* vectors) {
+    std::vector<float> suffix_sums(d + 1);
+
+    for (size_t entry_idx = 0; entry_idx < n_entry; entry_idx++) {
+        size_t current_pos = offset + entry_idx;
+        size_t batch_no = current_pos / batch_size;
+        size_t pos_in_batch = current_pos % batch_size;
+
+        const float* vector = vectors + entry_idx * d;
+
+        // Compute suffix sums of squared values.
+        suffix_sums[d] = 0.0f;
+        for (int j = d - 1; j >= 0; j--) {
+            float squared_val = vector[j] * vector[j];
+            suffix_sums[j] = suffix_sums[j + 1] + squared_val;
+        }
+
+        // Store cumulative sums in batch-oriented layout.
+        size_t cumsum_batch_offset = batch_no * batch_size * (n_levels + 1);
+
+        for (size_t level = 0; level < n_levels; level++) {
+            size_t start_idx = level * level_width_floats;
+            size_t cumsum_offset =
+                    cumsum_batch_offset + level * batch_size + pos_in_batch;
+            if (start_idx < d) {
+                cumsum_base[cumsum_offset] = std::sqrt(suffix_sums[start_idx]);
+            } else {
+                cumsum_base[cumsum_offset] = 0.0f;
+            }
+        }
+
+        // Last level sum is always 0.
+        size_t cumsum_offset =
+                cumsum_batch_offset + n_levels * batch_size + pos_in_batch;
+        cumsum_base[cumsum_offset] = 0.0f;
+    }
+}
+
+void Panorama::compute_query_cum_sums(const float* query, float* query_cum_sums)
+        const {
+    std::vector<float> suffix_sums(d + 1);
+    suffix_sums[d] = 0.0f;
+
+    for (int j = d - 1; j >= 0; j--) {
+        float squared_val = query[j] * query[j];
+        suffix_sums[j] = suffix_sums[j + 1] + squared_val;
+    }
+
+    for (size_t level = 0; level < n_levels; level++) {
+        size_t start_idx = level * level_width_floats;
+        if (start_idx < d) {
+            query_cum_sums[level] = std::sqrt(suffix_sums[start_idx]);
+        } else {
+            query_cum_sums[level] = 0.0f;
+        }
+    }
+
+    query_cum_sums[n_levels] = 0.0f;
+}
+
+void Panorama::reconstruct(idx_t key, float* recons, const uint8_t* codes_base)
+        const {
+    uint8_t* recons_buffer = reinterpret_cast<uint8_t*>(recons);
+
+    size_t batch_no = key / batch_size;
+    size_t pos_in_batch = key % batch_size;
+    size_t batch_offset = batch_no * batch_size * code_size;
+
+    for (size_t level = 0; level < n_levels; level++) {
+        size_t level_offset = level * level_width * batch_size;
+        const uint8_t* src = codes_base + batch_offset + level_offset +
+                pos_in_batch * level_width;
+        uint8_t* dest = recons_buffer + level * level_width;
+        size_t copy_size =
+                std::min(level_width, code_size - level * level_width);
+        memcpy(dest, src, copy_size);
+    }
+}
+
+void Panorama::copy_entry(
+        uint8_t* dest_codes,
+        uint8_t* src_codes,
+        float* dest_cum_sums,
+        float* src_cum_sums,
+        size_t dest_idx,
+        size_t src_idx) const {
+    // Calculate positions
+    size_t src_batch_no = src_idx / batch_size;
+    size_t src_pos_in_batch = src_idx % batch_size;
+    size_t dest_batch_no = dest_idx / batch_size;
+    size_t dest_pos_in_batch = dest_idx % batch_size;
+
+    // Calculate offsets
+    size_t src_batch_offset = src_batch_no * batch_size * code_size;
+    size_t dest_batch_offset = dest_batch_no * batch_size * code_size;
+    size_t src_cumsum_batch_offset = src_batch_no * batch_size * (n_levels + 1);
+    size_t dest_cumsum_batch_offset =
+            dest_batch_no * batch_size * (n_levels + 1);
+
+    for (size_t level = 0; level < n_levels; level++) {
+        // Copy code
+        size_t level_offset = level * level_width * batch_size;
+        size_t actual_level_width =
+                std::min(level_width, code_size - level * level_width);
+
+        const uint8_t* src = src_codes + src_batch_offset + level_offset +
+                src_pos_in_batch * actual_level_width;
+        uint8_t* dest = dest_codes + dest_batch_offset + level_offset +
+                dest_pos_in_batch * actual_level_width;
+        memcpy(dest, src, actual_level_width);
+
+        // Copy cum_sums
+        size_t cumsum_level_offset = level * batch_size;
+
+        const size_t src_offset = src_cumsum_batch_offset +
+                cumsum_level_offset + src_pos_in_batch;
+        size_t dest_offset = dest_cumsum_batch_offset + cumsum_level_offset +
+                dest_pos_in_batch;
+        dest_cum_sums[dest_offset] = src_cum_sums[src_offset];
+    }
+}
+} // namespace faiss

data/vendor/faiss/faiss/impl/Panorama.h

@@ -0,0 +1,204 @@
+/*
+ * 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.
+ */
+
+// -*- c++ -*-
+
+#ifndef FAISS_PANORAMA_H
+#define FAISS_PANORAMA_H
+
+#include <faiss/impl/IDSelector.h>
+#include <faiss/impl/PanoramaStats.h>
+#include <faiss/utils/distances.h>
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+namespace faiss {
+
+/**
+ * Implements the core logic of Panorama-based refinement.
+ * arXiv: https://arxiv.org/abs/2510.00566
+ *
+ * Panorama partitions the dimensions of all vectors into L contiguous levels.
+ * During the refinement stage of ANNS, it computes distances between the query
+ * and its candidates level-by-level. After processing each level, it prunes the
+ * candidates whose lower bound exceeds the k-th best distance.
+ *
+ * In order to enable speedups, the dimensions (or codes) of each vector are
+ * stored in a batched, level-major manner. Within each batch of b vectors, the
+ * dimensions corresponding to level 1 will be stored first (for all elements in
+ * that batch), followed by level 2, and so on. This allows for efficient memory
+ * access patterns.
+ *
+ * Coupled with the appropriate orthogonal PreTransform (e.g. PCA, Cayley,
+ * etc.), Panorama can prune the vast majority of dimensions, greatly
+ * accelerating the refinement stage.
+ */
+struct Panorama {
+    size_t d = 0;
+    size_t code_size = 0;
+    size_t n_levels = 0;
+    size_t level_width = 0;
+    size_t level_width_floats = 0;
+    size_t batch_size = 0;
+
+    explicit Panorama(size_t code_size, size_t n_levels, size_t batch_size);
+
+    void set_derived_values();
+
+    /// Helper method to copy codes into level-oriented batch layout at a given
+    /// offset in the list.
+    void copy_codes_to_level_layout(
+            uint8_t* codes,
+            size_t offset,
+            size_t n_entry,
+            const uint8_t* code);
+
+    /// Helper method to compute the cumulative sums of the codes.
+    /// The cumsums also follow the level-oriented batch layout to minimize the
+    /// number of random memory accesses.
+    void compute_cumulative_sums(
+            float* cumsum_base,
+            size_t offset,
+            size_t n_entry,
+            const float* vectors);
+
+    /// Compute the cumulative sums of the query vector.
+    void compute_query_cum_sums(const float* query, float* query_cum_sums)
+            const;
+
+    /// Copy single entry (code and cum_sum) from one location to another.
+    void copy_entry(
+            uint8_t* dest_codes,
+            uint8_t* src_codes,
+            float* dest_cum_sums,
+            float* src_cum_sums,
+            size_t dest_idx,
+            size_t src_idx) const;
+
+    /// Panorama's core progressive filtering algorithm:
+    /// Process vectors in batches for cache efficiency. For each batch:
+    /// 1. Apply ID selection filter and initialize distances
+    /// (||y||^2 + ||x||^2).
+    /// 2. Maintain an "active set" of candidate indices that haven't been
+    /// pruned yet.
+    /// 3. For each level, refine distances incrementally and compact the active
+    /// set:
+    ///    - Compute dot product for current level: exact_dist -= 2*<x,y>.
+    ///    - Use Cauchy-Schwarz bound on remaining levels to get lower bound
+    ///    - Prune candidates whose lower bound exceeds k-th best distance.
+    ///    - Compact active_indices to remove pruned candidates (branchless)
+    /// 4. After all levels, survivors are exact distances; update heap.
+    /// This achieves early termination while maintaining SIMD-friendly
+    /// sequential access patterns in the level-oriented storage layout.
+    template <typename C>
+    size_t progressive_filter_batch(
+            const uint8_t* codes_base,
+            const float* cum_sums,
+            const float* query,
+            const float* query_cum_sums,
+            size_t batch_no,
+            size_t list_size,
+            const IDSelector* sel,
+            const idx_t* ids,
+            bool use_sel,
+            std::vector<uint32_t>& active_indices,
+            std::vector<float>& exact_distances,
+            float threshold,
+            PanoramaStats& local_stats) const;
+
+    void reconstruct(idx_t key, float* recons, const uint8_t* codes_base) const;
+};
+
+template <typename C>
+size_t Panorama::progressive_filter_batch(
+        const uint8_t* codes_base,
+        const float* cum_sums,
+        const float* query,
+        const float* query_cum_sums,
+        size_t batch_no,
+        size_t list_size,
+        const IDSelector* sel,
+        const idx_t* ids,
+        bool use_sel,
+        std::vector<uint32_t>& active_indices,
+        std::vector<float>& exact_distances,
+        float threshold,
+        PanoramaStats& local_stats) const {
+    size_t batch_start = batch_no * batch_size;
+    size_t curr_batch_size = std::min(list_size - batch_start, batch_size);
+
+    size_t cumsum_batch_offset = batch_no * batch_size * (n_levels + 1);
+    const float* batch_cum_sums = cum_sums + cumsum_batch_offset;
+    const float* level_cum_sums = batch_cum_sums + batch_size;
+    float q_norm = query_cum_sums[0] * query_cum_sums[0];
+
+    size_t batch_offset = batch_no * batch_size * code_size;
+    const uint8_t* storage_base = codes_base + batch_offset;
+
+    // Initialize active set with ID-filtered vectors.
+    size_t num_active = 0;
+    for (size_t i = 0; i < curr_batch_size; i++) {
+        size_t global_idx = batch_start + i;
+        idx_t id = (ids == nullptr) ? global_idx : ids[global_idx];
+        bool include = !use_sel || sel->is_member(id);
+
+        active_indices[num_active] = i;
+        float cum_sum = batch_cum_sums[i];
+        exact_distances[i] = cum_sum * cum_sum + q_norm;
+
+        num_active += include;
+    }
+
+    if (num_active == 0) {
+        return 0;
+    }
+
+    size_t total_active = num_active;
+    for (size_t level = 0; level < n_levels; level++) {
+        local_stats.total_dims_scanned += num_active;
+        local_stats.total_dims += total_active;
+
+        float query_cum_norm = query_cum_sums[level + 1];
+
+        size_t level_offset = level * level_width * batch_size;
+        const float* level_storage =
+                (const float*)(storage_base + level_offset);
+
+        size_t next_active = 0;
+        for (size_t i = 0; i < num_active; i++) {
+            uint32_t idx = active_indices[i];
+            size_t actual_level_width = std::min(
+                    level_width_floats, d - level * level_width_floats);
+
+            const float* yj = level_storage + idx * actual_level_width;
+            const float* query_level = query + level * level_width_floats;
+
+            float dot_product =
+                    fvec_inner_product(query_level, yj, actual_level_width);
+
+            exact_distances[idx] -= 2.0f * dot_product;
+
+            float cum_sum = level_cum_sums[idx];
+            float cauchy_schwarz_bound = 2.0f * cum_sum * query_cum_norm;
+            float lower_bound = exact_distances[idx] - cauchy_schwarz_bound;
+
+            active_indices[next_active] = idx;
+            next_active += C::cmp(threshold, lower_bound) ? 1 : 0;
+        }
+
+        num_active = next_active;
+        level_cum_sums += batch_size;
+    }
+
+    return num_active;
+}
+} // namespace faiss
+
+#endif

data/vendor/faiss/faiss/impl/PanoramaStats.cpp

@@ -0,0 +1,33 @@
+/*
+ * 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.
+ */
+
+// -*- c++ -*-
+
+#include <faiss/impl/PanoramaStats.h>
+
+namespace faiss {
+
+void PanoramaStats::reset() {
+    total_dims_scanned = 0;
+    total_dims = 0;
+    ratio_dims_scanned = 1.0f;
+}
+
+void PanoramaStats::add(const PanoramaStats& other) {
+    total_dims_scanned += other.total_dims_scanned;
+    total_dims += other.total_dims;
+    if (total_dims > 0) {
+        ratio_dims_scanned =
+                static_cast<float>(total_dims_scanned) / total_dims;
+    } else {
+        ratio_dims_scanned = 1.0f;
+    }
+}
+
+PanoramaStats indexPanorama_stats;
+
+} // namespace faiss

data/vendor/faiss/faiss/impl/PanoramaStats.h

@@ -0,0 +1,38 @@
+/*
+ * 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.
+ */
+
+// -*- c++ -*-
+
+#ifndef FAISS_PANORAMA_STATS_H
+#define FAISS_PANORAMA_STATS_H
+
+#include <faiss/impl/platform_macros.h>
+
+namespace faiss {
+
+/// Statistics are not robust to internal threading nor to
+/// concurrent Panorama searches. Use these values in a
+/// single-threaded context to accurately gauge Panorama's
+/// pruning effectiveness.
+struct PanoramaStats {
+    uint64_t total_dims_scanned = 0; // total dimensions scanned
+    uint64_t total_dims = 0;         // total dimensions
+    float ratio_dims_scanned = 1.0f; // fraction of dimensions actually scanned
+
+    PanoramaStats() {
+        reset();
+    }
+    void reset();
+    void add(const PanoramaStats& other);
+};
+
+// Single global var for all Panorama indexes
+FAISS_API extern PanoramaStats indexPanorama_stats;
+
+} // namespace faiss
+
+#endif

data/vendor/faiss/faiss/impl/PolysemousTraining.cpp

@@ -178,7 +178,7 @@ struct ReproduceWithHammingObjective : PermutationObjective {
         return x * x;
     }
 
-    // weihgting of distances: it is more important to reproduce small
+    // weighting of distances: it is more important to reproduce small
     // distances well
     double dis_weight(double x) const {
         return exp(-dis_weight_factor * x);
@@ -295,7 +295,7 @@ struct ReproduceWithHammingObjective : PermutationObjective {
 
 } // anonymous namespace
 
-// weihgting of distances: it is more important to reproduce small
+// weighting of distances: it is more important to reproduce small
 // distances well
 double ReproduceDistancesObjective::dis_weight(double x) const {
     return exp(-dis_weight_factor * x);
@@ -636,7 +636,7 @@ struct Score3Computer : PermutationObjective {
         return accu;
     }
 
-    /// PermutationObjective implementeation (just negates the scores
+    /// PermutationObjective implementation (just negates the scores
     /// for minimization)
 
     double compute_cost(const int* perm) const override {
@@ -689,7 +689,7 @@ struct RankingScore2 : Score3Computer<float, double> {
     /// count nb of i, j in a x b st. i < j
     /// a and b should be sorted on input
     /// they are the ranks of j and k respectively.
-    /// specific version for diff-of-rank weighting, cannot optimized
+    /// specific version for diff-of-rank weighting, cannot optimize
     /// with a cumulative table
     double accum_gt_weight_diff(
             const std::vector<int>& a,
@@ -985,7 +985,7 @@ size_t PolysemousTraining::memory_usage_per_thread(
             return n * n * n * sizeof(float);
     }
 
-    FAISS_THROW_MSG("Invalid optmization type");
+    FAISS_THROW_MSG("Invalid optimization type");
     return 0;
 }
 

data/vendor/faiss/faiss/impl/ProductAdditiveQuantizer.cpp

@@ -154,7 +154,7 @@ void ProductAdditiveQuantizer::compute_unpacked_codes(
         int32_t* unpacked_codes,
         size_t n,
         const float* centroids) const {
-    /// TODO: actuallly we do not need to unpack and pack
+    /// TODO: actually we do not need to unpack and pack
     size_t offset_d = 0, offset_m = 0;
     std::vector<float> xsub;
     std::vector<uint8_t> codes;

data/vendor/faiss/faiss/impl/ProductAdditiveQuantizer.h

@@ -46,7 +46,7 @@ struct ProductAdditiveQuantizer : AdditiveQuantizer {
 
     ProductAdditiveQuantizer();
 
-    virtual ~ProductAdditiveQuantizer();
+    virtual ~ProductAdditiveQuantizer() override;
 
     void init(
             size_t d,

data/vendor/faiss/faiss/impl/ProductQuantizer-inl.h

@@ -5,6 +5,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#pragma once
+
 namespace faiss {
 
 inline PQEncoderGeneric::PQEncoderGeneric(

data/vendor/faiss/faiss/impl/ProductQuantizer.h

@@ -166,7 +166,7 @@ struct ProductQuantizer : Quantizer {
     /// Symmetric Distance Table
     std::vector<float> sdc_table;
 
-    // intitialize the SDC table from the centroids
+    // initialize the SDC table from the centroids
     void compute_sdc_table();
 
     void search_sdc(