[RF] Avoid double-virtual funciton call in RooBinning

In `RooBinning`, the virtual `binNumber()` function was implemented by
calling the virtual `rawBinNumber()` function. The overhead from the
virtual function call is avoided by using an inline implementation
function instead.

Furthermore, the `rawBinNumber()` function was removed from the
RooAbsBinning interface, because it makes only sense in the context of
the RooBinning implementation.

Also, the functionality to look up bin boundaries by value in
`RooBinning` is removed, as such floating point comparisons should not
be done.

Author: guitargeek

roofit/roofitcore/inc/RooAbsBinning.h

@@ -39,7 +39,6 @@ class RooAbsBinning : public TNamed, public RooPrintable {
   }
   virtual Int_t numBoundaries() const = 0 ;
   virtual Int_t binNumber(double x) const = 0 ;
-  virtual Int_t rawBinNumber(double x) const { return binNumber(x) ; }
   virtual double binCenter(Int_t bin) const = 0 ;
   virtual double binWidth(Int_t bin) const = 0 ;
   virtual double binLow(Int_t bin) const = 0 ;

roofit/roofitcore/inc/RooBinning.h

@@ -39,7 +39,7 @@ class RooBinning : public RooAbsBinning {
     return _nbins+1;
   }
   Int_t binNumber(double x) const override;
-  Int_t rawBinNumber(double x) const override;
+  Int_t rawBinNumber(double x) const;
   virtual double nearestBoundary(double x) const;
 
   void setRange(double xlo, double xhi) override;
@@ -70,8 +70,6 @@ class RooBinning : public RooAbsBinning {
   void addUniform(Int_t nBins, double xlo, double xhi);
   bool removeBoundary(double boundary);
 
-  bool hasBoundary(double boundary);
-
 protected:
 
   bool binEdges(Int_t bin, double& xlo, double& xhi) const;

roofit/roofitcore/src/RooBinning.cxx

@@ -157,14 +157,6 @@ bool RooBinning::removeBoundary(double boundary)
   return true;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-/// Check if boundary exists at given value
-
-bool RooBinning::hasBoundary(double boundary)
-{
-  return std::binary_search(_boundaries.begin(), _boundaries.end(), boundary);
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 /// Add array of nbins uniformly sized bins in range [xlo,xhi]
 
@@ -176,14 +168,26 @@ void RooBinning::addUniform(Int_t nbins, double xlo, double xhi)
    (double(i) / double(nbins)) * xhi);
 }
 
+namespace {
+
+inline int rawBinNumberImpl(double x, std::vector<double> const& boundaries) {
+  auto it = std::lower_bound(boundaries.begin(), boundaries.end(), x);
+  // always return valid bin number
+  while (boundaries.begin() != it &&
+     (boundaries.end() == it || boundaries.end() == it + 1 || x < *it)) --it;
+  return it - boundaries.begin();
+}
+
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 /// Return sequential bin number that contains value x where bin
 /// zero is the first bin with an upper boundary above the lower bound
 /// of the range
 
 Int_t RooBinning::binNumber(double x) const
 {
-  return std::max(0, std::min(_nbins, rawBinNumber(x) - _blo));
+  return std::max(0, std::min(_nbins, rawBinNumberImpl(x, _boundaries) - _blo));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -193,14 +197,10 @@ Int_t RooBinning::binNumber(double x) const
 
 Int_t RooBinning::rawBinNumber(double x) const
 {
-  std::vector<double>::const_iterator it = std::lower_bound(
-      _boundaries.begin(), _boundaries.end(), x);
-  // always return valid bin number
-  while (_boundaries.begin() != it &&
-     (_boundaries.end() == it || _boundaries.end() == it + 1 || x < *it)) --it;
-  return it - _boundaries.begin();
+  return rawBinNumberImpl(x, _boundaries);
 }
 
+
 ////////////////////////////////////////////////////////////////////////////////
 /// Return the value of the nearest boundary to x
 
@@ -254,7 +254,7 @@ void RooBinning::updateBinCount()
       _nbins = -1;
       return;
   }
-  _blo = rawBinNumber(_xlo);
+  _blo = rawBinNumberImpl(_xlo, _boundaries);
   std::vector<double>::const_iterator it = std::lower_bound(
       _boundaries.begin(), _boundaries.end(), _xhi);
   if (_boundaries.begin() != it && (_boundaries.end() == it || _xhi < *it)) --it;