Histogram.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <algorithm>
#include <cstddef>
#include <iosfwd>
#include <iterator>
#include <string>
#include <utility>
#include <vector>
 
namespace BaseLib
{
template <typename T>
class Histogram
{
public:
    using Data =
        typename std::vector<double>;  
 
public:
    template <typename InputIterator>
    Histogram(InputIterator first, InputIterator last, const int nr_bins = 16,
              const bool computeHistogram = true)
        : data_(first, last), nr_bins_(nr_bins), dirty_(true)
    {
        init(computeHistogram);
    }

    explicit Histogram(std::vector<T> data, const unsigned int nr_bins = 16,
                       const bool computeHistogram = true)
        : data_(std::move(data)), nr_bins_(nr_bins), dirty_(true)
    {
        init(computeHistogram);
    }

    void update()
    {
        if (!dirty_)
        {
            return;
        }
 
        bin_width_ = (max_ - min_) / nr_bins_;
 
        auto it = data_.begin();
        for (unsigned int bin = 0; bin < nr_bins_; bin++)
        {
            auto itEnd = std::upper_bound(it, data_.end(),
                                          min_ + (bin + 1) * bin_width_);
            histogram_[bin] = std::distance(it, itEnd);
            it = itEnd;
        }
        dirty_ = false;
    }
 
    void setMinimum(const T& minimum)
    {
        min_ = minimum;
        dirty_ = true;
    }
    void setMaximum(const T& maximum)
    {
        max_ = maximum;
        dirty_ = true;
    }
 
    const Data& getSortedData() const { return data_; }
    const std::vector<std::size_t>& getBinCounts() const { return histogram_; }
    const unsigned int& getNumberOfBins() const { return nr_bins_; }
    const T& getMinimum() const { return min_; }
    const T& getMaximum() const { return max_; }
    const T& getBinWidth() const { return bin_width_; }
 
    void prettyPrint(std::ostream& os,
                     const unsigned int line_width = 16) const;
 
    int write(std::string const& file_name, std::string const& data_set_name,
              std::string const& param_name) const;
 
protected:
    void init(const bool computeHistogram = true)
    {
        std::sort(data_.begin(), data_.end());
        histogram_.resize(nr_bins_);
        min_ = data_.front();
        max_ = data_.back();
        bin_width_ = (max_ - min_) / nr_bins_;
 
        dirty_ = true;
        if (computeHistogram)
        {
            update();
        }
    }
 
    Data data_;
    const unsigned int nr_bins_;
    std::vector<std::size_t> histogram_;
    T min_, max_;  
    T bin_width_;
 
private:
    bool dirty_;  
};

template <typename T>
std::ostream& operator<<(std::ostream& os, const Histogram<T>& h);
 
extern template class Histogram<double>;
extern template std::ostream& operator<<(std::ostream& os,
                                         const Histogram<double>& h);
}  // namespace BaseLib