test(regression): add standalone dataset determinism test target with bit-exact integer PRNG

Author: Neiko2002

cpp/test/CMakeLists.txt

@@ -23,6 +23,9 @@ endmacro()
 # Phase 1 Test Target: CPU Features & Build Verification
 add_deglib_test(test_cpu_features src/test_cpu_features.cpp)
 
+# Dataset Determinism Regression test
+add_deglib_test(test_dataset_determinism src/regression/test_dataset_determinism.cpp)
+
 # Metric Regression tests
 add_deglib_test(test_l2_regression src/regression/metric/test_l2_regression.cpp)
 add_deglib_test(test_innerproduct_regression src/regression/metric/test_innerproduct_regression.cpp)
@@ -32,7 +35,7 @@ add_deglib_test(test_l2_uint8_regression src/regression/metric/test_l2_uint8_reg
 add_deglib_test(test_l2_builder_regression src/regression/builder/test_l2_builder_regression.cpp)
 
 # Meta target to build all regression tests
-add_custom_target(test_regression DEPENDS test_l2_regression test_innerproduct_regression test_l2_uint8_regression test_l2_builder_regression)
+add_custom_target(test_regression DEPENDS test_dataset_determinism test_l2_regression test_innerproduct_regression test_l2_uint8_regression test_l2_builder_regression)
 
 
 

cpp/test/src/regression/test_dataset_determinism.cpp

@@ -0,0 +1,60 @@
+#include "test_regression.h"
+
+TEST(DeglibDatasetDeterminism, ClusteredDatasetBitExactness)
+{
+    const size_t dim = 128;
+    const size_t base_count = 100000;
+    const size_t query_count = 100;
+    const size_t num_clusters = 1000;
+
+    std::vector<float> base_data;
+    std::vector<float> query_data;
+    generate_synthetic_clustered_dataset(base_count, dim, base_data, query_data, query_count, num_clusters);
+
+    const uint64_t base_hash = float_vector_checksum(base_data);
+    const uint64_t query_hash = float_vector_checksum(query_data);
+
+    auto gt_l2 = compute_groundtruth_l2(base_data, base_count, query_data, query_count, dim, 10);
+    const uint64_t gt_l2_hash = groundtruth_checksum(gt_l2);
+
+    auto gt_ip = compute_groundtruth_innerproduct(base_data, base_count, query_data, query_count, dim, 10);
+    const uint64_t gt_ip_hash = groundtruth_checksum(gt_ip);
+
+    std::cout << "[DatasetDeterminism] base_hash = 0x" << std::hex << base_hash << std::dec << std::endl;
+    std::cout << "[DatasetDeterminism] query_hash = 0x" << std::hex << query_hash << std::dec << std::endl;
+    std::cout << "[DatasetDeterminism] gt_l2_hash = 0x" << std::hex << gt_l2_hash << std::dec << std::endl;
+    std::cout << "[DatasetDeterminism] gt_ip_hash = 0x" << std::hex << gt_ip_hash << std::dec << std::endl;
+
+    // Hardcoded expected hashes computed on Windows
+    // Checksum verification ensures 100% bit-exact dataset generation and groundtruth across OS/compilers.
+    EXPECT_EQ(base_hash, 0xef1c7686c6a529f4ULL) << "base_data checksum mismatch across platforms!";
+    EXPECT_EQ(query_hash, 0xea1c88f507eeb188ULL) << "query_data checksum mismatch across platforms!";
+    EXPECT_EQ(gt_l2_hash, 0xe04ea5bc6428cc3dULL) << "gt_l2 checksum mismatch across platforms!";
+    EXPECT_EQ(gt_ip_hash, 0x10c26c33619a5928ULL) << "gt_ip checksum mismatch across platforms!";
+}
+
+TEST(DeglibDatasetDeterminism, Uint8ClusteredDatasetBitExactness)
+{
+    const size_t dim = 128;
+    const size_t base_count = 100000;
+    const size_t query_count = 100;
+    const size_t num_clusters = 1000;
+
+    std::vector<uint8_t> base_data;
+    std::vector<uint8_t> query_data;
+    generate_synthetic_clustered_dataset_uint8(base_count, dim, base_data, query_data, query_count, num_clusters);
+
+    const uint64_t base_hash = fnv1a_64(base_data.data(), base_data.size());
+    const uint64_t query_hash = fnv1a_64(query_data.data(), query_data.size());
+
+    auto gt_u8 = compute_groundtruth_l2_uint8(base_data, base_count, query_data, query_count, dim, 10);
+    const uint64_t gt_u8_hash = groundtruth_checksum(gt_u8);
+
+    std::cout << "[DatasetDeterminism] uint8_base_hash = 0x" << std::hex << base_hash << std::dec << std::endl;
+    std::cout << "[DatasetDeterminism] uint8_query_hash = 0x" << std::hex << query_hash << std::dec << std::endl;
+    std::cout << "[DatasetDeterminism] gt_u8_hash = 0x" << std::hex << gt_u8_hash << std::dec << std::endl;
+
+    EXPECT_EQ(base_hash, 0x4d94d32f77a245daULL) << "uint8_base_data checksum mismatch across platforms!";
+    EXPECT_EQ(query_hash, 0x5493b1b61d1b8a94ULL) << "uint8_query_data checksum mismatch across platforms!";
+    EXPECT_EQ(gt_u8_hash, 0xde241e831af209fcULL) << "gt_u8 checksum mismatch across platforms!";
+}

cpp/test/src/regression/test_regression.h

@@ -84,11 +84,14 @@ inline static uint32_t deglib_prng_next(uint32_t& state) {
 
 inline static float deglib_prng_float(uint32_t& state, float min_val, float max_val) {
     uint32_t val = deglib_prng_next(state) >> 8; // 24-bit integer
-    float u = static_cast<float>(val) * (1.0f / 16777215.0f);
-    return min_val + u * (max_val - min_val);
+    float u = static_cast<float>(val) / 16777215.0f;
+    float range = max_val - min_val;
+    return min_val + u * range;
 }
 
 // Generate cross-platform deterministic clustered dataset (Gaussian Mixture with fixed seed)
+// Uses pure 32-bit integer arithmetic and exact integer-to-float conversion to guarantee
+// 100% bit-exact float vectors across MSVC, GCC, and Clang on all CPU architectures.
 inline static void generate_synthetic_clustered_dataset(size_t count, size_t dim, std::vector<float>& base,
                                                  std::vector<float>& query, size_t query_count,
                                                  size_t num_clusters = 20)
@@ -97,13 +100,14 @@ inline static void generate_synthetic_clustered_dataset(size_t count, size_t dim
     query.resize(query_count * dim);
 
     uint32_t rng_state = 42;
-    std::vector<std::vector<float>> centroids(num_clusters, std::vector<float>(dim));
+    std::vector<std::vector<int32_t>> centroids(num_clusters, std::vector<int32_t>(dim));
 
     for (size_t c = 0; c < num_clusters; ++c)
     {
         for (size_t d = 0; d < dim; ++d)
         {
-            centroids[c][d] = deglib_prng_float(rng_state, -1000.0f, 1000.0f);
+            uint32_t val = deglib_prng_next(rng_state);
+            centroids[c][d] = static_cast<int32_t>(val % 2001) - 1000; // [-1000, 1000]
         }
     }
 
@@ -112,8 +116,9 @@ inline static void generate_synthetic_clustered_dataset(size_t count, size_t dim
         size_t c = i % num_clusters;
         for (size_t d = 0; d < dim; ++d)
         {
-            float noise = deglib_prng_float(rng_state, -100.0f, 100.0f);
-            base[i * dim + d] = centroids[c][d] + noise;
+            uint32_t val = deglib_prng_next(rng_state);
+            int32_t noise = static_cast<int32_t>(val % 201) - 100; // [-100, 100]
+            base[i * dim + d] = static_cast<float>(centroids[c][d] + noise);
         }
     }
 
@@ -122,8 +127,9 @@ inline static void generate_synthetic_clustered_dataset(size_t count, size_t dim
         size_t c = q % num_clusters;
         for (size_t d = 0; d < dim; ++d)
         {
-            float noise = deglib_prng_float(rng_state, -100.0f, 100.0f);
-            query[q * dim + d] = centroids[c][d] + noise;
+            uint32_t val = deglib_prng_next(rng_state);
+            int32_t noise = static_cast<int32_t>(val % 201) - 100; // [-100, 100]
+            query[q * dim + d] = static_cast<float>(centroids[c][d] + noise);
         }
     }
 }
@@ -381,63 +387,5 @@ inline static uint64_t groundtruth_checksum(const std::vector<std::vector<uint32
     return hash;
 }
 
-TEST(DeglibDatasetDeterminism, ClusteredDatasetBitExactness)
-{
-    const size_t dim = 128;
-    const size_t base_count = 100000;
-    const size_t query_count = 100;
-    const size_t num_clusters = 1000;
-
-    std::vector<float> base_data;
-    std::vector<float> query_data;
-    generate_synthetic_clustered_dataset(base_count, dim, base_data, query_data, query_count, num_clusters);
-
-    const uint64_t base_hash = float_vector_checksum(base_data);
-    const uint64_t query_hash = float_vector_checksum(query_data);
-
-    auto gt_l2 = compute_groundtruth_l2(base_data, base_count, query_data, query_count, dim, 10);
-    const uint64_t gt_l2_hash = groundtruth_checksum(gt_l2);
-
-    auto gt_ip = compute_groundtruth_innerproduct(base_data, base_count, query_data, query_count, dim, 10);
-    const uint64_t gt_ip_hash = groundtruth_checksum(gt_ip);
-
-    std::cout << "[DatasetDeterminism] base_hash = 0x" << std::hex << base_hash << std::dec << std::endl;
-    std::cout << "[DatasetDeterminism] query_hash = 0x" << std::hex << query_hash << std::dec << std::endl;
-    std::cout << "[DatasetDeterminism] gt_l2_hash = 0x" << std::hex << gt_l2_hash << std::dec << std::endl;
-    std::cout << "[DatasetDeterminism] gt_ip_hash = 0x" << std::hex << gt_ip_hash << std::dec << std::endl;
-
-    // Hardcoded expected hashes computed on Windows
-    // Checksum verification ensures 100% bit-exact dataset generation and groundtruth across OS/compilers.
-    EXPECT_EQ(base_hash, 0x9843814b67933ae7ULL) << "base_data checksum mismatch across platforms!";
-    EXPECT_EQ(query_hash, 0xf632af44f678450dULL) << "query_data checksum mismatch across platforms!";
-    EXPECT_EQ(gt_l2_hash, 0xecfc8c14d4c8a2dcULL) << "gt_l2 checksum mismatch across platforms!";
-    EXPECT_EQ(gt_ip_hash, 0xe37a489e10fb4a5fULL) << "gt_ip checksum mismatch across platforms!";
-}
-
-TEST(DeglibDatasetDeterminism, Uint8ClusteredDatasetBitExactness)
-{
-    const size_t dim = 128;
-    const size_t base_count = 100000;
-    const size_t query_count = 100;
-    const size_t num_clusters = 1000;
-
-    std::vector<uint8_t> base_data;
-    std::vector<uint8_t> query_data;
-    generate_synthetic_clustered_dataset_uint8(base_count, dim, base_data, query_data, query_count, num_clusters);
-
-    const uint64_t base_hash = fnv1a_64(base_data.data(), base_data.size());
-    const uint64_t query_hash = fnv1a_64(query_data.data(), query_data.size());
-
-    auto gt_u8 = compute_groundtruth_l2_uint8(base_data, base_count, query_data, query_count, dim, 10);
-    const uint64_t gt_u8_hash = groundtruth_checksum(gt_u8);
-
-    std::cout << "[DatasetDeterminism] uint8_base_hash = 0x" << std::hex << base_hash << std::dec << std::endl;
-    std::cout << "[DatasetDeterminism] uint8_query_hash = 0x" << std::hex << query_hash << std::dec << std::endl;
-    std::cout << "[DatasetDeterminism] gt_u8_hash = 0x" << std::hex << gt_u8_hash << std::dec << std::endl;
-
-    EXPECT_EQ(base_hash, 0x4d94d32f77a245daULL) << "uint8_base_data checksum mismatch across platforms!";
-    EXPECT_EQ(query_hash, 0x5493b1b61d1b8a94ULL) << "uint8_query_data checksum mismatch across platforms!";
-    EXPECT_EQ(gt_u8_hash, 0xde241e831af209fcULL) << "gt_u8 checksum mismatch across platforms!";
-}