groups.hpp

/****************************************************************************
 *  hipipe library
 *  Copyright (c) 2017, Cognexa Solutions s.r.o.
 *  Copyright (c) 2018, Iterait a.s.
 *  Author(s) Filip Matzner
 *
 *  This file is distributed under the MIT License.
 *  See the accompanying file LICENSE.txt for the complete license agreement.
 ****************************************************************************/
 
#ifndef HIPIPE_CORE_GROUPS_HPP
#define HIPIPE_CORE_GROUPS_HPP
 
#include <hipipe/core/utility/random.hpp>
 
#include <range/v3/action/insert.hpp>
#include <range/v3/action/shuffle.hpp>
#include <range/v3/algorithm/all_of.hpp>
#include <range/v3/algorithm/copy.hpp>
#include <range/v3/numeric/accumulate.hpp>
#include <range/v3/range/conversion.hpp>
#include <range/v3/view/concat.hpp>
#include <range/v3/view/drop.hpp>
#include <range/v3/view/filter.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/repeat_n.hpp>
#include <range/v3/view/take.hpp>
 
#include <vector>
 
namespace hipipe {
 
namespace rga = ranges::actions;
namespace rgv = ranges::views;
 
 
template<typename Prng = std::mt19937&>
std::vector<std::size_t> generate_groups(std::size_t size, std::vector<double> ratio,
                                         Prng&& gen = utility::random_generator)
{
    // check all ratios non-negative
    assert(ranges::all_of(ratio, [](double d) { return d >= 0; }));
 
    // check positive ratio sum
    double ratio_sum = ranges::accumulate(ratio, 0.);
    assert(ratio_sum > 0);
 
    // remove trailing zeros
    ratio.erase(std::find_if(ratio.rbegin(), ratio.rend(), [](double r) { return r > 0; }).base(),
                ratio.end());
 
    // scale to [0, 1]
    for (double& r : ratio) r /= ratio_sum;
 
    std::vector<std::size_t> groups;
    groups.reserve(size);
 
    for (std::size_t i = 0; i < ratio.size(); ++i) {
        std::size_t count = std::lround(ratio[i] * size);
        // take all the remaining elements if this is the last non-zero group
        if (i + 1 == ratio.size()) count = size - groups.size();
        rga::insert(groups, groups.end(), rgv::repeat_n(i, count));
    }
 
    rga::shuffle(groups, gen);
    return groups;
}
 
template<typename Prng = std::mt19937&>
std::vector<std::vector<std::size_t>>
generate_groups(std::size_t n, std::size_t size,
                const std::vector<double>& volatile_ratio,
                const std::vector<double>& fixed_ratio,
                Prng&& gen = utility::random_generator)
{
    std::size_t volatile_size = volatile_ratio.size();
    auto full_ratio = ranges::to_vector(rgv::concat(volatile_ratio, fixed_ratio));
 
    std::vector<std::vector<std::size_t>> all_groups;
    std::vector<std::size_t> initial_groups = generate_groups(size, full_ratio, gen);
 
    for (std::size_t i = 0; i < n; ++i) {
        auto groups = initial_groups;
        // select those groups, which are volatile (those will be replaced)
        auto groups_volatile =
          rgv::filter(groups, [volatile_size](std::size_t l) { return l < volatile_size; });
        // count the number of volatile groups
        std::size_t volatile_count = ranges::distance(groups_volatile);
        // generate the replacement
        auto groups_volatile_new = generate_groups(volatile_count, volatile_ratio, gen);
        // replace
        ranges::copy(groups_volatile_new, groups_volatile.begin());
        // store
        all_groups.emplace_back(std::move(groups));
    }
 
    return all_groups;
}
 
}  // end namespace hipipe
#endif