deglib 0.2.5__tar.gz → 0.2.6__tar.gz

{deglib-0.2.5 → deglib-0.2.6}/CMakeLists.txt

@@ -15,11 +15,20 @@ find_package(pybind11 CONFIG REQUIRED)
 set(ENABLE_BENCHMARKS OFF CACHE BOOL "Disable benchmarks" FORCE)
 set(ENABLE_TESTING OFF CACHE BOOL "Disable tests" FORCE)
 
+# Find deglib cpp source: prefer ../cpp in repository checkouts, fallback to local lib/ (PyPI sdist)
+if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/../cpp/CMakeLists.txt")
+    set(DEGLIB_CPP_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../cpp")
+elseif(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/lib/CMakeLists.txt")
+    set(DEGLIB_CPP_DIR "${CMAKE_CURRENT_SOURCE_DIR}/lib")
+else()
+    message(FATAL_ERROR "Could not find deglib cpp source directory (checked ../cpp/ and lib/)")
+endif()
+
 # Add cpp-deglib
-add_subdirectory(${CMAKE_SOURCE_DIR}/lib/)
+add_subdirectory(${DEGLIB_CPP_DIR} deglib_cpp_build)
 pybind11_add_module(deglib_cpp src/deg_cpp/deglib_cpp.cpp)
 
 # Specify the include directories
-include_directories(${CMAKE_SOURCE_DIR}/lib/deglib/include)
+include_directories(${DEGLIB_CPP_DIR}/deglib/include)
 
 target_link_libraries(deglib_cpp PRIVATE compile-options)

{deglib-0.2.5/src/deglib.egg-info → deglib-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deglib
-Version: 0.2.5
+Version: 0.2.6
 Summary: Python bindings for the Dynamic Exploration Graph library by Nico Hezel
 Author: Nico Hezel
 Author-email: Bruno Schilling <bruno.schilling@htw-berlin.de>
@@ -278,10 +278,21 @@ Controls the topology optimization strategy:
 - `OptimizationTarget.HighLID`: Optimized for datasets with high local intrinsic dimensionality (supports multithreaded building).
 - `OptimizationTarget.StreamingData`: Optimized for continuous dynamic additions and deletions.
 
-### Search Parameter `eps`
-- The epsilon parameter expands the search priority queue during graph exploration.
-- Small values (e.g. `eps=0.001` or `eps=0.01`): Faster query execution.
-- Higher values (e.g. `eps=0.1` to `eps=0.3`): Higher recall rate.
+### Unified Search Parameter: `eps_or_ef`
+`Searcher` provides a unified exploration parameter `eps_or_ef`:
+- **Relative Distance Margin (`eps_or_ef < 1.0`)**: Standard DEG dynamic distance exploration bound $(1 + \epsilon) \cdot d_{\text{cur}}$.
+  - Small values (e.g. `eps_or_ef=0.001` or `0.01`): Faster query execution.
+  - Higher values (e.g. `eps_or_ef=0.1` to `0.3`): Higher recall rate.
+- **Fixed Candidate Pool (`eps_or_ef >= 1.0`)**: HNSW-style search with a fixed candidate pool size of `round(eps_or_ef)` during exploration.
+  - Typical values: `64`, `96`, `128`, `200`, `400`.
+
+```python
+# Mode 1: Relative distance margin (default: eps_or_ef=0.1)
+indices, distances = searcher.search(query, k=10, eps_or_ef=0.1)
+
+# Mode 2: Fixed candidate pool (HNSW-style)
+indices, distances = searcher.search(query, k=10, eps_or_ef=128)
+```
 
 ### Supported Metrics & Data Types
 - `Metric.FP32_L2`: Euclidean distance (`np.float32`)

{deglib-0.2.5 → deglib-0.2.6}/README.md

@@ -250,10 +250,21 @@ Controls the topology optimization strategy:
 - `OptimizationTarget.HighLID`: Optimized for datasets with high local intrinsic dimensionality (supports multithreaded building).
 - `OptimizationTarget.StreamingData`: Optimized for continuous dynamic additions and deletions.
 
-### Search Parameter `eps`
-- The epsilon parameter expands the search priority queue during graph exploration.
-- Small values (e.g. `eps=0.001` or `eps=0.01`): Faster query execution.
-- Higher values (e.g. `eps=0.1` to `eps=0.3`): Higher recall rate.
+### Unified Search Parameter: `eps_or_ef`
+`Searcher` provides a unified exploration parameter `eps_or_ef`:
+- **Relative Distance Margin (`eps_or_ef < 1.0`)**: Standard DEG dynamic distance exploration bound $(1 + \epsilon) \cdot d_{\text{cur}}$.
+  - Small values (e.g. `eps_or_ef=0.001` or `0.01`): Faster query execution.
+  - Higher values (e.g. `eps_or_ef=0.1` to `0.3`): Higher recall rate.
+- **Fixed Candidate Pool (`eps_or_ef >= 1.0`)**: HNSW-style search with a fixed candidate pool size of `round(eps_or_ef)` during exploration.
+  - Typical values: `64`, `96`, `128`, `200`, `400`.
+
+```python
+# Mode 1: Relative distance margin (default: eps_or_ef=0.1)
+indices, distances = searcher.search(query, k=10, eps_or_ef=0.1)
+
+# Mode 2: Fixed candidate pool (HNSW-style)
+indices, distances = searcher.search(query, k=10, eps_or_ef=128)
+```
 
 ### Supported Metrics & Data Types
 - `Metric.FP32_L2`: Euclidean distance (`np.float32`)

{deglib-0.2.5 → deglib-0.2.6}/lib/CMakeLists.txt

@@ -70,12 +70,11 @@ else()  # Native build
 
   # setup compiler flags
   if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  # Portable native build: generic code is compiled for the build machine's
+  # baseline ISA only (no explicit AVX-512), so the module imports cleanly on
+  # CPUs without AVX-512. AVX-512 kernels are per-function target attributes
+  # (DEGLIB_TARGET_AVX512*), gated at runtime by deglib::cpu::select_dist().
     target_compile_options(compile-options INTERFACE -O3 -march=native -fpic -w -pthread -ftree-vectorize)
-    if(SUPPORT_AVX512F)
-      target_compile_options(compile-options INTERFACE -mavx512f -mfma)
-    elseif(SUPPORT_AVX2)
-      target_compile_options(compile-options INTERFACE -mavx2 -mfma)
-    endif()
   elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
     target_compile_options(compile-options INTERFACE -O2 -DNDEBUG -march=native -fpic)
   elseif(MSVC)

{deglib-0.2.5 → deglib-0.2.6}/lib/bench/include/build.h

@@ -41,7 +41,9 @@ inline deglib::graph::SizeBoundedGraph create_random_graph(
     const uint32_t vertex_count = (max_size > 0 && max_size < repository.size()) ? max_size : uint32_t(repository.size());
     const auto feature_data = repository.getFeature(0);
 
-    return deglib::graph::SizeBoundedGraph::create_random_graph(feature_data, vertex_count, k, feature_space);
+    auto graph = deglib::graph::SizeBoundedGraph(vertex_count, k, feature_space);
+    deglib::builder::populate_random_graph(graph, feature_data, vertex_count);
+    return graph;
 }
 
 inline void create_graph(

{deglib-0.2.5 → deglib-0.2.6}/lib/deglib/include/deglib/builder.h

@@ -649,7 +649,7 @@ class EvenRegularGraphBuilder {
             const auto dist_func_param = graph.getFeatureSpace().get_dist_func_param();
 
             // find good neighbors for the new vertex
-            const std::vector<uint32_t> entry_vertex_indices = {0};
+            const auto entry_vertex_indices = graph.getEntryVertexIndices();
             auto top_list =
                 graph.search_intern(entry_vertex_indices, new_vertex_feature, std::max(uint32_t(this->extend_k_), edges_per_vertex), this->extend_eps_);
             const auto results = topListAscending(top_list);
@@ -1535,7 +1535,7 @@ DynamicExplorationGraph build_from_data(
     }
 
     auto feature_space = deglib::distances::FloatSpace(dims, metric);
-    auto graph = deglib::DynamicExplorationGraph::create_empty(vertex_count, edges_per_vertex, feature_space);
+    auto graph = DynamicExplorationGraph(std::make_unique<deglib::graph::SizeBoundedGraph>(vertex_count, edges_per_vertex, feature_space));
 
     std::mt19937 rng(seed);
     auto builder = EvenRegularGraphBuilder(
@@ -1555,4 +1555,103 @@ DynamicExplorationGraph build_from_data(
     return graph;
 }
 
+/**
+ * Populate a MutableGraph with a random k-regular graph.
+ *
+ * @param graph The mutable graph instance to populate.
+ * @param feature_data Pointer to contiguous feature data bytes.
+ * @param vertex_count Number of vertices to insert.
+ * @param seed Random seed for deterministic graph construction (default: 7).
+ */
+inline void populate_random_graph(
+    deglib::graph::MutableGraph& graph,
+    const std::byte* feature_data,
+    const uint32_t vertex_count,
+    const uint32_t seed = 7
+) {
+    const auto& feature_space = graph.getFeatureSpace();
+    const auto edges_per_vertex = graph.getEdgesPerVertex();
+    const auto dist_func = feature_space.get_dist_func();
+    const auto dist_func_param = feature_space.get_dist_func_param();
+
+    // add the initial vertices (edges_per_vertex + 1)
+    {
+        const auto size = static_cast<uint32_t>(edges_per_vertex + 1);
+        for (uint32_t y = 0; y < size; y++) {
+            const auto query = feature_data + size_t(y) * feature_space.get_data_size();
+            const auto internal_index = graph.addVertex(y, query);
+
+            auto neighbor_indices = std::vector<uint32_t>();
+            auto neighbor_weights = std::vector<float>();
+            for (uint32_t x = 0; x < size; x++) {
+                if (x == internal_index) continue;
+                neighbor_indices.emplace_back(x);
+                neighbor_weights.emplace_back(dist_func(query, feature_data + size_t(x) * feature_space.get_data_size(), dist_func_param));
+            }
+            graph.changeEdges(internal_index, neighbor_indices.data(), neighbor_weights.data());
+        }
+    }
+
+    // random order of vertices
+    auto rnd = std::mt19937(seed);
+    auto rnd_neighbor = deglib::random::DeterministicUniformIntDistribution<uint32_t>(0, edges_per_vertex - 1);
+
+    // add the remaining vertices
+    for (uint32_t label = edges_per_vertex + 1; label < vertex_count; label++) {
+        const auto new_vertex_feature = feature_data + size_t(label) * feature_space.get_data_size();
+        const auto internal_index = graph.addVertex(label, new_vertex_feature);
+        auto top_list = deglib::random::DeterministicUniformIntDistribution<uint32_t>(0, label - 1);
+
+        // remove the worst edge of the good neighbors and connect them with this new vertex
+        auto new_neighbors = std::vector<std::pair<uint32_t, float>>();
+        while (new_neighbors.size() < edges_per_vertex) {
+            const auto candidate_index = static_cast<uint32_t>(top_list(rnd));
+
+            // check if the vertex is already in the edge list of the new vertex (added during a previous loop-run)
+            // since all edges are undirected and the edge information of the new vertex does not yet exist, we search the other way around.
+            if (graph.hasEdge(candidate_index, internal_index)) continue;
+
+            // find a new random neighbor
+            uint32_t new_neighbor_index = 0;
+            float new_neighbor_weight = 0;
+            bool found = false;
+            const auto neighbor_weights = graph.getNeighborWeights(candidate_index);
+            const auto neighbor_indices = graph.getNeighborIndices(candidate_index);
+            while (!found) {
+                const auto edge_idx = static_cast<uint32_t>(rnd_neighbor(rnd));
+                const auto neighbor_index = neighbor_indices[edge_idx];
+                const auto neighbor_weight = neighbor_weights[edge_idx];
+
+                // the suggested neighbors might already be in the edge list of the new vertex
+                if (!graph.hasEdge(neighbor_index, internal_index)) {
+                    new_neighbor_index = neighbor_index;
+                    new_neighbor_weight = neighbor_weight;
+                    found = true;
+                }
+            }
+
+            // place the new vertex in the edge list of the result-vertex
+            const auto candidate_dist = dist_func(new_vertex_feature, graph.getFeatureVector(candidate_index), dist_func_param);
+            graph.changeEdge(candidate_index, new_neighbor_index, internal_index, candidate_dist);
+            new_neighbors.emplace_back(candidate_index, candidate_dist);
+
+            // place the new vertex in the edge list of the worst edge neighbor
+            const auto new_neighbor_dist = dist_func(new_vertex_feature, graph.getFeatureVector(new_neighbor_index), dist_func_param);
+            graph.changeEdge(new_neighbor_index, candidate_index, internal_index, new_neighbor_dist);
+            new_neighbors.emplace_back(new_neighbor_index, new_neighbor_dist);
+        }
+
+        // sort the neighbors by their neighbor indices and store them in the new vertex
+        std::sort(new_neighbors.begin(), new_neighbors.end(), [](const auto& x, const auto& y) { return x.first < y.first; });
+        auto neighbor_indices = std::vector<uint32_t>();
+        auto neighbor_weights = std::vector<float>();
+        for (auto&& neighbor : new_neighbors) {
+            neighbor_indices.emplace_back(neighbor.first);
+            neighbor_weights.emplace_back(neighbor.second);
+        }
+        graph.changeEdges(internal_index, neighbor_indices.data(), neighbor_weights.data());
+    }
+}
+
 }  // end namespace deglib::builder
+

deglib-0.2.6/lib/deglib/include/deglib/deglib.h

@@ -0,0 +1,118 @@
+#pragma once
+
+#include "deglib/analysis.h"
+#include "deglib/builder.h"
+#include "deglib/config.h"
+#include "deglib/distances.h"
+#include "deglib/filter.h"
+#include "deglib/graph.h"
+#include "deglib/optimization.h"
+#include "deglib/search.h"
+#include "deglib/search/searcher.h"
+#include "deglib/utils/memory.h"
+#include "deglib/utils/random.h"
+
+namespace deglib {
+using builder::build_from_data;
+using builder::EvenRegularGraphBuilder;
+using builder::OptimizationTarget;
+
+/**
+ * Create an EvenRegularGraphBuilder for building and incrementally modifying a DynamicExplorationGraph.
+ */
+inline builder::EvenRegularGraphBuilder create_builder(
+    DynamicExplorationGraph& graph,
+    std::mt19937& rnd,
+    const builder::OptimizationTarget optimization_target = builder::OptimizationTarget::LowLID,
+    const uint8_t extend_k = 0,
+    const float extend_eps = 0.1f,
+    const uint8_t improve_k = 0,
+    const float improve_eps = 0.001f,
+    const uint8_t max_path_length = 5,
+    const uint32_t improve_tries = 0
+) {
+    return builder::EvenRegularGraphBuilder(
+        graph, rnd, optimization_target, extend_k, extend_eps, improve_k, improve_eps, max_path_length, improve_tries
+    );
+}
+
+/**
+ * Create an empty mutable DynamicExplorationGraph with the given capacity,
+ * edges per vertex, and feature space (backed by SizeBoundedGraph).
+ */
+inline DynamicExplorationGraph create_empty(
+    const uint32_t max_vertex_count,
+    const uint8_t edges_per_vertex,
+    const deglib::distances::FloatSpace& feature_space
+) {
+    auto graph = std::make_unique<deglib::graph::SizeBoundedGraph>(max_vertex_count, edges_per_vertex, feature_space);
+    return DynamicExplorationGraph(std::move(graph));
+}
+
+/**
+ * Create an empty mutable DynamicExplorationGraph with chunk-based dynamic memory allocation (backed by DynamicGraph).
+ *
+ * @param edges_per_vertex Number of edges per vertex (must be even).
+ * @param feature_space The feature space defining dimensionality and metric.
+ * @param chunk_size Target number of vertices per memory chunk (default = 1024).
+ *                   Will be automatically rounded up to the nearest power of 2 (e.g. 600 -> 1024).
+ */
+inline DynamicExplorationGraph create_dynamic_empty(
+    const uint8_t edges_per_vertex,
+    const deglib::distances::FloatSpace& feature_space,
+    const uint32_t chunk_size = 1024
+) {
+    auto graph = std::make_unique<deglib::graph::DynamicGraph>(edges_per_vertex, feature_space, chunk_size);
+    return DynamicExplorationGraph(std::move(graph));
+}
+
+/**
+ * Create a random exploration graph from the given feature data (backed by SizeBoundedGraph).
+ *
+ * @param feature_data Pointer to a contiguous array of feature vectors.
+ *                     Each vector is feature_space.get_data_size() bytes.
+ * @param vertex_count Number of vertices to insert.
+ * @param edges_per_vertex Number of edges per vertex (must be even).
+ * @param feature_space The feature space defining dimensionality and metric.
+ * @param seed Random seed for deterministic graph construction.
+ * @return A new DynamicExplorationGraph wrapping the created random graph.
+ */
+inline DynamicExplorationGraph create_random_graph(
+    const std::byte* feature_data,
+    const uint32_t vertex_count,
+    const uint8_t edges_per_vertex,
+    const deglib::distances::FloatSpace& feature_space,
+    const uint32_t seed = 7
+) {
+    auto graph = std::make_unique<deglib::graph::SizeBoundedGraph>(vertex_count, edges_per_vertex, feature_space);
+    deglib::builder::populate_random_graph(*graph, feature_data, vertex_count, seed);
+    return DynamicExplorationGraph(std::move(graph));
+}
+
+/**
+ * Load a saved graph from disk as a compact, immutable DynamicExplorationGraph (backed by ReadOnlyGraph).
+ */
+inline DynamicExplorationGraph load_readonly_graph(const char* path_graph) {
+    auto graph = std::make_unique<deglib::graph::ReadOnlyGraph>(deglib::graph::load_readonly_graph(path_graph));
+    return DynamicExplorationGraph(std::move(graph));
+}
+
+/**
+ * Load a saved graph from disk as a chunk-allocated mutable DynamicExplorationGraph (backed by DynamicGraph).
+ */
+inline DynamicExplorationGraph load_dynamic_graph(const char* path_graph, const uint32_t chunk_size = 1024) {
+    auto graph = std::make_unique<deglib::graph::DynamicGraph>(deglib::graph::load_dynamic_graph(path_graph, chunk_size));
+    return DynamicExplorationGraph(std::move(graph));
+}
+
+/**
+ * Load a saved graph from disk as a fixed-capacity mutable DynamicExplorationGraph (backed by SizeBoundedGraph).
+ *
+ * @param new_max_size Optional capacity override. If 0, uses the graph's serialized size.
+ */
+inline DynamicExplorationGraph load_mutable_graph(const char* path_graph, const uint32_t new_max_size = 0) {
+    auto graph = std::make_unique<deglib::graph::SizeBoundedGraph>(deglib::graph::load_sizebounded_graph(path_graph, new_max_size));
+    return DynamicExplorationGraph(std::move(graph));
+}
+
+}  // namespace deglib

{deglib-0.2.5 → deglib-0.2.6}/lib/deglib/include/deglib/distance/fp16_ip.h

@@ -110,8 +110,26 @@ class InnerProductFP16_AVX512 {
         __m512 sum512 = _mm512_add_ps(sum512_1, sum512_2);
         float result = fp16_hsum512(sum512);
 
-        // Scalar residual for the unaligned tail — eliminated at compile-time if HasTail == false
+        // Vectorized residual tail for arbitrary dimensions
         if constexpr (HasTail) {
+            if ((last - a) >= 8) {
+                __m256 va8 = _mm256_cvtph_ps(_mm_loadu_si128(reinterpret_cast<const __m128i*>(a)));
+                __m256 vb8 = _mm256_cvtph_ps(_mm_loadu_si128(reinterpret_cast<const __m128i*>(b)));
+                __m256 prod8 = _mm256_mul_ps(va8, vb8);
+                result += fp16_hsum256(prod8);
+                a += 8;
+                b += 8;
+            }
+            if ((last - a) >= 4) {
+                __m128 va4 = _mm_cvtph_ps(_mm_loadu_si64(a));
+                __m128 vb4 = _mm_cvtph_ps(_mm_loadu_si64(b));
+                __m128 prod4 = _mm_mul_ps(va4, vb4);
+                prod4 = _mm_add_ps(prod4, _mm_movehl_ps(prod4, prod4));
+                prod4 = _mm_add_ss(prod4, _mm_shuffle_ps(prod4, prod4, 1));
+                result += _mm_cvtss_f32(prod4);
+                a += 4;
+                b += 4;
+            }
             while (a < last) {
                 float fa = deglib::distances::fp16::fp16_to_float(*a++);
                 float fb = deglib::distances::fp16::fp16_to_float(*b++);
@@ -243,8 +261,18 @@ class InnerProductFP16_AVX2 {
         __m256 sum256 = _mm256_add_ps(sum256_1, sum256_2);
         float result = fp16_hsum256(sum256);
 
-        // Scalar residual for the unaligned tail — eliminated at compile-time if HasTail == false
+        // Vectorized residual tail for arbitrary dimensions
         if constexpr (HasTail) {
+            if ((last - a) >= 4) {
+                __m128 va4 = _mm_cvtph_ps(_mm_loadu_si64(a));
+                __m128 vb4 = _mm_cvtph_ps(_mm_loadu_si64(b));
+                __m128 prod4 = _mm_mul_ps(va4, vb4);
+                prod4 = _mm_add_ps(prod4, _mm_movehl_ps(prod4, prod4));
+                prod4 = _mm_add_ss(prod4, _mm_shuffle_ps(prod4, prod4, 1));
+                result += _mm_cvtss_f32(prod4);
+                a += 4;
+                b += 4;
+            }
             while (a < last) {
                 float fa = deglib::distances::fp16::fp16_to_float(*a++);
                 float fb = deglib::distances::fp16::fp16_to_float(*b++);

{deglib-0.2.5 → deglib-0.2.6}/lib/deglib/include/deglib/distance/fp16_l2.h

@@ -115,7 +115,27 @@ class L2FP16_AVX512 {
         float result = fp16_l2_hsum512(sum512);
 
         // Scalar residual for the unaligned tail — eliminated at compile-time if HasTail == false
+        // Vectorized residual tail for arbitrary dimensions
         if constexpr (HasTail) {
+            if ((last - a) >= 8) {
+                __m256 va8 = _mm256_cvtph_ps(_mm_loadu_si128(reinterpret_cast<const __m128i*>(a)));
+                __m256 vb8 = _mm256_cvtph_ps(_mm_loadu_si128(reinterpret_cast<const __m128i*>(b)));
+                __m256 diff8 = _mm256_sub_ps(va8, vb8);
+                result += fp16_l2_hsum256(_mm256_mul_ps(diff8, diff8));
+                a += 8;
+                b += 8;
+            }
+            if ((last - a) >= 4) {
+                __m128 va4 = _mm_cvtph_ps(_mm_loadu_si64(a));
+                __m128 vb4 = _mm_cvtph_ps(_mm_loadu_si64(b));
+                __m128 diff4 = _mm_sub_ps(va4, vb4);
+                __m128 prod4 = _mm_mul_ps(diff4, diff4);
+                prod4 = _mm_add_ps(prod4, _mm_movehl_ps(prod4, prod4));
+                prod4 = _mm_add_ss(prod4, _mm_shuffle_ps(prod4, prod4, 1));
+                result += _mm_cvtss_f32(prod4);
+                a += 4;
+                b += 4;
+            }
             while (a < last) {
                 float fa = deglib::distances::fp16::fp16_to_float(*a++);
                 float fb = deglib::distances::fp16::fp16_to_float(*b++);
@@ -251,8 +271,19 @@ class L2FP16_AVX2 {
         __m256 sum256 = _mm256_add_ps(sum256_1, sum256_2);
         float result = fp16_l2_hsum256(sum256);
 
-        // Scalar residual for the unaligned tail — eliminated at compile-time if HasTail == false
+        // Vectorized residual tail for arbitrary dimensions
         if constexpr (HasTail) {
+            if ((last - a) >= 4) {
+                __m128 va4 = _mm_cvtph_ps(_mm_loadu_si64(a));
+                __m128 vb4 = _mm_cvtph_ps(_mm_loadu_si64(b));
+                __m128 diff4 = _mm_sub_ps(va4, vb4);
+                __m128 prod4 = _mm_mul_ps(diff4, diff4);
+                prod4 = _mm_add_ps(prod4, _mm_movehl_ps(prod4, prod4));
+                prod4 = _mm_add_ss(prod4, _mm_shuffle_ps(prod4, prod4, 1));
+                result += _mm_cvtss_f32(prod4);
+                a += 4;
+                b += 4;
+            }
             while (a < last) {
                 float fa = deglib::distances::fp16::fp16_to_float(*a++);
                 float fb = deglib::distances::fp16::fp16_to_float(*b++);

{deglib-0.2.5 → deglib-0.2.6}/lib/deglib/include/deglib/distance/fp32_ip.h

@@ -120,8 +120,29 @@ class InnerProductFloat_AVX512 {
         _mm_store_ps(f, sum128);
         float result = f[0] + f[1] + f[2] + f[3];
 
-        // Scalar residual for the unaligned tail — eliminated at compile-time if HasTail == false
+        // Vectorized residual tail for arbitrary dimensions
         if constexpr (HasTail) {
+            if ((last - a) >= 8) {
+                __m256 va8 = _mm256_loadu_ps(a);
+                __m256 vb8 = _mm256_loadu_ps(b);
+                __m256 prod8 = _mm256_mul_ps(va8, vb8);
+                __m128 sum128 = _mm_add_ps(_mm256_castps256_ps128(prod8), _mm256_extractf128_ps(prod8, 1));
+                alignas(16) float f[4];
+                _mm_store_ps(f, sum128);
+                result += f[0] + f[1] + f[2] + f[3];
+                a += 8;
+                b += 8;
+            }
+            if ((last - a) >= 4) {
+                __m128 va4 = _mm_loadu_ps(a);
+                __m128 vb4 = _mm_loadu_ps(b);
+                __m128 prod4 = _mm_mul_ps(va4, vb4);
+                prod4 = _mm_add_ps(prod4, _mm_movehl_ps(prod4, prod4));
+                prod4 = _mm_add_ss(prod4, _mm_shuffle_ps(prod4, prod4, 1));
+                result += _mm_cvtss_f32(prod4);
+                a += 4;
+                b += 4;
+            }
             while (a < last) {
                 result = std::fma(*a++, *b++, result);
             }
@@ -245,8 +266,18 @@ class InnerProductFloat_AVX2 {
         __m256 sum256 = _mm256_add_ps(sum256_1, sum256_2);
         float result = fp32_hsum256(sum256);
 
-        // Scalar residual for the unaligned tail — eliminated at compile-time if HasTail == false
+        // Vectorized residual tail for arbitrary dimensions
         if constexpr (HasTail) {
+            if ((last - a) >= 4) {
+                __m128 va4 = _mm_loadu_ps(a);
+                __m128 vb4 = _mm_loadu_ps(b);
+                __m128 prod4 = _mm_mul_ps(va4, vb4);
+                prod4 = _mm_add_ps(prod4, _mm_movehl_ps(prod4, prod4));
+                prod4 = _mm_add_ss(prod4, _mm_shuffle_ps(prod4, prod4, 1));
+                result += _mm_cvtss_f32(prod4);
+                a += 4;
+                b += 4;
+            }
             while (a < last) {
                 result = std::fma(*a++, *b++, result);
             }

{deglib-0.2.5 → deglib-0.2.6}/lib/deglib/include/deglib/distance/fp32_l2.h

@@ -118,8 +118,27 @@ class L2Float_AVX512 {
         _mm_store_ps(f, sum128);
         float result = f[0] + f[1] + f[2] + f[3];
 
-        // Scalar residual for the unaligned tail — eliminated at compile-time if HasTail == false
+        // Vectorized residual tail for arbitrary dimensions
         if constexpr (HasTail) {
+            if ((last - a) >= 8) {
+                __m256 va8 = _mm256_loadu_ps(a);
+                __m256 vb8 = _mm256_loadu_ps(b);
+                __m256 diff8 = _mm256_sub_ps(va8, vb8);
+                result += fp32_l2_hsum256(_mm256_mul_ps(diff8, diff8));
+                a += 8;
+                b += 8;
+            }
+            if ((last - a) >= 4) {
+                __m128 va4 = _mm_loadu_ps(a);
+                __m128 vb4 = _mm_loadu_ps(b);
+                __m128 diff4 = _mm_sub_ps(va4, vb4);
+                __m128 prod4 = _mm_mul_ps(diff4, diff4);
+                prod4 = _mm_add_ps(prod4, _mm_movehl_ps(prod4, prod4));
+                prod4 = _mm_add_ss(prod4, _mm_shuffle_ps(prod4, prod4, 1));
+                result += _mm_cvtss_f32(prod4);
+                a += 4;
+                b += 4;
+            }
             while (a < last) {
                 float diff = *a++ - *b++;
                 result = std::fma(diff, diff, result);
@@ -243,8 +262,19 @@ class L2Float_AVX2 {
         __m256 sum256 = _mm256_add_ps(sum256_1, sum256_2);
         float result = fp32_l2_hsum256(sum256);
 
-        // Scalar residual for the unaligned tail — eliminated at compile-time if HasTail == false
+        // Vectorized residual tail for arbitrary dimensions
         if constexpr (HasTail) {
+            if ((last - a) >= 4) {
+                __m128 va4 = _mm_loadu_ps(a);
+                __m128 vb4 = _mm_loadu_ps(b);
+                __m128 diff4 = _mm_sub_ps(va4, vb4);
+                __m128 prod4 = _mm_mul_ps(diff4, diff4);
+                prod4 = _mm_add_ps(prod4, _mm_movehl_ps(prod4, prod4));
+                prod4 = _mm_add_ss(prod4, _mm_shuffle_ps(prod4, prod4, 1));
+                result += _mm_cvtss_f32(prod4);
+                a += 4;
+                b += 4;
+            }
             while (a < last) {
                 float diff = *a++ - *b++;
                 result = std::fma(diff, diff, result);

{deglib-0.2.5 → deglib-0.2.6}/lib/deglib/include/deglib/distance/int8_ip.h

@@ -176,6 +176,34 @@ class InnerProductInt8_AVX512_VNNI {
         int64_t result = int8_ip_hsum512(sum512) - (int8_ip_hsum512(q_comp) * 128);
 
         if constexpr (HasTail) {
+            const size_t rem = last - a;
+            if (rem >= 32) {
+                __m256i raw_a256 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(a));
+                __m256i raw_b256 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(b));
+                __m256i prod1 = _mm256_madd_epi16(_mm256_cvtepi8_epi16(_mm256_castsi256_si128(raw_a256)), _mm256_cvtepi8_epi16(_mm256_castsi256_si128(raw_b256)));
+                __m256i prod2 = _mm256_madd_epi16(_mm256_cvtepi8_epi16(_mm256_extracti128_si256(raw_a256, 1)), _mm256_cvtepi8_epi16(_mm256_extracti128_si256(raw_b256, 1)));
+                result += int8_ip_hsum256(_mm256_add_epi32(prod1, prod2));
+                a += 32;
+                b += 32;
+            }
+            if ((last - a) >= 16) {
+                __m128i raw_a128 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(a));
+                __m128i raw_b128 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(b));
+                __m256i prod = _mm256_madd_epi16(_mm256_cvtepi8_epi16(raw_a128), _mm256_cvtepi8_epi16(raw_b128));
+                result += int8_ip_hsum256(prod);
+                a += 16;
+                b += 16;
+            }
+            if ((last - a) >= 8) {
+                __m128i raw_a64 = _mm_loadu_si64(a);
+                __m128i raw_b64 = _mm_loadu_si64(b);
+                __m128i prod = _mm_madd_epi16(_mm_cvtepi8_epi16(raw_a64), _mm_cvtepi8_epi16(raw_b64));
+                prod = _mm_add_epi32(prod, _mm_shuffle_epi32(prod, _MM_SHUFFLE(1, 0, 3, 2)));
+                prod = _mm_add_epi32(prod, _mm_shuffle_epi32(prod, _MM_SHUFFLE(2, 3, 0, 1)));
+                result += static_cast<int64_t>(_mm_cvtsi128_si32(prod));
+                a += 8;
+                b += 8;
+            }
             while (a < last) {
                 result += int64_t(*a++) * int64_t(*b++);
             }
@@ -291,6 +319,34 @@ class InnerProductInt8_AVX512 {
         int64_t result = int8_ip_hsum512(sum512);
 
         if constexpr (HasTail) {
+            const size_t rem = last - a;
+            if (rem >= 32) {
+                __m256i raw_a256 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(a));
+                __m256i raw_b256 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(b));
+                __m256i prod1 = _mm256_madd_epi16(_mm256_cvtepi8_epi16(_mm256_castsi256_si128(raw_a256)), _mm256_cvtepi8_epi16(_mm256_castsi256_si128(raw_b256)));
+                __m256i prod2 = _mm256_madd_epi16(_mm256_cvtepi8_epi16(_mm256_extracti128_si256(raw_a256, 1)), _mm256_cvtepi8_epi16(_mm256_extracti128_si256(raw_b256, 1)));
+                result += int8_ip_hsum256(_mm256_add_epi32(prod1, prod2));
+                a += 32;
+                b += 32;
+            }
+            if ((last - a) >= 16) {
+                __m128i raw_a128 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(a));
+                __m128i raw_b128 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(b));
+                __m256i prod = _mm256_madd_epi16(_mm256_cvtepi8_epi16(raw_a128), _mm256_cvtepi8_epi16(raw_b128));
+                result += int8_ip_hsum256(prod);
+                a += 16;
+                b += 16;
+            }
+            if ((last - a) >= 8) {
+                __m128i raw_a64 = _mm_loadu_si64(a);
+                __m128i raw_b64 = _mm_loadu_si64(b);
+                __m128i prod = _mm_madd_epi16(_mm_cvtepi8_epi16(raw_a64), _mm_cvtepi8_epi16(raw_b64));
+                prod = _mm_add_epi32(prod, _mm_shuffle_epi32(prod, _MM_SHUFFLE(1, 0, 3, 2)));
+                prod = _mm_add_epi32(prod, _mm_shuffle_epi32(prod, _MM_SHUFFLE(2, 3, 0, 1)));
+                result += static_cast<int64_t>(_mm_cvtsi128_si32(prod));
+                a += 8;
+                b += 8;
+            }
             while (a < last) {
                 result += int64_t(*a++) * int64_t(*b++);
             }
@@ -410,6 +466,16 @@ class InnerProductInt8_AVX2_VNNI {
         int64_t result = int8_ip_hsum256(sum256) - (int8_ip_hsum256(q_comp) * 128);
 
         if constexpr (HasTail) {
+            if ((last - a) >= 8) {
+                __m128i raw_a64 = _mm_loadu_si64(a);
+                __m128i raw_b64 = _mm_loadu_si64(b);
+                __m128i prod = _mm_madd_epi16(_mm_cvtepi8_epi16(raw_a64), _mm_cvtepi8_epi16(raw_b64));
+                prod = _mm_add_epi32(prod, _mm_shuffle_epi32(prod, _MM_SHUFFLE(1, 0, 3, 2)));
+                prod = _mm_add_epi32(prod, _mm_shuffle_epi32(prod, _MM_SHUFFLE(2, 3, 0, 1)));
+                result += static_cast<int64_t>(_mm_cvtsi128_si32(prod));
+                a += 8;
+                b += 8;
+            }
             while (a < last) {
                 result += int64_t(*a++) * int64_t(*b++);
             }
@@ -524,6 +590,16 @@ class InnerProductInt8_AVX2 {
         int64_t result = int8_ip_hsum256(sum256);
 
         if constexpr (HasTail) {
+            if ((last - a) >= 8) {
+                __m128i raw_a64 = _mm_loadu_si64(a);
+                __m128i raw_b64 = _mm_loadu_si64(b);
+                __m128i prod = _mm_madd_epi16(_mm_cvtepi8_epi16(raw_a64), _mm_cvtepi8_epi16(raw_b64));
+                prod = _mm_add_epi32(prod, _mm_shuffle_epi32(prod, _MM_SHUFFLE(1, 0, 3, 2)));
+                prod = _mm_add_epi32(prod, _mm_shuffle_epi32(prod, _MM_SHUFFLE(2, 3, 0, 1)));
+                result += static_cast<int64_t>(_mm_cvtsi128_si32(prod));
+                a += 8;
+                b += 8;
+            }
             while (a < last) {
                 result += int64_t(*a++) * int64_t(*b++);
             }