Bin.h

Go to the documentation of this file.

// \author Darko Veberic
// \date 2014

#ifndef _utl_Bin_h_
#define _utl_Bin_h_

#include <vector>
#include <iostream>
#include <functional>


namespace utl {

  class Equidistant {
  public:
    Equidistant(const double start, const double stop, const unsigned int nBins) :
      fStart(start),
      fStop(stop),
      fNBins(nBins),
      fStep((stop-start)/nBins),
      fInvStep(1/fStep)
    { }

    int GetBinIndex(const double x) const { return int(fInvStep*(x - fStart)); }

    double GetBinCenter(const int i) const { return Interpolate(i+0.5); }
    double GetBinLowerEdge(const int i) const { return Interpolate(i); }
    double GetBinUpperEdge(const int i) const { return Interpolate(i+1); }
    double GetBinWidth(const int i) const
    { return (0 <= i && i < int(fNBins)) ? fStep : std::numeric_limits<double>::infinity(); }

    unsigned int GetNBins() const { return fNBins; }
    double GetStart() const { return fStart; }
    double GetStop() const { return fStop; }
    double GetStep() const { return fStep; }

  private:
    double
    Interpolate(const double i)
      const
    {
      if (i < 0)
        return -std::numeric_limits<double>::infinity();
      if (i > int(fNBins))
        return std::numeric_limits<double>::infinity();
      return fStart + i*fStep;
    }

    double fStart;
    double fStop;
    unsigned int fNBins;
    double fStep;
    double fInvStep;
  };


  template<typename DataType>
  class EquidistantInNorm : public Equidistant {
  public:
    EquidistantInNorm(const double start, const double stop, const unsigned int nBins,
                      const std::function<double(const DataType&)>& norm) :
      Equidistant(start, stop, nBins),
      fNorm(norm)
    { }

    int GetBinIndex(const DataType& x) const { return Equidistant::GetBinIndex(fNorm(x)); }

    int GetUnnormalizedBinIndex(const double x) const { return Equidistant::GetBinIndex(x); }

  private:
    const std::function<double(const DataType&)> fNorm;
  };


  template<class BinType, class DiscretizationType>
  class Bin : public DiscretizationType {
  public:
    Bin(const DiscretizationType& dis, const BinType& init = BinType()) :
      DiscretizationType(dis),
      fBins(dis.GetNBins(), init),
      fUnderflow(init),
      fOverflow(init)
    { }

    std::vector<BinType>& GetAllBins() { return fBins; }

    const std::vector<BinType>& GetAllBins() const { return fBins; }

    template<class DataType>
    BinType& operator()(const DataType& x) { return (*this)[this->GetBinIndex(x)]; }

    template<class DataType>
    const BinType& operator()(const DataType& x) const { return (*this)[this->GetBinIndex(x)]; }

    BinType&
    operator[](const int i)
    {
      if (i < 0)
        return fUnderflow;
      if (i >= int(fBins.size()))
        return fOverflow;
      return At(i);
    }

    const BinType&
    operator[](const int i)
      const
    {
      if (i < 0)
        return fUnderflow;
      if (i >= fBins.size())
        return fOverflow;
      return At(i);
    }

    bool IsRegularIndex(const int i) const { return 0 <= i && i < fBins.size(); }

    template<class DataType>
    void Apply(const DataType& x) { (*this)(x)(x); }

    template<class DataType, class Indexer>
    void Apply(const DataType& x, Indexer indexer) { (*this)(indexer(x))(x); }

    template<typename DataType>
    void
    Apply(const std::vector<DataType>& vec)
    {
      for (const DataType& x : vec)
        Apply(x);
    }

    template<typename DataType, class Indexer>
    void
    Apply(const std::vector<DataType>& vec, Indexer indexer)
    {
      for (const DataType& x : vec)
        Apply(x, indexer);
    }

    template<typename DataType, class Indexer, class Unpack>
    void
    Apply(const std::vector<DataType>& vec, Indexer indexer, Unpack unpack)
    {
      for (const DataType& x : vec)
        Apply(unpack(x), indexer);
    }

    const BinType& GetUnderflow() const { return fUnderflow; }
    const BinType& GetOverflow() const { return fOverflow; }

    void
    Clear()
    {
      for (auto& b : fBins)
        b.Clear();
      fUnderflow.Clear();
      fOverflow.Clear();
    }

  private:
  #ifdef DEBUG
    BinType& At(const int i) { return fBins.at(i); }
    const BinType& At(const int i) const { return fBins.at(i); }
  #else
    BinType& At(const int i) { return fBins[i]; }
    const BinType& At(const int i) const { return fBins[i]; }
  #endif

    std::vector<BinType> fBins;
    BinType fUnderflow;
    BinType fOverflow;
  };

}


#endif