Sort of Distributed Data

#include <algorithm>
#include <fstream>
#include <iostream>
#include <random>
#include <tuple>
#include <vector>

template <class ValType, class Dist>
std::vector<ValType> generate_experiment(size_t n, Dist dist)
{
    std::random_device rd;
    std::mt19937 reng(rd());

    std::vector<ValType> vec;
    vec.reserve(n);

    while (vec.size() < n) {
        vec.push_back(dist(reng));
    }

    return vec;
}

unsigned long bucket_sort(std::vector<double>& data)
{
    size_t n = data.size();
    auto mm = std::minmax_element(data.begin(), data.end());

    double inf = *std::get<0>(mm), sup = *std::get<1>(mm);
    double step = (sup - inf + 1) / n;

    std::vector<std::vector<double>> buckets(n);

    unsigned long cnt = 0;

    for (double elem : data) {
        size_t bucket_idx = (elem - inf) / step;
        cnt += buckets[bucket_idx].size();
        buckets[bucket_idx].push_back(elem);
    }

    return cnt;
}

int main(int argc, char const* argv[])
{
    constexpr size_t exp_cnt = 256;

    for (int n = 16; n < 8192; n += 16) {
        std::ofstream fout_u("uniform.csv", std::ios::app);
        std::uniform_real_distribution<double> dist_u(0, n);
        for (size_t i = 0; i < exp_cnt; i++) {
            std::vector<double> vec = generate_experiment<double>(n, dist_u);
            auto cnt = bucket_sort(vec);

            fout_u << n << "," << cnt << std::endl;
            printf("%s \t %d \t %lu \t %lu \n", "uniform", n, i, cnt);
        }
        fout_u.close();

        std::ofstream fout_n("normal.csv", std::ios::app);
        std::normal_distribution<double> dist_n(0, n / 3);
        for (size_t i = 0; i < exp_cnt; i++) {
            std::vector<double> vec = generate_experiment<double>(n, dist_n);
            auto cnt = bucket_sort(vec);

            fout_n << n << "," << cnt << std::endl;
            printf("%s \t %d \t %lu \t %lu \n", "uniform", n, i, cnt);
        }
        fout_n.close();
    }

    return 0;
}