create_factor.hpp

Go to the documentation of this file.

#ifndef FACTORIZE_CLEAN_FACTOR_HPP
#define FACTORIZE_CLEAN_FACTOR_HPP
 
#include <unordered_map>
#include <vector>
#include <algorithm>
#include <cstddef>
 
#include "sanisizer/sanisizer.hpp"
 
#include "utils.hpp"
 
namespace factorize {
 
template<typename Input_, typename Code_>
std::vector<Input_> create_factor(const std::size_t n, const Input_* const input, Code_* const codes) {
    auto unique = [&]{ // scoping this in an IIFE to release map memory sooner.
        std::unordered_map<Input_, Code_> mapping;
        for (I<decltype(n)> i = 0; i < n; ++i) {
            const auto current = input[i];
            const auto mIt = mapping.find(current);
            if (mIt != mapping.end()) {
                codes[i] = mIt->second;
            } else {
                Code_ alt = mapping.size();
                mapping[current] = alt;
                codes[i] = alt;
            }
        }
        return std::vector<std::pair<Input_, Code_> >(mapping.begin(), mapping.end());
    }();
 
    // Remapping to a sorted set.
    std::sort(unique.begin(), unique.end());
    const auto nuniq = unique.size();
    auto remapping = sanisizer::create<std::vector<Code_> >(nuniq);
    auto output = sanisizer::create<std::vector<Input_> >(nuniq);
    for (I<decltype(nuniq)> u = 0; u < nuniq; ++u) {
        remapping[unique[u].second] = u;
        output[u] = unique[u].first;
    }
 
    // Mapping each cell to its sorted factor.
    for (I<decltype(n)> i = 0; i < n; ++i) {
        codes[i] = remapping[codes[i]];
    }
 
    return output;
}
 
}
 
#endif