kcenon::monitoring::detail Namespace Reference

Classes
class	time_series_ring_buffer
	Generic time-series ring buffer base template. More...

Functions
double	calculate_percentile (const std::vector< double > &sorted_values, double percentile)
	Calculate percentile from sorted values.
time_series_statistics	calculate_basic_statistics (const std::vector< double > &values, std::chrono::system_clock::time_point oldest_timestamp, std::chrono::system_clock::time_point newest_timestamp)
	Calculate basic statistics from a vector of double values.

Function Documentation

calculate_basic_statistics()

time_series_statistics kcenon::monitoring::detail::calculate_basic_statistics ( const std::vector< double > & values, std::chrono::system_clock::time_point oldest_timestamp, std::chrono::system_clock::time_point newest_timestamp )

inline

Calculate basic statistics from a vector of double values.

Parameters

values	Vector of values to analyze
oldest_timestamp	Timestamp of oldest sample
newest_timestamp	Timestamp of newest sample

Returns

Calculated statistics

Definition at line 140 of file time_series_buffer.h.

                                                      {
 
    time_series_statistics stats;
    stats.sample_count = values.size();
 
    if (values.empty()) {
        stats.min_value = 0.0;
        stats.max_value = 0.0;
        return stats;
    }
 
    stats.oldest_timestamp = oldest_timestamp;
    stats.newest_timestamp = newest_timestamp;
 
    double sum = 0.0;
    for (double val : values) {
        sum += val;
        stats.min_value = (std::min)(stats.min_value, val);
        stats.max_value = (std::max)(stats.max_value, val);
    }
    stats.avg = sum / values.size();
 
    double variance = 0.0;
    for (double val : values) {
        double diff = val - stats.avg;
        variance += diff * diff;
    }
    stats.stddev = std::sqrt(variance / values.size());
 
    std::vector<double> sorted_values = values;
    std::sort(sorted_values.begin(), sorted_values.end());
    stats.p95 = calculate_percentile(sorted_values, 95.0);
    stats.p99 = calculate_percentile(sorted_values, 99.0);
 
    return stats;
}

References kcenon::monitoring::time_series_statistics::avg, calculate_percentile(), kcenon::monitoring::time_series_statistics::max_value, kcenon::monitoring::time_series_statistics::min_value, kcenon::monitoring::time_series_statistics::newest_timestamp, kcenon::monitoring::time_series_statistics::oldest_timestamp, kcenon::monitoring::time_series_statistics::p95, kcenon::monitoring::time_series_statistics::p99, kcenon::monitoring::time_series_statistics::sample_count, and kcenon::monitoring::time_series_statistics::stddev.

Referenced by kcenon::monitoring::load_average_history::calculate_statistics(), and kcenon::monitoring::time_series_buffer< T >::calculate_statistics().

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_percentile()

double kcenon::monitoring::detail::calculate_percentile ( const std::vector< double > & sorted_values, double percentile )

inline

Calculate percentile from sorted values.

Parameters

sorted_values	Pre-sorted vector of values
percentile	Percentile to calculate (0-100)

Returns

Calculated percentile value

Definition at line 110 of file time_series_buffer.h.

                                                      {
    if (sorted_values.empty()) {
        return 0.0;
    }
    if (sorted_values.size() == 1) {
        return sorted_values[0];
    }
 
    double rank = (percentile / 100.0) * (sorted_values.size() - 1);
    size_t lower_idx = static_cast<size_t>(rank);
    size_t upper_idx = lower_idx + 1;
    double fraction = rank - lower_idx;
 
    if (upper_idx >= sorted_values.size()) {
        return sorted_values[lower_idx];
    }
 
    return sorted_values[lower_idx] +
           fraction * (sorted_values[upper_idx] - sorted_values[lower_idx]);
}

Referenced by calculate_basic_statistics().

Here is the caller graph for this function: