From 3ecf1c4ef4a3b4eacb07db181d5230e47a16b7ba Mon Sep 17 00:00:00 2001
From: Carles Fernandez <carles.fernandez@gmail.com>
Date: Wed, 1 Nov 2023 09:17:11 +0100
Subject: [PATCH] volk_gnsssdr: improve random integer generation

---
 .../volk_gnsssdr/lib/qa_utils.cc              | 115 ++++++++++++------
 1 file changed, 75 insertions(+), 40 deletions(-)

diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/qa_utils.cc b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/qa_utils.cc
index 311122427..2257e51f0 100644
--- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/qa_utils.cc
+++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/qa_utils.cc
@@ -33,59 +33,94 @@ void random_values(T *buf, unsigned int n, std::default_random_engine &e1)
 
 void load_random_data(void *data, volk_gnsssdr_type_t type, unsigned int n)
 {
-    std::random_device r;
-    std::default_random_engine e1(r());
-    std::default_random_engine e2(r());
+    std::random_device rnd_device;
+    std::default_random_engine rnd_engine(rnd_device());
 
     if (type.is_complex) n *= 2;
 
     if (type.is_float)
         {
             if (type.size == 8)
-                random_values<double>((double *)data, n, e1);
+                random_values<double>((double *)data, n, rnd_engine);
             else
-                random_values<float>((float *)data, n, e1);
+                random_values<float>((float *)data, n, rnd_engine);
         }
     else
         {
-            float int_max = float(uint64_t(2) << (type.size * 8));
-            if (type.is_signed) int_max /= 2.0;
-            std::uniform_real_distribution<float> uniform_dist(-int_max, int_max);
-            for (unsigned int i = 0; i < n; i++)
+            switch (type.size)
                 {
-                    float scaled_rand = uniform_dist(e2);
-
-                    switch (type.size)
+                case 8:
+                    if (type.is_signed)
                         {
-                        case 8:
-                            if (type.is_signed)
-                                ((int64_t *)data)[i] = (int64_t)scaled_rand;
-                            else
-                                ((uint64_t *)data)[i] = (uint64_t)scaled_rand;
-                            break;
-                        case 4:
-                            if (type.is_signed)
-                                ((int32_t *)data)[i] = (int32_t)scaled_rand;
-                            else
-                                ((uint32_t *)data)[i] = (uint32_t)scaled_rand;
-                            break;
-                        case 2:
-                            // 16 bit multiplication saturates very fast
-                            // we produce here only 3 bits input range
-                            if (type.is_signed)
-                                ((int16_t *)data)[i] = (int16_t)((int16_t)scaled_rand % 8);
-                            else
-                                ((uint16_t *)data)[i] = (uint16_t)(int16_t)((int16_t)scaled_rand % 8);
-                            break;
-                        case 1:
-                            if (type.is_signed)
-                                ((int8_t *)data)[i] = (int8_t)scaled_rand;
-                            else
-                                ((uint8_t *)data)[i] = (uint8_t)scaled_rand;
-                            break;
-                        default:
-                            throw "load_random_data: no support for data size > 8 or < 1";  // no shenanigans here
+                            std::uniform_int_distribution<int64_t> uniform_dist(
+                                std::numeric_limits<int64_t>::min(),
+                                std::numeric_limits<int64_t>::max());
+                            for (unsigned int i = 0; i < n; i++)
+                                ((int64_t *)data)[i] = uniform_dist(rnd_engine);
                         }
+                    else
+                        {
+                            std::uniform_int_distribution<uint64_t> uniform_dist(
+                                std::numeric_limits<uint64_t>::min(),
+                                std::numeric_limits<uint64_t>::max());
+                            for (unsigned int i = 0; i < n; i++)
+                                ((uint64_t *)data)[i] = uniform_dist(rnd_engine);
+                        }
+                    break;
+                case 4:
+                    if (type.is_signed)
+                        {
+                            std::uniform_int_distribution<int32_t> uniform_dist(
+                                std::numeric_limits<int32_t>::min(),
+                                std::numeric_limits<int32_t>::max());
+                            for (unsigned int i = 0; i < n; i++)
+                                ((int32_t *)data)[i] = uniform_dist(rnd_engine);
+                        }
+                    else
+                        {
+                            std::uniform_int_distribution<uint32_t> uniform_dist(
+                                std::numeric_limits<uint32_t>::min(),
+                                std::numeric_limits<uint32_t>::max());
+                            for (unsigned int i = 0; i < n; i++)
+                                ((uint32_t *)data)[i] = uniform_dist(rnd_engine);
+                        }
+                    break;
+                case 2:
+                    if (type.is_signed)
+                        {
+                            std::uniform_int_distribution<int16_t> uniform_dist(-7, 7);
+                            for (unsigned int i = 0; i < n; i++)
+                                ((int16_t *)data)[i] = uniform_dist(rnd_engine);
+                        }
+                    else
+                        {
+                            std::uniform_int_distribution<uint16_t> uniform_dist(
+                                std::numeric_limits<uint16_t>::min(),
+                                std::numeric_limits<uint16_t>::max());
+                            for (unsigned int i = 0; i < n; i++)
+                                ((uint16_t *)data)[i] = uniform_dist(rnd_engine);
+                        }
+                    break;
+                case 1:
+                    if (type.is_signed)
+                        {
+                            std::uniform_int_distribution<int16_t> uniform_dist(
+                                std::numeric_limits<int8_t>::min(),
+                                std::numeric_limits<int8_t>::max());
+                            for (unsigned int i = 0; i < n; i++)
+                                ((int8_t *)data)[i] = uniform_dist(rnd_engine);
+                        }
+                    else
+                        {
+                            std::uniform_int_distribution<uint16_t> uniform_dist(
+                                std::numeric_limits<uint8_t>::min(),
+                                std::numeric_limits<uint8_t>::max());
+                            for (unsigned int i = 0; i < n; i++)
+                                ((uint8_t *)data)[i] = uniform_dist(rnd_engine);
+                        }
+                    break;
+                default:
+                    throw "load_random_data: no support for data size > 8 or < 1";  // no shenanigans here
                 }
         }
 }