Histogram.hpp

Go to the documentation of this file.

// The Reactive C++ Toolbox.
// Copyright (C) 2021 Reactive Markets Limited
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef TOOLBOX_HDR_HISTOGRAM
#define TOOLBOX_HDR_HISTOGRAM
 
#include <toolbox/Config.h>
 
#include <cstdint>
#include <vector>
 
namespace toolbox {
inline namespace hdr {
struct TOOLBOX_API BucketConfig {
    BucketConfig(std::int64_t lowest_trackable_value, std::int64_t highest_trackable_value,
                 int significant_figures);
    ~BucketConfig() noexcept = default;
 
    // Copy.
    BucketConfig(const BucketConfig&) noexcept = default;
    BucketConfig& operator=(const BucketConfig&) noexcept = default;
 
    // Move.
    BucketConfig(BucketConfig&&) noexcept = default;
    BucketConfig& operator=(BucketConfig&&) noexcept = default;
 
    std::int64_t lowest_trackable_value;
    std::int64_t highest_trackable_value;
    std::int32_t significant_figures;
    std::int32_t unit_magnitude;
    std::int32_t sub_bucket_half_count_magnitude;
    std::int32_t sub_bucket_count;
    std::int32_t sub_bucket_half_count;
    std::int64_t sub_bucket_mask;
    std::int32_t bucket_count;
    std::int32_t counts_len;
};
 
class TOOLBOX_API Histogram {
  public:
    explicit Histogram(const BucketConfig& config);
    Histogram(std::int64_t lowest_trackable_value, std::int64_t highest_trackable_value,
              std::int32_t significant_figures);
    ~Histogram() noexcept = default;
 
    // Copy.
    Histogram(const Histogram&) = default;
    Histogram& operator=(const Histogram&) = default;
 
    // Move.
    Histogram(Histogram&&) noexcept = default;
    Histogram& operator=(Histogram&&) noexcept = default;
 
    std::int64_t lowest_trackable_value() const noexcept { return lowest_trackable_value_; }
    std::int64_t highest_trackable_value() const noexcept { return highest_trackable_value_; }
    std::int32_t significant_figures() const noexcept { return significant_figures_; }
 
    std::int32_t sub_bucket_count() const noexcept { return sub_bucket_count_; }
    std::int32_t bucket_count() const noexcept { return bucket_count_; }
    std::int64_t total_count() const noexcept { return total_count_; }
    std::int32_t counts_len() const noexcept { return static_cast<std::int32_t>(counts_.size()); }
 
    std::int64_t min() const noexcept;
 
    std::int64_t max() const noexcept;
 
    bool values_are_equivalent(std::int64_t a, std::int64_t b) const noexcept;
 
    std::int64_t lowest_equivalent_value(std::int64_t value) const noexcept;
    std::int64_t highest_equivalent_value(std::int64_t value) const noexcept;
 
    std::int64_t count_at_value(std::int64_t value) const noexcept;
    std::int64_t count_at_index(std::int32_t index) const noexcept;
    std::int64_t value_at_index(std::int32_t index) const noexcept;
    std::int64_t size_of_equivalent_value_range(std::int64_t value) const noexcept;
    std::int64_t next_non_equivalent_value(std::int64_t value) const noexcept;
    std::int64_t median_equivalent_value(std::int64_t value) const noexcept;
    std::int64_t counts_get_normalised(std::int32_t index) const noexcept;
 
    void reset() noexcept;
 
    bool record_value(std::int64_t value) noexcept;
 
    bool record_values(std::int64_t value, std::int64_t count) noexcept;
 
  private:
    std::int32_t normalize_index(std::int32_t index) const noexcept;
    std::int32_t get_bucket_index(std::int64_t value) const noexcept;
    std::int32_t counts_index(std::int32_t bucket_index,
                              std::int32_t sub_bucket_index) const noexcept;
    std::int32_t counts_index_for(std::int64_t value) const noexcept;
    std::int64_t non_zero_min() const noexcept;
 
    void counts_inc_normalised(std::int32_t index, std::int64_t value) noexcept;
    void update_min_max(std::int64_t value) noexcept;
 
    std::int64_t lowest_trackable_value_;
    std::int64_t highest_trackable_value_;
    std::int32_t significant_figures_;
    std::int32_t unit_magnitude_;
    std::int32_t sub_bucket_half_count_magnitude_;
    std::int32_t sub_bucket_count_;
    std::int32_t sub_bucket_half_count_;
    std::int64_t sub_bucket_mask_;
    std::int32_t bucket_count_;
 
    std::int32_t normalizing_index_offset_;
    std::int64_t min_value_;
    std::int64_t max_value_;
    std::int64_t total_count_;
    std::vector<std::int64_t> counts_;
};
 
} // namespace hdr
} // namespace toolbox
 
#endif // TOOLBOX_HDR_HISTOGRAM