Histogram.h

#pragma once
 
#include <algorithm>
#include <cassert>
#include <chrono>
#include <cmath>
#include <map>
 
namespace xrpl::test::csf {

template <class T, class Compare = std::less<T>>
class Histogram
{
    // TODO: Consider logarithmic bins around expected median if this becomes
    // unscalable
    std::map<T, std::size_t, Compare> counts_;
    std::size_t samples_ = 0;
 
public:
    void
    insert(T const& s)
    {
        ++counts_[s];
        ++samples_;
    }

    [[nodiscard]] std::size_t
    size() const
    {
        return samples_;
    }

    [[nodiscard]] std::size_t
    numBins() const
    {
        return counts_.size();
    }

    [[nodiscard]] T
    minValue() const
    {
        return counts_.empty() ? T{} : counts_.begin()->first;
    }

    [[nodiscard]] T
    maxValue() const
    {
        return counts_.empty() ? T{} : counts_.rbegin()->first;
    }

    [[nodiscard]] T
    avg() const
    {
        T tmp{};
        if (samples_ == 0)
            return tmp;
        // Since counts are sorted, shouldn't need to worry much about numerical
        // error
        for (auto const& [bin, count] : counts_)
        {
            tmp += bin * count;
        }
        return tmp / samples_;
    }

    [[nodiscard]] T
    percentile(float p) const
    {
        assert(p >= 0 && p <= 1);
        std::size_t const pos = std::round(p * samples_);
 
        if (counts_.empty())
            return T{};
 
        auto it = counts_.begin();
        std::size_t cumsum = it->second;
        while (it != counts_.end() && cumsum < pos)
        {
            ++it;
            cumsum += it->second;
        }
        return it->first;
    }
};
 
}  // namespace xrpl::test::csf