/// \file histspeedtest.cxx
///
/// \warning This is part of the ROOT 7 prototype! It will change without notice. It might trigger earthquakes. Feedback
/// is welcome!
/// \author Axel Naumann <axel@cern.ch>

#include "TRandom3.h"
#include <vector>
#include <chrono>
#include <iostream>

#include "TH1.h"
#include "TH2.h"
#include "TH3.h"

#include "ROOT/RHist.hxx"
#include "ROOT/RHistBufferedFill.hxx"

using namespace ROOT;
using namespace std;

constexpr unsigned short gRepeat = 2;

/* DataTypes:

 THistDataContent
 THistDataUncertainty
 THistDataMomentUncert
 THistDataRuntime
and
 MyTHistDataNoStat
 MyTHistDataContent
 MyTHistDataMomentUncert

 /opt/build/root_builds/rootcling.cmake/include/ROOT/THistBinIter.h:53:50: error: no member named 'GetUncertainty' in
'ROOT::Experimental::THistDataContent<2, double, ROOT::Experimental::THistDataDefaultStorage>::TBinStat<double>' auto
GetUncertainty() const { return GetStat().GetUncertainty(); }
 ~~~~~~~~~ ^

 new ones (STATCLASSES)

 THistStatContent
 THistStatUncertainty
 THistStatTotalSumOfWeights
 THistStatTotalSumOfSquaredWeights
 THistDataMomentUncert


 */

#ifndef STATCLASSES
#define STATCLASSES Experimental::RHistStatContent, Experimental::RHistStatUncertainty
#endif

struct Timer {
   using TimePoint_t = decltype(std::chrono::high_resolution_clock::now());

   const char *fTitle;
   size_t fCount;
   TimePoint_t fStart;

   Timer(const char *title, size_t count)
      : fTitle(title), fCount(count), fStart(std::chrono::high_resolution_clock::now())
   {}

   ~Timer()
   {
      using namespace std::chrono;
      auto end = high_resolution_clock::now();
      duration<double> time_span = duration_cast<duration<double>>(end - fStart);
      // std::cout << fCount << " * " << fTitle << ": " << time_span.count() << " seconds \n";
      // std::cout << fCount << " * " << fTitle << ": " << fCount / (1e6) / time_span.count()
      //    << " millions per seconds\n";
      std::cout << fCount << " * " << fTitle << ": " << time_span.count() << " seconds, \t";
      std::cout << fCount / (1e6) / time_span.count() << " millions per seconds \n";
   }
};

constexpr UInt_t gStride = 32; // TH1::GetDefaultBufferSize()

struct BinEdges {
   static constexpr size_t fNBinsX = 4;
   static constexpr size_t fNBinsY = 5;
   double fXBins[4];
   double fYBins[5];

   BinEdges(double minValue, double maxValue)
   {
      if (maxValue < minValue)
         swap(minValue, maxValue);
      double range = maxValue - minValue;

      double x[fNBinsX] = {0., 0.1, 0.3, 1.};
      double y[fNBinsY] = {0., 0.1, 0.2, 0.3, 1.};

      for (size_t i = 0; i < fNBinsX; ++i)
         fXBins[i] = minValue + range * x[i];
      for (size_t i = 0; i < fNBinsY; ++i)
         fYBins[i] = minValue + range * y[i];
   }

   using AConf_t = Experimental::RAxisConfig;

   AConf_t GetConfigX() const { return AConf_t(std::span<const double>(fXBins).to_vector()); }
   AConf_t GetConfigY() const { return AConf_t(std::span<const double>(fYBins).to_vector()); }
};

template <typename T>
void GenerateInput(std::vector<T> &numbers, double minVal, double maxVal, UInt_t seed)
{
   Timer t("GenerateInput", numbers.size());
   if (minVal > maxVal) {
      std::swap(minVal, maxVal);
   }
   T range = maxVal - minVal;
   TRandom3 r(seed);
   size_t len = numbers.size();
   for (auto c = numbers.begin(); c != numbers.end(); ++c) {
      *c = minVal + range * r.Rndm();
   }
}

std::string
MakeTitle(std::string_view version, std::string_view histname, std::string_view title, std::string_view axis)
{
   std::string result =
      std::string(version) + " " + std::string(histname) + " " + std::string(title) + " [" + std::string(axis) + "]";
   return result;
}

template <int dim, typename type>
const char *GetHist();

template <>
const char *GetHist<2, double>()
{
   return "2D";
};
template <>
const char *GetHist<2, float>()
{
   return "2F";
};

template <>
const char *GetHist<1, double>()
{
   return "1D";
};
template <>
const char *GetHist<1, float>()
{
   return "1F";
};

namespace R7 {
const char *gVersion = "R7";

template <typename T, unsigned short kNDim>
struct Dim;

template <typename T>
struct Dim<T, 2> {

   constexpr static unsigned short kNDim = 2;
   using ExpTH2 = Experimental::RHist<kNDim, T, STATCLASSES>;

   using FillFunc_t = std::add_pointer_t<long(ExpTH2 &hist, std::vector<double> &input, std::string_view type)>;

   struct EE {
      static constexpr const char *const gType = "regular bin size  ";

      template <FillFunc_t filler>
      static long Execute(std::vector<double> &input, double minVal, double maxVal)
      {

         ExpTH2 hist({100, minVal, maxVal}, {5, minVal, maxVal});
         return filler(hist, input, gType);
      }
   };

   struct II {
      static constexpr const char *const gType = "irregular bin size";

      template <FillFunc_t filler>
      static long Execute(std::vector<double> &input, double minVal, double maxVal)
      {

         BinEdges edges(minVal, maxVal);
         ExpTH2 hist(edges.GetConfigX(), edges.GetConfigY());
         return filler(hist, input, gType);
      }
   };

   inline static long fillN(ExpTH2 &hist, std::vector<double> &input, std::string_view gType)
   {

      using array_t = Experimental::Hist::RCoordArray<2>;
      array_t *values = (array_t *)(&input[0]);
      constexpr size_t stride = gStride;

      std::string title = MakeTitle(gVersion, GetHist<kNDim, T>(), "fills N (stride 32)", gType);
      {
         Timer t(title.c_str(), input.size() / 2);
         for (size_t i = 0; i < (input.size() - (stride * 2 - 1)); i += (stride * 2), values += 32) {
            std::span<array_t> coords(values, 32);
            hist.FillN(coords);
         }
      }
      return hist.GetNDim();
   }

   inline static long fillBuffered(ExpTH2 &hist, std::vector<double> &input, std::string_view gType)
   {
      Experimental::RHistBufferedFill<ExpTH2> filler(hist);
      std::string title = MakeTitle(gVersion, GetHist<kNDim, T>(), "fills (buffered)   ", gType);
      {
         Timer t(title.c_str(), input.size() / 2);
         for (size_t i = 0; i < input.size() - 1; i += 2)
            filler.Fill({input[i], input[i + 1]});
      }
      return hist.GetNDim();
   }

   inline static long fill(ExpTH2 &hist, std::vector<double> &input, std::string_view gType)
   {
      std::string title = MakeTitle(gVersion, GetHist<kNDim, T>(), "fills              ", gType);
      {
         Timer t(title.c_str(), input.size() / 2);
         for (size_t i = 0; i < input.size() - 1; i += 2)
            hist.Fill({input[i], input[i + 1]});
      }
      return hist.GetNDim();
   }
}; // DimD

template <typename T>
struct Dim<T, 1> {

   constexpr static unsigned short kNDim = 1;
   using ExpTH1 = Experimental::RHist<kNDim, T, STATCLASSES>;

   using FillFunc_t = std::add_pointer_t<long(ExpTH1 &hist, std::vector<double> &input, std::string_view type)>;

   struct EE {
      static constexpr const char *const gType = "regular bin size  ";

      template <FillFunc_t filler>
      static long Execute(std::vector<double> &input, double minVal, double maxVal)
      {
         long result = 0;
         for (unsigned short i = 0; i < gRepeat; ++i) {
            ExpTH1 hist({100, minVal, maxVal});
            result += filler(hist, input, gType);
         }
         return result;
      }
   };

   struct II {
      static constexpr const char *const gType = "irregular bin size";

      template <FillFunc_t filler>
      static long Execute(std::vector<double> &input, double minVal, double maxVal)
      {

         long result = 0;
         BinEdges edges(minVal, maxVal);
         for (unsigned short i = 0; i < gRepeat; ++i) {
            ExpTH1 hist(edges.GetConfigX());
            result += filler(hist, input, gType);
         }
         return result;
      }
   };

   inline static long fillN(ExpTH1 &hist, std::vector<double> &input, std::string_view gType)
   {

      using array_t = Experimental::Hist::RCoordArray<1>;
      array_t *values = (array_t *)(&input[0]);
      constexpr size_t stride = gStride;

      std::string title = MakeTitle(gVersion, GetHist<kNDim, T>(), "fills N (stride 32)", gType);
      {
         Timer t(title.c_str(), input.size());
         for (size_t i = 0; i < (input.size() - (stride - 1)); i += (stride), values += 32) {
            std::span<array_t> coords(values, 32);
            hist.FillN(coords);
         }
      }
      return hist.GetNDim();
   }

   inline static long fillBuffered(ExpTH1 &hist, std::vector<double> &input, std::string_view gType)
   {
      Experimental::RHistBufferedFill<ExpTH1> filler(hist);
      std::string title = MakeTitle(gVersion, GetHist<kNDim, T>(), "fills (buffered)   ", gType);
      {
         Timer t(title.c_str(), input.size());
         for (size_t i = 0; i < input.size(); ++i)
            filler.Fill({input[i]});
      }
      return hist.GetNDim();
   }

   inline static long fill(ExpTH1 &hist, std::vector<double> &input, std::string_view gType)
   {
      std::string title = MakeTitle(gVersion, GetHist<kNDim, T>(), "fills              ", gType);
      {
         Timer t(title.c_str(), input.size());
         for (size_t i = 0; i < input.size(); ++i)
            hist.Fill({input[i]});
      }
      return hist.GetNDim();
   }
}; // Dim1

} // namespace R7

namespace R6 {
const char *gVersion = "R6";

template <int ndim, typename T>
struct Redirect;
template <>
struct Redirect<2, float> {
   using HistType_t = TH2F;
};
template <>
struct Redirect<2, double> {
   using HistType_t = TH2D;
};
template <>
struct Redirect<1, float> {
   using HistType_t = TH1F;
};
template <>
struct Redirect<1, double> {
   using HistType_t = TH1D;
};

template <typename T, int kNDim>
struct Dim;

template <typename T>
struct Dim<T, 2> {

   constexpr static unsigned short kNDim = 2;
   using HistType_t = typename Redirect<kNDim, T>::HistType_t;

   using FillFunc_t = std::add_pointer_t<long(HistType_t &hist, std::vector<double> &input, std::string_view type)>;

   struct EE {

      static constexpr const char *const gType = "regular bin size  ";

      template <FillFunc_t filler>
      static long Execute(std::vector<double> &input, double minVal, double maxVal)
      {

         long result = 0;
         for (unsigned short i = 0; i < gRepeat; ++i) {
            HistType_t hist("a", "a hist", 100, minVal, maxVal, 5, minVal, maxVal);
            result += filler(hist, input, gType);
         }
         return result;
      }
   };

   struct II {

      static constexpr const char *const gType = "irregular bin size";

      template <FillFunc_t filler>
      static long Execute(std::vector<double> &input, double minVal, double maxVal)
      {
         long result = 0;
         BinEdges edges(minVal, maxVal);
         for (unsigned short i = 0; i < gRepeat; ++i) {
            HistType_t hist("a", "a hist", edges.fNBinsX - 1, edges.fXBins, edges.fNBinsY - 1, edges.fYBins);
            result += filler(hist, input, gType);
         }
         return result;
      }
   };

   static long fillBuffered(HistType_t &hist, std::vector<double> &input, std::string_view gType)
   {
      std::string title = MakeTitle(gVersion, GetHist<kNDim, T>(), "fills (buffered)   ", gType);
      hist.SetBuffer(TH1::GetDefaultBufferSize());
      {
         // Timer t("R6 2D fills [regular bins size]",input.size()/2);
         Timer t(title.c_str(), input.size() / 2);
         for (size_t i = 0; i < input.size() - 1; i += 2)
            hist.Fill(input[i], input[i + 1]);
      }
      return (long)hist.GetEntries();
   }

   static long fillN(HistType_t &hist, std::vector<double> &input, std::string_view gType)
   {
      std::string title = MakeTitle(gVersion, GetHist<kNDim, T>(), "fills N (stride 32)", gType);
      constexpr size_t stride = gStride;
      {
         // Timer t("R6 2D fills [regular bins size]",input.size()/2);
         Timer t(title.c_str(), input.size() / 2);
         for (size_t i = 0; i < (input.size() - (stride * 2 - 1)); i += (stride * 2))
            hist.FillN(gStride, &(input[i]), &(input[i + gStride]), nullptr);
      }
      return (long)hist.GetEntries();
   }

   static long fill(HistType_t &hist, std::vector<double> &input, std::string_view gType)
   {
      std::string title = MakeTitle(gVersion, GetHist<kNDim, T>(), "fills              ", gType);
      {
         // Timer t("R6 2D fills [regular bins size]",input.size()/2);
         Timer t(title.c_str(), input.size() / 2);
         for (size_t i = 0; i < input.size() - 1; i += 2)
            hist.Fill(input[i], input[i + 1]);
      }
      return (long)hist.GetEntries();
   }
}; // Dim

template <typename T>
struct Dim<T, 1> {

   constexpr static unsigned short kNDim = 1;
   using HistType_t = typename Redirect<kNDim, T>::HistType_t;

   using FillFunc_t = std::add_pointer_t<long(HistType_t &hist, std::vector<double> &input, std::string_view type)>;

   struct EE {

      static constexpr const char *const gType = "regular bin size  ";

      template <FillFunc_t filler>
      static long Execute(std::vector<double> &input, double minVal, double maxVal)
      {

         long result = 0;
         for (unsigned short i = 0; i < gRepeat; ++i) {
            HistType_t hist("a", "a hist", 100, minVal, maxVal);
            result += filler(hist, input, gType);
         }
         return result;
      }
   };

   struct II {

      static constexpr const char *const gType = "irregular bin size";

      template <FillFunc_t filler>
      static long Execute(std::vector<double> &input, double minVal, double maxVal)
      {
         long result = 0;
         BinEdges edges(minVal, maxVal);
         for (unsigned short i = 0; i < gRepeat; ++i) {
            HistType_t hist("a", "a hist", edges.fNBinsX - 1, edges.fXBins);
            result += filler(hist, input, gType);
         }
         return result;
      }
   };

   static long fillBuffered(HistType_t &hist, std::vector<double> &input, std::string_view gType)
   {
      std::string title = MakeTitle(gVersion, GetHist<kNDim, T>(), "fills (buffered)   ", gType);
      hist.SetBuffer(TH1::GetDefaultBufferSize());
      {
         // Timer t("R6 2D fills [regular bins size]",input.size()/2);
         Timer t(title.c_str(), input.size());
         for (size_t i = 0; i < input.size() - 1; ++i)
            hist.Fill(input[i]);
      }
      return (long)hist.GetEntries();
   }

   static long fillN(HistType_t &hist, std::vector<double> &input, std::string_view gType)
   {
      std::string title = MakeTitle(gVersion, GetHist<kNDim, T>(), "fills N (stride 32)", gType);
      constexpr size_t stride = gStride;
      {
         // Timer t("R6 2D fills [regular bins size]",input.size()/2);
         Timer t(title.c_str(), input.size());
         for (size_t i = 0; i < (input.size() - (stride - 1)); i += (stride))
            hist.FillN(gStride, &(input[i]), nullptr);
      }
      return (long)hist.GetEntries();
   }

   static long fill(HistType_t &hist, std::vector<double> &input, std::string_view gType)
   {
      std::string title = MakeTitle(gVersion, GetHist<kNDim, T>(), "fills              ", gType);
      {
         // Timer t("R6 2D fills [regular bins size]",input.size()/2);
         Timer t(title.c_str(), input.size());
         for (size_t i = 0; i < input.size(); ++i)
            hist.Fill(input[i]);
      }
      return (long)hist.GetEntries();
   }
}; // Dim1
} // namespace R6

template <typename T, unsigned short kNDim>
void speedtest(size_t count = (size_t)(1e6));

template <>
void speedtest<double, 2>(size_t count)
{
   using DataType_t = double;
   static constexpr unsigned short kNDim = 2;

   TH1::AddDirectory(kFALSE);

   std::vector<double> input; // (count);
   input.resize(count);

   double minVal = -5.0;
   double maxVal = +5.0;
   GenerateInput(input, minVal, maxVal, 0);

   // Make sure we have some overflow.
   minVal *= 0.9;
   maxVal *= 0.9;

   cout << '\n';

   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);

   cout << '\n';

   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);

   cout << '\n';

   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);

   cout << '\n';

   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);

   cout << '\n';
}

// these are copy/paste to work around failure to properly instantiate the template :(

template <>
void speedtest<float, 2>(size_t count)
{
   using DataType_t = float;
   constexpr unsigned short kNDim = 2;

   TH1::AddDirectory(kFALSE);

   std::vector<double> input; // (count);
   input.resize(count);

   double minVal = -5.0;
   double maxVal = +5.0;
   GenerateInput(input, minVal, maxVal, 0);

   // Make sure we have some overflow.
   minVal *= 0.9;
   maxVal *= 0.9;

   cout << '\n';

   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);

   cout << '\n';

   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);

   cout << '\n';

   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);

   cout << '\n';

   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);
}

template <>
void speedtest<double, 1>(size_t count)
{
   using DataType_t = double;
   static constexpr unsigned short kNDim = 1;

   TH1::AddDirectory(kFALSE);

   std::vector<double> input; // (count);
   input.resize(count);

   double minVal = -5.0;
   double maxVal = +5.0;
   GenerateInput(input, minVal, maxVal, 0);

   // Make sure we have some overflow.
   minVal *= 0.9;
   maxVal *= 0.9;

   cout << '\n';

   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);

   cout << '\n';

   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);

   cout << '\n';

   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);

   cout << '\n';

   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);
}

template <>
void speedtest<float, 1>(size_t count)
{
   using DataType_t = float;
   static constexpr unsigned short kNDim = 1;

   TH1::AddDirectory(kFALSE);

   std::vector<double> input; // (count);
   input.resize(count);

   double minVal = -5.0;
   double maxVal = +5.0;
   GenerateInput(input, minVal, maxVal, 0);

   // Make sure we have some overflow.
   minVal *= 0.9;
   maxVal *= 0.9;

   cout << '\n';

   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::EE::Execute<R7::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);

   cout << '\n';

   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);
   R7::Dim<DataType_t, kNDim>::II::Execute<R7::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);

   cout << '\n';

   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::EE::Execute<R6::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);

   cout << '\n';

   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fillBuffered>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fillN>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);
   R6::Dim<DataType_t, kNDim>::II::Execute<R6::Dim<DataType_t, kNDim>::fill>(input, minVal, maxVal);
}

void histspeedtest(size_t iter = 1e6, int what = 255)
{
   if (what & 1)
      speedtest<double, 2>(iter);
   if (what & 2)
      speedtest<float, 2>(iter);
   if (what & 4)
      speedtest<double, 1>(iter);
   if (what & 8)
      speedtest<float, 1>(iter);
}

int main(int argc, char **argv)
{

   size_t iter = 1e7;
   int what = 1 | 2 | 4 | 8;
   if (argc > 1)
      iter = atof(argv[1]);
   if (argc > 2)
      what = atoi(argv[2]);

   histspeedtest(iter, what);
}