faiss 0.6.1 → 0.6.3

data/vendor/faiss/faiss/impl/HNSW.h

@@ -25,7 +25,9 @@ namespace faiss {
 // Forward declarations to avoid circular dependency.
 struct IndexHNSW;
 struct IndexHNSWFlatPanorama;
-struct MinimaxHeap;
+template <class HC_>
+struct MinimaxHeapT;
+using MinimaxHeap = MinimaxHeapT<CMax<float, int32_t>>;
 class LockVector;
 
 /** Implementation of the Hierarchical Navigable Small World
@@ -60,30 +62,52 @@ struct HNSW {
     /// internal storage of vectors (32 bits: this is expensive)
     using storage_idx_t = int32_t;
 
-    // for now we do only these distances
-    using C = CMax<float, int64_t>;
+    // The two comparator flavors HNSW supports. CMax (smaller-is-better)
+    // is the default; CMin (larger-is-better) is used when `is_similarity`
+    // is set on the owning index.
+    using C_distance = CMax<float, int64_t>;
+    using C_similarity = CMin<float, int64_t>;
+
+    // Back-compat alias: keeps `HNSW::C` resolving to the distance
+    // (CMax) comparator everywhere the type is referenced directly.
+    using C = C_distance;
 
     typedef std::pair<float, storage_idx_t> Node;
 
     /// to sort pairs of (id, distance) from nearest to farthest or the reverse
-    struct NodeDistCloser {
+    template <class CT>
+    struct NodeDistCloserT {
         float d;
         int id;
-        NodeDistCloser(float d_in, int id_in) : d(d_in), id(id_in) {}
-        bool operator<(const NodeDistCloser& obj1) const {
-            return d < obj1.d;
+        NodeDistCloserT(float d_in, int id_in) : d(d_in), id(id_in) {}
+        bool operator<(const NodeDistCloserT& obj1) const {
+            // priority_queue keeps the "worst" element at the top so that
+            // when the queue is full we can pop it. For CMax (distance) the
+            // worst element is the largest d; for CMin (similarity) it is
+            // the smallest d. Equivalent to: obj1.d "better than" d.
+            return CT::cmp(obj1.d, d);
         }
     };
 
-    struct NodeDistFarther {
+    template <class CT>
+    struct NodeDistFartherT {
         float d;
         int id;
-        NodeDistFarther(float d_in, int id_in) : d(d_in), id(id_in) {}
-        bool operator<(const NodeDistFarther& obj1) const {
-            return d > obj1.d;
+        NodeDistFartherT(float d_in, int id_in) : d(d_in), id(id_in) {}
+        bool operator<(const NodeDistFartherT& obj1) const {
+            // priority_queue here keeps the "best" element at the top so we
+            // can process the nearest candidate first. For CMax (distance)
+            // the best is the smallest d; for CMin (similarity) the best is
+            // the largest d. Equivalent to: d "better than" obj1.d.
+            return CT::cmp(d, obj1.d);
         }
     };
 
+    // Back-compat aliases: default to the distance (CMax) comparator so
+    // existing call sites that mention `HNSW::NodeDist*` keep working.
+    using NodeDistCloser = NodeDistCloserT<C_distance>;
+    using NodeDistFarther = NodeDistFartherT<C_distance>;
+
     /// assignment probability to each layer (sum=1)
     std::vector<double> assign_probas;
 
@@ -131,6 +155,12 @@ struct HNSW {
     /// use Panorama progressive pruning in search
     bool is_panorama = false;
 
+    /// distance comparison semantics: when true, distances are treated as
+    /// similarity scores (larger is better). Default false matches the
+    /// historical L2/Hamming behavior (smaller is better).
+    /// Not serialized: must be re-set by the owning Index after loading.
+    bool is_similarity = false;
+
     // See impl/VisitedTable.h.
     std::optional<bool> use_visited_hashset;
 
@@ -216,10 +246,11 @@ struct HNSW {
 
     int prepare_level_tab(size_t n, bool preset_levels = false);
 
+    template <class C = C_distance>
     static void shrink_neighbor_list(
             DistanceComputer& qdis,
-            std::priority_queue<NodeDistFarther>& input,
-            std::vector<NodeDistFarther>& output,
+            std::priority_queue<NodeDistFartherT<C>>& input,
+            std::vector<NodeDistFartherT<C>>& output,
             size_t max_size,
             bool keep_max_size_level0 = false);
 
@@ -250,6 +281,11 @@ struct HNSWStats {
 // global var that collects them all
 FAISS_API extern HNSWStats hnsw_stats;
 
+/// Internal HNSW algorithm helpers. These are not part of the public API; they
+/// are exposed here only so that unit tests (and a few cross-TU callers such as
+/// the Panorama search variant) can reach them.
+namespace hnsw_detail {
+
 int search_from_candidates(
         const HNSW& hnsw,
         DistanceComputer& qdis,
@@ -302,4 +338,6 @@ void search_neighbors_to_add(
         VisitedTable& vt,
         bool reference_version = false);
 
+} // namespace hnsw_detail
+
 } // namespace faiss

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

@@ -597,8 +597,8 @@ void LocalSearchQuantizer::icm_encode_step(
         const float* binaries,
         size_t n,
         size_t n_iters) const {
-    FAISS_THROW_IF_NOT(M != 0 && K != 0);
-    FAISS_THROW_IF_NOT(binaries != nullptr);
+    FAISS_THROW_IF_MSG(M == 0 || K == 0, "M and K must be nonzero");
+    FAISS_THROW_IF_NOT(binaries);
 
     // Resolve SIMD level once, not per iteration of the n × n_iters × M loop.
     with_simd_level_256bit([&]<SIMDLevel SL>() {

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

@@ -142,7 +142,9 @@ void NSG::build(
         idx_t n,
         const nsg::Graph<idx_t>& knn_graph,
         bool verbose) {
-    FAISS_THROW_IF_NOT(!is_built && ntotal == 0);
+    FAISS_THROW_IF_MSG(
+            is_built || ntotal != 0,
+            "NSG graph must be empty and not yet built");
 
     if (verbose) {
         printf("NSG::build R=%d, L=%d, C=%d\n", R, L, C);
@@ -234,10 +236,11 @@ void NSG::init_graph(Index* storage, const nsg::Graph<idx_t>& knn_graph) {
     std::unique_ptr<DistanceComputer> dis(storage_distance_computer(storage));
 
     dis->set_query(center.get());
-    VisitedTable vt(ntotal, use_visited_hashset);
+    std::unique_ptr<VisitedTable> vt =
+            VisitedTable::create(ntotal, use_visited_hashset);
 
     // Do not collect the visited nodes
-    search_on_graph<false>(knn_graph, *dis, vt, ep, L, retset, tmpset);
+    search_on_graph<false>(knn_graph, *dis, *vt, ep, L, retset, tmpset);
 
     // set enterpoint
     enterpoint = retset[0].id;
@@ -344,7 +347,8 @@ void NSG::link(
         std::vector<Node> pool;
         std::vector<Neighbor> tmp;
 
-        VisitedTable vt(ntotal, use_visited_hashset);
+        std::unique_ptr<VisitedTable> vt =
+                VisitedTable::create(ntotal, use_visited_hashset);
         std::unique_ptr<DistanceComputer> dis(
                 storage_distance_computer(storage));
 
@@ -355,13 +359,13 @@ void NSG::link(
 
             // Collect the visited nodes into pool
             search_on_graph<true>(
-                    knn_graph, *dis, vt, enterpoint, L, tmp, pool);
+                    knn_graph, *dis, *vt, enterpoint, L, tmp, pool);
 
-            sync_prune(i, pool, *dis, vt, knn_graph, graph);
+            sync_prune(i, pool, *dis, *vt, knn_graph, graph);
 
             pool.clear();
             tmp.clear();
-            vt.advance();
+            vt->advance();
         }
     } // omp parallel
 
@@ -531,19 +535,21 @@ void NSG::add_reverse_links(
 
 int NSG::tree_grow(Index* storage, std::vector<int>& degrees) {
     int root = enterpoint;
-    VisitedTable vt(ntotal, use_visited_hashset);
-    VisitedTable vt2(ntotal, use_visited_hashset);
+    std::unique_ptr<VisitedTable> vt =
+            VisitedTable::create(ntotal, use_visited_hashset);
+    std::unique_ptr<VisitedTable> vt2 =
+            VisitedTable::create(ntotal, use_visited_hashset);
 
     int num_attached = 0;
     int cnt = 0;
     while (true) {
-        cnt = dfs(vt, root, cnt);
+        cnt = dfs(*vt, root, cnt);
         if (cnt >= ntotal) {
             break;
         }
 
-        root = attach_unlinked(storage, vt, vt2, degrees);
-        vt2.advance();
+        root = attach_unlinked(storage, *vt, *vt2, degrees);
+        vt2->advance();
         num_attached += 1;
     }
 

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

@@ -36,7 +36,12 @@ namespace faiss {
 ///                    from active_indices (subsequent levels after pruning).
 /// @tparam LevelWidth Compile-time level width in floats (0 = use runtime
 ///                    level_width_dims). Enables full loop unrolling.
+// Skip pragmas under nvcc: its EDG frontend warns on `#pragma GCC optimize`
+// (#1675-D) for every `.cu` that transitively includes this header. These
+// templates are CPU-only, so the hint is irrelevant during nvcc parse.
+#if !defined(__NVCC__)
 FAISS_PRAGMA_IMPRECISE_FUNCTION_BEGIN
+#endif
 template <bool AllActive = false, size_t LevelWidth = 0>
 static inline void compute_level_dot_kernel(
         const float* FAISS_RESTRICT query_level,
@@ -44,18 +49,20 @@ static inline void compute_level_dot_kernel(
         const uint32_t* active_indices,
         const size_t num_active,
         const size_t level_width_dims,
-        float* FAISS_RESTRICT dot_products) {
+        float* FAISS_RESTRICT dot_products,
+        size_t stride = 0) {
     const size_t width = LevelWidth > 0 ? LevelWidth : level_width_dims;
+    const size_t row_stride = stride == 0 ? width : stride;
     size_t i = 0;
     for (; i + 4 <= num_active; i += 4) {
         const float* y0 = level_storage +
-                (AllActive ? (i + 0) : active_indices[i + 0]) * width;
+                (AllActive ? (i + 0) : active_indices[i + 0]) * row_stride;
         const float* y1 = level_storage +
-                (AllActive ? (i + 1) : active_indices[i + 1]) * width;
+                (AllActive ? (i + 1) : active_indices[i + 1]) * row_stride;
         const float* y2 = level_storage +
-                (AllActive ? (i + 2) : active_indices[i + 2]) * width;
+                (AllActive ? (i + 2) : active_indices[i + 2]) * row_stride;
         const float* y3 = level_storage +
-                (AllActive ? (i + 3) : active_indices[i + 3]) * width;
+                (AllActive ? (i + 3) : active_indices[i + 3]) * row_stride;
 
         float dp0 = 0, dp1 = 0, dp2 = 0, dp3 = 0;
         FAISS_PRAGMA_IMPRECISE_LOOP
@@ -73,8 +80,8 @@ static inline void compute_level_dot_kernel(
         dot_products[i + 3] = dp3;
     }
     for (; i < num_active; i++) {
-        const float* yj =
-                level_storage + (AllActive ? i : active_indices[i]) * width;
+        const float* yj = level_storage +
+                (AllActive ? i : active_indices[i]) * row_stride;
         float dp = 0;
         FAISS_PRAGMA_IMPRECISE_LOOP
         for (size_t j = 0; j < width; j++) {
@@ -83,7 +90,9 @@ static inline void compute_level_dot_kernel(
         dot_products[i] = dp;
     }
 }
+#if !defined(__NVCC__)
 FAISS_PRAGMA_IMPRECISE_FUNCTION_END
+#endif
 
 /// Update exact distances with the current level's dot products, then apply
 /// Panorama pruning: for each active vector, compute a lower bound on
@@ -92,7 +101,9 @@ FAISS_PRAGMA_IMPRECISE_FUNCTION_END
 ///
 /// Uses `if constexpr` on C::is_max rather than C::cmp() to ensure the
 /// comparison autovectorizes (C::cmp generates scalar function calls).
+#if !defined(__NVCC__)
 FAISS_PRAGMA_IMPRECISE_FUNCTION_BEGIN
+#endif
 template <bool AllActive, typename C, MetricType M>
 static inline void prune_kernel(
         float* FAISS_RESTRICT exact_distances,
@@ -128,7 +139,9 @@ static inline void prune_kernel(
         }
     }
 }
+#if !defined(__NVCC__)
 FAISS_PRAGMA_IMPRECISE_FUNCTION_END
+#endif
 
 /// Compact active_indices in-place, removing entries where active_byteset[i]
 /// is zero. Returns the new count of active elements. Uses a branchless BMI2 +

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

@@ -26,6 +26,8 @@
 
 #include <faiss/impl/FaissAssert.h>
 
+#include <faiss/impl/polysemous_training/dispatch.h>
+
 /*****************************************
  * Mixed PQ / Hamming
  ******************************************/
@@ -168,6 +170,94 @@ static inline int hamming_dis(uint64_t a, uint64_t b) {
     return popcount64(a ^ b);
 }
 
+static inline double sqr(double x) {
+    return x * x;
+}
+
+// Scalar (NONE) kernels for the two objectives. The dispatch boundary lives in
+// the objective methods below, which route to these or to the AVX-512
+// specializations (in polysemous_training/avx512.cpp) via
+// with_selected_simd_levels.
+namespace polysemous_training {
+
+template <>
+double hamming_compute_cost<SIMDLevel::NONE>(
+        int n,
+        const int* perm,
+        const double* target_dis,
+        const double* weights) {
+    double cost = 0;
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n; j++) {
+            double wanted = target_dis[i * n + j];
+            double w = weights[i * n + j];
+            double actual = hamming_dis(perm[i], perm[j]);
+            cost += w * sqr(wanted - actual);
+        }
+    }
+    return cost;
+}
+
+template <>
+double hamming_cost_update<SIMDLevel::NONE>(
+        int n,
+        const int* perm,
+        int iw,
+        int jw,
+        const double* target_dis,
+        const double* weights) {
+    double delta_cost = 0;
+
+    for (int i = 0; i < n; i++) {
+        if (i == iw) {
+            for (int j = 0; j < n; j++) {
+                double wanted = target_dis[i * n + j], w = weights[i * n + j];
+                double actual = hamming_dis(perm[i], perm[j]);
+                delta_cost -= w * sqr(wanted - actual);
+                double new_actual = hamming_dis(
+                        perm[jw],
+                        perm[j == iw           ? jw
+                                     : j == jw ? iw
+                                               : j]);
+                delta_cost += w * sqr(wanted - new_actual);
+            }
+        } else if (i == jw) {
+            for (int j = 0; j < n; j++) {
+                double wanted = target_dis[i * n + j], w = weights[i * n + j];
+                double actual = hamming_dis(perm[i], perm[j]);
+                delta_cost -= w * sqr(wanted - actual);
+                double new_actual = hamming_dis(
+                        perm[iw],
+                        perm[j == iw           ? jw
+                                     : j == jw ? iw
+                                               : j]);
+                delta_cost += w * sqr(wanted - new_actual);
+            }
+        } else {
+            int j = iw;
+            {
+                double wanted = target_dis[i * n + j], w = weights[i * n + j];
+                double actual = hamming_dis(perm[i], perm[j]);
+                delta_cost -= w * sqr(wanted - actual);
+                double new_actual = hamming_dis(perm[i], perm[jw]);
+                delta_cost += w * sqr(wanted - new_actual);
+            }
+            j = jw;
+            {
+                double wanted = target_dis[i * n + j], w = weights[i * n + j];
+                double actual = hamming_dis(perm[i], perm[j]);
+                delta_cost -= w * sqr(wanted - actual);
+                double new_actual = hamming_dis(perm[i], perm[iw]);
+                delta_cost += w * sqr(wanted - new_actual);
+            }
+        }
+    }
+
+    return delta_cost;
+}
+
+} // namespace polysemous_training
+
 namespace {
 
 /// optimize permutation to reproduce a distance table with Hamming distances
@@ -175,10 +265,6 @@ struct ReproduceWithHammingObjective : PermutationObjective {
     int nbits;
     double dis_weight_factor;
 
-    static double sqr(double x) {
-        return x * x;
-    }
-
     // weighting of distances: it is more important to reproduce small
     // distances well
     double dis_weight(double x) const {
@@ -190,73 +276,21 @@ struct ReproduceWithHammingObjective : PermutationObjective {
 
     // cost = quadratic difference between actual distance and Hamming distance
     double compute_cost(const int* perm) const override {
-        double cost = 0;
-        for (int i = 0; i < n; i++) {
-            for (int j = 0; j < n; j++) {
-                double wanted = target_dis[i * n + j];
-                double w = weights[i * n + j];
-                double actual = hamming_dis(perm[i], perm[j]);
-                cost += w * sqr(wanted - actual);
-            }
-        }
-        return cost;
+        return with_selected_simd_levels<polysemous_training::SIMD_LEVELS>(
+                [&]<SIMDLevel SL>() {
+                    return polysemous_training::hamming_compute_cost<SL>(
+                            n, perm, target_dis.data(), weights.data());
+                });
     }
 
     // what would the cost update be if iw and jw were swapped?
     // computed in O(n) instead of O(n^2) for the full re-computation
     double cost_update(const int* perm, int iw, int jw) const override {
-        double delta_cost = 0;
-
-        for (int i = 0; i < n; i++) {
-            if (i == iw) {
-                for (int j = 0; j < n; j++) {
-                    double wanted = target_dis[i * n + j],
-                           w = weights[i * n + j];
-                    double actual = hamming_dis(perm[i], perm[j]);
-                    delta_cost -= w * sqr(wanted - actual);
-                    double new_actual = hamming_dis(
-                            perm[jw],
-                            perm[j == iw           ? jw
-                                         : j == jw ? iw
-                                                   : j]);
-                    delta_cost += w * sqr(wanted - new_actual);
-                }
-            } else if (i == jw) {
-                for (int j = 0; j < n; j++) {
-                    double wanted = target_dis[i * n + j],
-                           w = weights[i * n + j];
-                    double actual = hamming_dis(perm[i], perm[j]);
-                    delta_cost -= w * sqr(wanted - actual);
-                    double new_actual = hamming_dis(
-                            perm[iw],
-                            perm[j == iw           ? jw
-                                         : j == jw ? iw
-                                                   : j]);
-                    delta_cost += w * sqr(wanted - new_actual);
-                }
-            } else {
-                int j = iw;
-                {
-                    double wanted = target_dis[i * n + j],
-                           w = weights[i * n + j];
-                    double actual = hamming_dis(perm[i], perm[j]);
-                    delta_cost -= w * sqr(wanted - actual);
-                    double new_actual = hamming_dis(perm[i], perm[jw]);
-                    delta_cost += w * sqr(wanted - new_actual);
-                }
-                j = jw;
-                {
-                    double wanted = target_dis[i * n + j],
-                           w = weights[i * n + j];
-                    double actual = hamming_dis(perm[i], perm[j]);
-                    delta_cost -= w * sqr(wanted - actual);
-                    double new_actual = hamming_dis(perm[i], perm[iw]);
-                    delta_cost += w * sqr(wanted - new_actual);
-                }
-            }
-        }
-
-        return delta_cost;
+        return with_selected_simd_levels<polysemous_training::SIMD_LEVELS>(
+                [&]<SIMDLevel SL>() {
+                    return polysemous_training::hamming_cost_update<SL>(
+                            n, perm, iw, jw, target_dis.data(), weights.data());
+                });
     }
 
     ReproduceWithHammingObjective(
@@ -306,14 +340,20 @@ double ReproduceDistancesObjective::get_source_dis(int i, int j) const {
     return source_dis[i * n + j];
 }
 
+namespace polysemous_training {
+
 // cost = quadratic difference between actual distance and Hamming distance
-double ReproduceDistancesObjective::compute_cost(const int* perm) const {
+template <>
+double distances_compute_cost<SIMDLevel::NONE>(
+        const ReproduceDistancesObjective& obj,
+        const int* perm) {
+    const int n = obj.n;
     double cost = 0;
     for (int i = 0; i < n; i++) {
         for (int j = 0; j < n; j++) {
-            double wanted = target_dis[i * n + j];
-            double w = weights[i * n + j];
-            double actual = get_source_dis(perm[i], perm[j]);
+            double wanted = obj.target_dis[i * n + j];
+            double w = obj.weights[i * n + j];
+            double actual = obj.get_source_dis(perm[i], perm[j]);
             cost += w * sqr(wanted - actual);
         }
     }
@@ -322,16 +362,22 @@ double ReproduceDistancesObjective::compute_cost(const int* perm) const {
 
 // what would the cost update be if iw and jw were swapped?
 // computed in O(n) instead of O(n^2) for the full re-computation
-double ReproduceDistancesObjective::cost_update(const int* perm, int iw, int jw)
-        const {
+template <>
+double distances_cost_update<SIMDLevel::NONE>(
+        const ReproduceDistancesObjective& obj,
+        const int* perm,
+        int iw,
+        int jw) {
+    const int n = obj.n;
     double delta_cost = 0;
     for (int i = 0; i < n; i++) {
         if (i == iw) {
             for (int j = 0; j < n; j++) {
-                double wanted = target_dis[i * n + j], w = weights[i * n + j];
-                double actual = get_source_dis(perm[i], perm[j]);
+                double wanted = obj.target_dis[i * n + j],
+                       w = obj.weights[i * n + j];
+                double actual = obj.get_source_dis(perm[i], perm[j]);
                 delta_cost -= w * sqr(wanted - actual);
-                double new_actual = get_source_dis(
+                double new_actual = obj.get_source_dis(
                         perm[jw],
                         perm[j == iw           ? jw
                                      : j == jw ? iw
@@ -340,10 +386,11 @@ double ReproduceDistancesObjective::cost_update(const int* perm, int iw, int jw)
             }
         } else if (i == jw) {
             for (int j = 0; j < n; j++) {
-                double wanted = target_dis[i * n + j], w = weights[i * n + j];
-                double actual = get_source_dis(perm[i], perm[j]);
+                double wanted = obj.target_dis[i * n + j],
+                       w = obj.weights[i * n + j];
+                double actual = obj.get_source_dis(perm[i], perm[j]);
                 delta_cost -= w * sqr(wanted - actual);
-                double new_actual = get_source_dis(
+                double new_actual = obj.get_source_dis(
                         perm[iw],
                         perm[j == iw           ? jw
                                      : j == jw ? iw
@@ -353,18 +400,20 @@ double ReproduceDistancesObjective::cost_update(const int* perm, int iw, int jw)
         } else {
             int j = iw;
             {
-                double wanted = target_dis[i * n + j], w = weights[i * n + j];
-                double actual = get_source_dis(perm[i], perm[j]);
+                double wanted = obj.target_dis[i * n + j],
+                       w = obj.weights[i * n + j];
+                double actual = obj.get_source_dis(perm[i], perm[j]);
                 delta_cost -= w * sqr(wanted - actual);
-                double new_actual = get_source_dis(perm[i], perm[jw]);
+                double new_actual = obj.get_source_dis(perm[i], perm[jw]);
                 delta_cost += w * sqr(wanted - new_actual);
             }
             j = jw;
             {
-                double wanted = target_dis[i * n + j], w = weights[i * n + j];
-                double actual = get_source_dis(perm[i], perm[j]);
+                double wanted = obj.target_dis[i * n + j],
+                       w = obj.weights[i * n + j];
+                double actual = obj.get_source_dis(perm[i], perm[j]);
                 delta_cost -= w * sqr(wanted - actual);
-                double new_actual = get_source_dis(perm[i], perm[iw]);
+                double new_actual = obj.get_source_dis(perm[i], perm[iw]);
                 delta_cost += w * sqr(wanted - new_actual);
             }
         }
@@ -372,6 +421,25 @@ double ReproduceDistancesObjective::cost_update(const int* perm, int iw, int jw)
     return delta_cost;
 }
 
+} // namespace polysemous_training
+
+double ReproduceDistancesObjective::compute_cost(const int* perm) const {
+    return with_selected_simd_levels<polysemous_training::SIMD_LEVELS>(
+            [&]<SIMDLevel SL>() {
+                return polysemous_training::distances_compute_cost<SL>(
+                        *this, perm);
+            });
+}
+
+double ReproduceDistancesObjective::cost_update(const int* perm, int iw, int jw)
+        const {
+    return with_selected_simd_levels<polysemous_training::SIMD_LEVELS>(
+            [&]<SIMDLevel SL>() {
+                return polysemous_training::distances_cost_update<SL>(
+                        *this, perm, iw, jw);
+            });
+}
+
 ReproduceDistancesObjective::ReproduceDistancesObjective(
         int n_in,
         const double* source_dis_in,