clean_factor.hpp

Go to the documentation of this file.

#ifndef SCRAN_AGGREGATE_CLEAN_FACTORS_HPP
#define SCRAN_AGGREGATE_CLEAN_FACTORS_HPP
 
#include <unordered_map>
#include <vector>
#include <algorithm>
 
namespace scran_aggregate {
 
template<typename Factor_, typename Output_>
std::vector<Factor_> clean_factor(size_t n, const Factor_* factor, Output_* cleaned) {
    auto unique = [&]{ // scoping this in an IIFE to release map memory sooner.
        std::unordered_map<Factor_, Output_> mapping;
        for (size_t i = 0; i < n; ++i) {
            auto current = factor[i];
            auto mIt = mapping.find(current);
            if (mIt != mapping.end()) {
                cleaned[i] = mIt->second;
            } else {
                Output_ alt = mapping.size();
                mapping[current] = alt;
                cleaned[i] = alt;
            }
        }
        return std::vector<std::pair<Factor_, Output_> >(mapping.begin(), mapping.end());
    }();
 
    // Remapping to a sorted set.
    std::sort(unique.begin(), unique.end());
    size_t nuniq = unique.size();
    std::vector<Output_> remapping(nuniq);
    std::vector<Factor_> output(nuniq);
    for (size_t u = 0; u < nuniq; ++u) {
        remapping[unique[u].second] = u;
        output[u] = unique[u].first;
    }
 
    // Mapping each cell to its sorted factor.
    for (size_t i = 0; i < n; ++i) {
        cleaned[i] = remapping[cleaned[i]];
    }
 
    return output;
}
 
}
 
#endif