Histogram.h

Go to the documentation of this file.

// Copyright (c) 2002-present, The OpenMS Team -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg$
// $Authors: Marc Sturm $
// --------------------------------------------------------------------------
 
#pragma once
 
//OpenMS
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/CONCEPT/Exception.h>
 
//STL
#include <vector>
#include <cmath>
#include <limits>
#include <iostream>
#include <algorithm>
 
namespace OpenMS
{
  namespace Math
  {
 
    template <typename ValueType = UInt, typename BinSizeType = double>
    class Histogram
    {
public:
 
      typedef typename std::vector<ValueType>::const_iterator ConstIterator;
 
      Histogram() :
        min_(0),
        max_(0),
        bin_size_(0)
      {
      }
 
      Histogram(const Histogram & histogram) :
        min_(histogram.min_),
        max_(histogram.max_),
        bin_size_(histogram.bin_size_),
        bins_(histogram.bins_)
      {
      }
 
      Histogram(BinSizeType min, BinSizeType max, BinSizeType bin_size) :
        min_(min),
        max_(max),
        bin_size_(bin_size)
      {
        this->initBins_();
      }
 
 
      template <typename DataIterator>
      Histogram(DataIterator begin, DataIterator end, BinSizeType min, BinSizeType max, BinSizeType bin_size) :
        min_(min),
        max_(max),
        bin_size_(bin_size)
      {
        this->initBins_();
        for (DataIterator it = begin; it != end; ++it)
        {
          this->inc((BinSizeType) *it);
        }
      }
 
      virtual ~Histogram()
      {
      }
 
 
      BinSizeType minBound() const
      {
        return min_;
      }
 
      BinSizeType maxBound() const
      {
        return max_;
      }
 
      ValueType maxValue() const
      {
        return *(std::max_element(bins_.begin(), bins_.end()));
      }
 
      ValueType minValue() const
      {
        return *(std::min_element(bins_.begin(), bins_.end()));
      }
 
      BinSizeType binSize() const
      {
        return bin_size_;
      }
 
      Size size() const
      {
        return bins_.size();
      }
 
      ValueType operator[](Size index) const
      {
        if (index >= bins_.size())
        {
          throw Exception::IndexOverflow(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION);
        }
        return bins_[index];
      }
 
      BinSizeType centerOfBin(Size bin_index) const
      {
        if (bin_index >= bins_.size())
        {
          throw Exception::IndexOverflow(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION);
        }
 
        return (BinSizeType)(min_ + ((BinSizeType)bin_index + 0.5) * bin_size_);
      }
 
      BinSizeType rightBorderOfBin(Size bin_index) const
      {
        if (bin_index >= bins_.size())
        {
          throw Exception::IndexOverflow(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION);
        }
        if (bin_index + 1 == bins_.size())
        { // rightmost bin is special. It contains the maximum value - see valueToBin().
          return std::nextafter(maxBound(), maxBound() + 1);
        }
        return (BinSizeType)(min_ + ((BinSizeType) bin_index + 1) * bin_size_);
      }
 
      BinSizeType leftBorderOfBin(Size bin_index) const
      {
        if (bin_index >= bins_.size())
        {
          throw Exception::IndexOverflow(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION);
        }
 
        return (BinSizeType)(min_ + (BinSizeType)bin_index * bin_size_);
      }
 
      ValueType binValue(BinSizeType val) const
      {
        return bins_[valueToBin(val)];
      }
 
      Size inc(BinSizeType val, ValueType increment = 1)
      {
        Size bin_index = this->valueToBin(val);
        this->bins_[bin_index] += increment;
        return bin_index;
      }
 
      Size incUntil(BinSizeType val, bool inclusive, ValueType increment = 1)
      {
        Size bin_index = this->valueToBin(val);
        for (Size i = 0; i < bin_index; ++i)
        {
         this->bins_[i] += increment;
        }
        if (inclusive)
        {
          this->bins_[bin_index] += increment;
        }
        return bin_index;
      }
 
      Size incFrom(BinSizeType val, bool inclusive, ValueType increment = 1)
      {
        Size bin_index = this->valueToBin(val);
        for (Size i = bin_index + 1; i < this->bins_.size(); ++i)
        {
          this->bins_[i] += increment;
        }
        if (inclusive)
        {
          this->bins_[bin_index] += increment;
        }
        return bin_index;
      }
 
      template< typename DataIterator >
      static void getCumulativeHistogram(DataIterator begin, DataIterator end,
                                         bool complement,
                                         bool inclusive,
                                         Histogram< ValueType, BinSizeType > & histogram)
      {
        for (DataIterator it = begin; it != end; ++it)
        {
          if (complement)
          {
            histogram.incUntil(*it, inclusive);
          }
          else
          {
            histogram.incFrom(*it, inclusive);
          }
        }
      }
 
 
      void reset(BinSizeType min, BinSizeType max, BinSizeType bin_size)
      {
        min_ = min;
        max_ = max;
        bin_size_ = bin_size;
        bins_.clear();
 
        if (bin_size_ <= 0)
        {
          throw Exception::OutOfRange(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION);
        }
        else
        {
          // if max_ == min_ there is only one bin
          if (max_ != min_)
          {
            bins_.resize(Size(ceil((max_ - min_) / bin_size_)), 0);
          }
          else
          {
            bins_.resize(1, 0);
          }
        }
      }
 
      bool operator==(const Histogram & histogram) const
      {
        return min_ == histogram.min_ &&
               max_ == histogram.max_ &&
               bin_size_ == histogram.bin_size_ &&
               bins_ == histogram.bins_;
      }
 
      bool operator!=(const Histogram & histogram) const
      {
        return !operator==(histogram);
      }
 
      Histogram & operator=(const Histogram & histogram)
      {
        if (&histogram == this) return *this;
 
        min_ = histogram.min_;
        max_ = histogram.max_;
        bin_size_ = histogram.bin_size_;
        bins_ = histogram.bins_;
 
        return *this;
      }
 
 
      inline ConstIterator begin() const { return bins_.begin(); }
 
      inline ConstIterator end() const { return bins_.end(); }
 
      void applyLogTransformation(BinSizeType multiplier)
      {
        for (typename std::vector<ValueType>::iterator it = bins_.begin(); it != bins_.end(); ++it)
        {
          *it = (ValueType)(multiplier * log((BinSizeType)(*it + 1.0f)));
        }
      }
 
      Size valueToBin(BinSizeType val) const
      {
        //std::cout << "val: " << val << " (min: " << min_ << " max: " << max_ << ")" << std::endl;
        if (val < min_ || val > max_)
        {
          throw Exception::OutOfRange(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION);
        }
        if (val == max_)
        {
          return Size(bins_.size() - 1);
        }
        else
        {
          return (Size) floor((val - min_) / bin_size_);
        }
      }
 
protected:
      BinSizeType min_;
      BinSizeType max_;
      BinSizeType bin_size_;
      std::vector<ValueType> bins_;
 
 
      void initBins_()
      {
        if (this->bin_size_ <= 0)
        {
          throw Exception::OutOfRange(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION);
        }
        else
        {
          if (this->max_ != this->min_)
          {
            this->bins_ = std::vector<ValueType>(Size(ceil((max_ - min_) / bin_size_)), 0);
          }
          else
          { // if max_ == min_ there is only one bin
            this->bins_ = std::vector<ValueType>(1, 0);
          }
        }
      }
    };
 
    template <typename ValueType, typename BinSizeType>
    std::ostream & operator<<(std::ostream & os, const Histogram<ValueType, BinSizeType> & hist)
    {
      for (Size i = 0; i < hist.size(); ++i)
      {
        os << hist.centerOfBin(i) << "\t"<< hist[i] << std::endl;
      }
      return os;
    }
 
  }   // namespace Math
 
} // namespace OpenMS