Quantile.h

Go to the documentation of this file.

#ifndef QUANTILE_H
#define QUANTILE_H
 
#include "TH1.h"
#include <vector>
#include <iostream>
 
struct Quantile {
  typedef std::pair<double, double> pair;
  typedef std::vector<pair> array;
 
  pair operator()(const double frac) const { return fromHead(frac); }
  pair operator[](const double frac) const { return fromTail(frac); }
 
  Quantile(const TH1* h) : N(1 + h->GetNbinsX()), Total(h->Integral(0, N)) {
    for (int i = 0; i < N; i++) {
      const double H = h->GetBinContent(i) + (!head.empty() ? head.back().second : 0);
      const double T = h->GetBinContent(N - i) + (!tail.empty() ? tail.back().second : 0);
      if (H)
        head.push_back(pair(h->GetBinWidth(i) + h->GetBinLowEdge(i), H));
      if (T)
        tail.push_back(pair(h->GetBinLowEdge(N - i), T));
    }
  }
 
  pair fromHead(const double frac) const { return calculateQ(frac, true); }
  pair fromTail(const double frac) const { return calculateQ(frac, false); }
 
private:
  pair calculateQ(const double frac, const bool fromHead) const {
    const double f = frac < 0.5 ? frac : 1 - frac;
    array::const_iterator begin(((frac < 0.5) == fromHead) ? head.begin() : tail.begin()),
        end(((frac < 0.5) == fromHead) ? head.end() : tail.end()), bin(begin);
 
    while (bin->second < f * Total)
      bin++;
    //dk    if( bin==begin ) return pair(sqrt(-1),0);
    if (bin == begin)
      return pair(-1, 0);
 
    array::const_iterator binNext(next(bin, end)), binPrev(prev(bin, begin)), binPPrev(prev(binPrev, begin));
 
    const double DX(binNext->first - binPPrev->first), DY((binNext->second - binPPrev->second) / Total),
 
        dX(bin->first - binPrev->first), dY((bin->second - binPrev->second) / Total),
 
        avgX((bin->first + binPrev->first) / 2), avgY((bin->second + binPrev->second) / (2 * Total)),
 
        x_q(avgX + dX / dY * (f - avgY)), xerr_q(std::max(fabs(DX / DY), fabs(dX / dY)) * sqrt(f * (1 - f) / Total));
 
    return pair(x_q, xerr_q);
  }
 
  template <class T>
  T prev(T bin, T begin) const {
    T binPrev = bin;
    while (binPrev > begin && (binPrev - 1)->second == (bin - 1)->second)
      binPrev--;
    return binPrev;
  }
 
  template <class T>
  T next(T bin, T end) const {
    T binNext = bin;
    while (binNext < end - 1 && (++binNext)->second == bin->second)
      ;
    return binNext;
  }
 
  const int N;
  const double Total;
  array head, tail;
};
#endif