Какой алгоритм рандомизации для чисел с плавающей запятой выбрать?

RandomBetweenDouble(0.0, numeric_limits<double>::max()))

double RandomBetweenDouble(double a, double b)
{
    random_device rd;                   //Недетерминированный генератор
    mt19937 gen(rd());                  //Генерация методом вихря Мерсенна
    uniform_real_distribution<> dist(a, b); //Задание границ генерации числа a <= с <= b
    double c = dist(gen);                   //Генерация
    return c;
}

template <typename T>
T RandomBetween(T a, T b)
{
    //Генерация числа с: a<=c<=b
    return c;
}

#include <random>
 
template <typename T>
T RandomBetween(T a, T b)
{
 
    //Генерация числа с: a<=c<=b
    return a + rand() % (b - a + 1);
}

#include <iostream>
#include <random>
#include <stdexcept>
 
#include <boost/multiprecision/cpp_int.hpp>
 
using BigInt = boost::multiprecision::cpp_int;
 
BigInt RandomBetween(const BigInt &a, const BigInt &b) {
  std::random_device rd;
 
  uint32_t rd_max = 0xFFFFFFFFu;
  std::uniform_int_distribution<uint32_t> dist(0, rd_max - 1);
 
  BigInt result = 0;
  BigInt c = b - a;
  BigInt d = c * c * c;
 
  while (result < d) {
    result = (result * rd_max) + dist(rd);
  }
 
  result = a + (result % (c + 1));
  return result;
}
 
int main() {
 
  BigInt a{"12345678901234567890123456789012345678901234567890"};
  BigInt b{"99999999999999999999999999999999999999999999999999"};
 
  std::cout << a << std::endl;
  std::cout << b << std::endl;
 
  for (size_t i = 0; i < 20; ++i) {
    std::cout << RandomBetween(a, b) << std::endl;
  }
 
  return 0;
}

uint64_t RandomBetweenuint64_t(uint64_t a, uint64_t b)
{
    random_device rd;                       //Недетерминированный генератор
    uniform_int_distribution<uint64_t> dist(a, b);  //Задание границ генерации числа a <= с <= b
    uint64_t c = dist(rd);                          //Генерация
    return c;
}

uint64_t RandomBetweenuint64_tByMult(uint64_t a, uint64_t b) 
{
    uint32_t coef = 1;
 
    if ((b - a) > numeric_limits<unsigned long>::max()) 
    { 
        coef = (b - a) / numeric_limits<unsigned long>::max();
    }
 
    random_device rd;
    uniform_int_distribution<uint32_t> dist1(numeric_limits<unsigned long>::min(), numeric_limits<unsigned long>::max());
    uniform_int_distribution<uint32_t> dist2(1, coef);
 
    uint32_t randomBetween = 0;
 
    coef = dist2(rd);
 
    for (size_t i = 0; i < coef; i++)
    {
        randomBetween += dist1(rd);
    }
 
    uint64_t c = a + randomBetween;
    return c;
}