frequency_distribution.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <functional>
#include <iterator>
#include <map>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace statcpp {
 
// ============================================================================
// Return value structures
// ============================================================================
 
template <typename T>
struct frequency_entry {
    T value;                                
    std::size_t count;                      
    double relative_frequency;              
    std::size_t cumulative_count;           
    double cumulative_relative_frequency;   
};
 
template <typename T>
struct frequency_table_result {
    std::vector<frequency_entry<T>> entries;  
    std::size_t total_count;                   
};
 
// ============================================================================
// Frequency Table
// ============================================================================
 
template <typename Iterator>
auto frequency_table(Iterator first, Iterator last)
    -> frequency_table_result<typename std::iterator_traits<Iterator>::value_type>
{
    using value_type = typename std::iterator_traits<Iterator>::value_type;
 
    if (first == last) {
        return {{}, 0};
    }
 
    // Count frequencies (std::map maintains sorted order)
    std::map<value_type, std::size_t> freq_map;
    for (auto it = first; it != last; ++it) {
        ++freq_map[*it];
    }
 
    std::size_t total = static_cast<std::size_t>(std::distance(first, last));
    double total_d = static_cast<double>(total);
 
    // Build result
    std::vector<frequency_entry<value_type>> entries;
    entries.reserve(freq_map.size());
 
    std::size_t cumulative = 0;
    for (const auto& pair : freq_map) {
        cumulative += pair.second;
        entries.push_back({
            pair.first,
            pair.second,
            static_cast<double>(pair.second) / total_d,
            cumulative,
            static_cast<double>(cumulative) / total_d
        });
    }
 
    return {std::move(entries), total};
}
 
template <typename Iterator, typename Projection>
auto frequency_table(Iterator first, Iterator last, Projection proj)
    -> frequency_table_result<std::invoke_result_t<Projection,
           typename std::iterator_traits<Iterator>::value_type>>
{
    using result_type = std::invoke_result_t<Projection,
        typename std::iterator_traits<Iterator>::value_type>;
 
    if (first == last) {
        return {{}, 0};
    }
 
    std::map<result_type, std::size_t> freq_map;
    for (auto it = first; it != last; ++it) {
        ++freq_map[std::invoke(proj, *it)];
    }
 
    std::size_t total = static_cast<std::size_t>(std::distance(first, last));
    double total_d = static_cast<double>(total);
 
    std::vector<frequency_entry<result_type>> entries;
    entries.reserve(freq_map.size());
 
    std::size_t cumulative = 0;
    for (const auto& pair : freq_map) {
        cumulative += pair.second;
        entries.push_back({
            pair.first,
            pair.second,
            static_cast<double>(pair.second) / total_d,
            cumulative,
            static_cast<double>(cumulative) / total_d
        });
    }
 
    return {std::move(entries), total};
}
 
// ============================================================================
// Frequency Count
// ============================================================================
 
template <typename Iterator>
auto frequency_count(Iterator first, Iterator last)
    -> std::unordered_map<typename std::iterator_traits<Iterator>::value_type, std::size_t>
{
    using value_type = typename std::iterator_traits<Iterator>::value_type;
 
    std::unordered_map<value_type, std::size_t> freq;
    for (auto it = first; it != last; ++it) {
        ++freq[*it];
    }
    return freq;
}
 
template <typename Iterator, typename Projection>
auto frequency_count(Iterator first, Iterator last, Projection proj)
    -> std::unordered_map<std::invoke_result_t<Projection,
           typename std::iterator_traits<Iterator>::value_type>, std::size_t>
{
    using result_type = std::invoke_result_t<Projection,
        typename std::iterator_traits<Iterator>::value_type>;
 
    std::unordered_map<result_type, std::size_t> freq;
    for (auto it = first; it != last; ++it) {
        ++freq[std::invoke(proj, *it)];
    }
    return freq;
}
 
// ============================================================================
// Relative Frequency
// ============================================================================
 
template <typename Iterator>
auto relative_frequency(Iterator first, Iterator last)
    -> std::unordered_map<typename std::iterator_traits<Iterator>::value_type, double>
{
    using value_type = typename std::iterator_traits<Iterator>::value_type;
 
    auto n = static_cast<std::size_t>(std::distance(first, last));
    if (n == 0) {
        return {};
    }
 
    auto freq = frequency_count(first, last);
    double total = static_cast<double>(n);
 
    std::unordered_map<value_type, double> result;
    result.reserve(freq.size());
    for (const auto& pair : freq) {
        result[pair.first] = static_cast<double>(pair.second) / total;
    }
    return result;
}
 
template <typename Iterator, typename Projection>
auto relative_frequency(Iterator first, Iterator last, Projection proj)
    -> std::unordered_map<std::invoke_result_t<Projection,
           typename std::iterator_traits<Iterator>::value_type>, double>
{
    using result_type = std::invoke_result_t<Projection,
        typename std::iterator_traits<Iterator>::value_type>;
 
    auto n = static_cast<std::size_t>(std::distance(first, last));
    if (n == 0) {
        return {};
    }
 
    auto freq = frequency_count(first, last, proj);
    double total = static_cast<double>(n);
 
    std::unordered_map<result_type, double> result;
    result.reserve(freq.size());
    for (const auto& pair : freq) {
        result[pair.first] = static_cast<double>(pair.second) / total;
    }
    return result;
}
 
// ============================================================================
// Cumulative Frequency
// ============================================================================
 
template <typename Iterator>
auto cumulative_frequency(Iterator first, Iterator last)
    -> std::vector<std::pair<typename std::iterator_traits<Iterator>::value_type, std::size_t>>
{
    using value_type = typename std::iterator_traits<Iterator>::value_type;
 
    if (first == last) {
        return {};
    }
 
    // Get frequency in sorted order
    std::map<value_type, std::size_t> freq_map;
    for (auto it = first; it != last; ++it) {
        ++freq_map[*it];
    }
 
    std::vector<std::pair<value_type, std::size_t>> result;
    result.reserve(freq_map.size());
 
    std::size_t cumulative = 0;
    for (const auto& pair : freq_map) {
        cumulative += pair.second;
        result.emplace_back(pair.first, cumulative);
    }
 
    return result;
}
 
template <typename Iterator, typename Projection>
auto cumulative_frequency(Iterator first, Iterator last, Projection proj)
    -> std::vector<std::pair<std::invoke_result_t<Projection,
           typename std::iterator_traits<Iterator>::value_type>, std::size_t>>
{
    using result_type = std::invoke_result_t<Projection,
        typename std::iterator_traits<Iterator>::value_type>;
 
    if (first == last) {
        return {};
    }
 
    std::map<result_type, std::size_t> freq_map;
    for (auto it = first; it != last; ++it) {
        ++freq_map[std::invoke(proj, *it)];
    }
 
    std::vector<std::pair<result_type, std::size_t>> result;
    result.reserve(freq_map.size());
 
    std::size_t cumulative = 0;
    for (const auto& pair : freq_map) {
        cumulative += pair.second;
        result.emplace_back(pair.first, cumulative);
    }
 
    return result;
}
 
// ============================================================================
// Cumulative Relative Frequency
// ============================================================================
 
template <typename Iterator>
auto cumulative_relative_frequency(Iterator first, Iterator last)
    -> std::vector<std::pair<typename std::iterator_traits<Iterator>::value_type, double>>
{
    using value_type = typename std::iterator_traits<Iterator>::value_type;
 
    auto n = static_cast<std::size_t>(std::distance(first, last));
    if (n == 0) {
        return {};
    }
 
    auto cum_freq = cumulative_frequency(first, last);
    double total = static_cast<double>(n);
 
    std::vector<std::pair<value_type, double>> result;
    result.reserve(cum_freq.size());
 
    for (const auto& pair : cum_freq) {
        result.emplace_back(pair.first, static_cast<double>(pair.second) / total);
    }
 
    return result;
}
 
template <typename Iterator, typename Projection>
auto cumulative_relative_frequency(Iterator first, Iterator last, Projection proj)
    -> std::vector<std::pair<std::invoke_result_t<Projection,
           typename std::iterator_traits<Iterator>::value_type>, double>>
{
    using result_type = std::invoke_result_t<Projection,
        typename std::iterator_traits<Iterator>::value_type>;
 
    auto n = static_cast<std::size_t>(std::distance(first, last));
    if (n == 0) {
        return {};
    }
 
    auto cum_freq = cumulative_frequency(first, last, proj);
    double total = static_cast<double>(n);
 
    std::vector<std::pair<result_type, double>> result;
    result.reserve(cum_freq.size());
 
    for (const auto& pair : cum_freq) {
        result.emplace_back(pair.first, static_cast<double>(pair.second) / total);
    }
 
    return result;
}
 
} // namespace statcpp