Function random_vector

cpp/base/random.hpp:91–135

 */
template <typename T>
inline auto random_vector(uint64_t size, std::pair<T, T> range)
{
    auto& mersenne_engine = random_engine();
    if constexpr (base::is_floating_point_v<T>) {
        std::vector<T> ret;
        ret.resize(size);
        using actual_type = std::conditional_t<std::floating_point<T>, T, float>;
        std::uniform_real_distribution<actual_type> value_dist{static_cast<actual_type>(range.first), static_cast<actual_type>(range.second)};
        auto value_gen = [&value_dist, &mersenne_engine]() {
            return value_dist(mersenne_engine);
        };
        std::generate(ret.begin(), ret.end(), value_gen);
        return ret;
    } else if constexpr (std::is_same_v<bool, T>) {
        boost::container::vector<T> ret;
        ret.resize(size);
        std::bernoulli_distribution value_dist(0.5);
        auto value_gen = [&value_dist, &mersenne_engine]() {
            return value_dist(mersenne_engine);
        };
        std::generate(ret.begin(), ret.end(), value_gen);
        return ret;
    } else if constexpr (sizeof(T) == 1) {
        std::vector<T> ret;
        ret.resize(size);
        // Handle 8-bit types separately
        using dist_type = std::conditional_t<std::is_signed_v<T>, int, unsigned int>;
        std::uniform_int_distribution<dist_type> value_dist{range.first, range.second};
        auto value_gen = [&value_dist, &mersenne_engine]() {
            return static_cast<T>(value_dist(mersenne_engine));
        };
        std::generate(ret.begin(), ret.end(), value_gen);
        return ret;
    } else {
        std::vector<T> ret;
        ret.resize(size);
        std::uniform_int_distribution<T> value_dist{range.first, range.second};

        auto value_gen = [&value_dist, &mersenne_engine]() {
            return value_dist(mersenne_engine);
        };
        std::generate(ret.begin(), ret.end(), value_gen);
        return ret;
    }
}

/**
 * @brief Generates a random vector of a given type and size.