statistics.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <numeric>
#include <type_traits>
#include <vector>
 
namespace kcenon {
namespace monitoring {
namespace stats {
 
template <typename T>
struct statistics {
    T min;
    T max;
    T mean;
    T median;
    T p95;
    T p99;
    T total;
    size_t count;
};
 
namespace detail {
 
template <typename T>
struct is_chrono_duration : std::false_type {};
 
template <typename Rep, typename Period>
struct is_chrono_duration<std::chrono::duration<Rep, Period>> : std::true_type {};
 
template <typename T>
inline constexpr bool is_chrono_duration_v = is_chrono_duration<T>::value;
 
template <typename T>
constexpr T zero_value() {
    if constexpr (is_chrono_duration_v<T>) {
        return T::zero();
    } else {
        return T{0};
    }
}
 
template <typename T>
constexpr T max_value() {
    if constexpr (is_chrono_duration_v<T>) {
        return T::max();
    } else {
        return std::numeric_limits<T>::max();
    }
}
 
template <typename T>
constexpr T min_value() {
    if constexpr (is_chrono_duration_v<T>) {
        return T::min();
    } else {
        return std::numeric_limits<T>::lowest();
    }
}
 
template <typename T>
T divide(const T& value, size_t count) {
    if (count == 0) {
        return zero_value<T>();
    }
    if constexpr (is_chrono_duration_v<T>) {
        return value / static_cast<typename T::rep>(count);
    } else {
        return value / static_cast<T>(count);
    }
}
 
}  // namespace detail
 
template <typename T>
T percentile(const std::vector<T>& sorted_values, double percentile_value) {
    if (sorted_values.empty()) {
        return detail::zero_value<T>();
    }
 
    if (percentile_value <= 0.0) {
        return sorted_values.front();
    }
 
    if (percentile_value >= 100.0) {
        return sorted_values.back();
    }
 
    double rank = (percentile_value / 100.0) * (sorted_values.size() - 1);
    size_t lower_idx = static_cast<size_t>(rank);
    size_t upper_idx = lower_idx + 1;
 
    if (upper_idx >= sorted_values.size()) {
        return sorted_values[lower_idx];
    }
 
    // For chrono types, use simple index-based selection
    // For numeric types, use linear interpolation
    if constexpr (detail::is_chrono_duration_v<T>) {
        // Use nearest-rank method for duration types
        return sorted_values[static_cast<size_t>(std::round(rank))];
    } else {
        double fraction = rank - static_cast<double>(lower_idx);
        return sorted_values[lower_idx] +
               static_cast<T>(fraction * (sorted_values[upper_idx] - sorted_values[lower_idx]));
    }
}
 
template <typename T>
statistics<T> compute_sorted(const std::vector<T>& sorted_values) {
    statistics<T> result{};
 
    if (sorted_values.empty()) {
        result.min = detail::zero_value<T>();
        result.max = detail::zero_value<T>();
        result.mean = detail::zero_value<T>();
        result.median = detail::zero_value<T>();
        result.p95 = detail::zero_value<T>();
        result.p99 = detail::zero_value<T>();
        result.total = detail::zero_value<T>();
        result.count = 0;
        return result;
    }
 
    result.count = sorted_values.size();
    result.min = sorted_values.front();
    result.max = sorted_values.back();
 
    // Calculate total
    result.total = std::accumulate(sorted_values.begin(), sorted_values.end(),
                                   detail::zero_value<T>());
 
    // Calculate mean
    result.mean = detail::divide(result.total, result.count);
 
    // Calculate percentiles
    result.median = percentile(sorted_values, 50.0);
    result.p95 = percentile(sorted_values, 95.0);
    result.p99 = percentile(sorted_values, 99.0);
 
    return result;
}
 
template <typename T>
statistics<T> compute(const std::vector<T>& values) {
    if (values.empty()) {
        return compute_sorted<T>({});
    }
 
    std::vector<T> sorted = values;
    std::sort(sorted.begin(), sorted.end());
    return compute_sorted(sorted);
}
 
template <typename T>
statistics<T> compute_inplace(std::vector<T>& values) {
    if (values.empty()) {
        return compute_sorted<T>({});
    }
 
    std::sort(values.begin(), values.end());
    return compute_sorted(values);
}
 
}  // namespace stats
}  // namespace monitoring
}  // namespace kcenon