RAxes.hxx

Go to the documentation of this file.

/// \file
/// \warning This is part of the %ROOT 7 prototype! It will change without notice. It might trigger earthquakes.
/// Feedback is welcome!
 
#ifndef ROOT_RAxes
#define ROOT_RAxes
 
#include "RAxisVariant.hxx"
#include "RBinIndex.hxx"
#include "RBinIndexMultiDimRange.hxx"
#include "RBinIndexRange.hxx"
#include "RCategoricalAxis.hxx"
#include "RLinearizedIndex.hxx"
#include "RRegularAxis.hxx"
#include "RVariableBinAxis.hxx"
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <stdexcept>
#include <tuple>
#include <type_traits>
#include <utility>
#include <variant>
#include <vector>
 
class TBuffer;
 
namespace ROOT {
namespace Experimental {
 
// forward declaration for friend declaration
template <typename T>
class RHistEngine;
 
namespace Internal {
 
/**
Bin configurations for all dimensions of a histogram.
*/
class RAxes final {
   template <typename T>
   friend class ::ROOT::Experimental::RHistEngine;
 
   std::vector<RAxisVariant> fAxes;
 
public:
   /// \param[in] axes the axis objects, must have size > 0
   explicit RAxes(std::vector<RAxisVariant> axes) : fAxes(std::move(axes))
   {
      if (fAxes.empty()) {
         throw std::invalid_argument("must have at least 1 axis object");
      }
   }
 
   std::size_t GetNDimensions() const { return fAxes.size(); }
   const std::vector<RAxisVariant> &Get() const { return fAxes; }
 
   friend bool operator==(const RAxes &lhs, const RAxes &rhs) { return lhs.fAxes == rhs.fAxes; }
   friend bool operator!=(const RAxes &lhs, const RAxes &rhs) { return !(lhs == rhs); }
 
   /// Compute the total number of bins for all axes.
   ///
   /// It is the product of each dimension's total number of bins.
   ///
   /// \return the total number of bins
   std::uint64_t ComputeTotalNBins() const
   {
      std::uint64_t totalNBins = 1;
      for (auto &&axis : fAxes) {
         totalNBins *= axis.GetTotalNBins();
      }
      return totalNBins;
   }
 
private:
   template <std::size_t I, std::size_t N, typename... A>
   RLinearizedIndex ComputeGlobalIndexImpl(std::size_t index, const std::tuple<A...> &args) const
   {
      using ArgumentType = std::tuple_element_t<I, std::tuple<A...>>;
      const auto &axis = fAxes[I];
      RLinearizedIndex linIndex;
      if (auto *regular = axis.GetRegularAxis()) {
         if constexpr (std::is_convertible_v<ArgumentType, RRegularAxis::ArgumentType>) {
            index *= regular->GetTotalNBins();
            linIndex = regular->ComputeLinearizedIndex(std::get<I>(args));
         } else {
            throw std::invalid_argument("invalid type of argument");
         }
      } else if (auto *variable = axis.GetVariableBinAxis()) {
         if constexpr (std::is_convertible_v<ArgumentType, RVariableBinAxis::ArgumentType>) {
            index *= variable->GetTotalNBins();
            linIndex = variable->ComputeLinearizedIndex(std::get<I>(args));
         } else {
            throw std::invalid_argument("invalid type of argument");
         }
      } else if (auto *categorical = axis.GetCategoricalAxis()) {
         if constexpr (std::is_convertible_v<ArgumentType, RCategoricalAxis::ArgumentType>) {
            index *= categorical->GetTotalNBins();
            linIndex = categorical->ComputeLinearizedIndex(std::get<I>(args));
         } else {
            throw std::invalid_argument("invalid type of argument");
         }
      } else {
         throw std::logic_error("unimplemented axis type"); // GCOVR_EXCL_LINE
      }
      if (!linIndex.fValid) {
         return {0, false};
      }
      index += linIndex.fIndex;
      if constexpr (I + 1 < N) {
         return ComputeGlobalIndexImpl<I + 1, N>(index, args);
      }
      return {index, true};
   }
 
   template <std::size_t N, typename... A>
   RLinearizedIndex ComputeGlobalIndexImpl(const std::tuple<A...> &args) const
   {
      return ComputeGlobalIndexImpl<0, N>(0, args);
   }
 
public:
   /// Compute the global index for all axes.
   ///
   /// Throws an exception if the number of arguments does not match the axis configuration, or if an argument cannot be
   /// converted for the axis type at run-time.
   ///
   /// \param[in] args the arguments
   /// \return the global index that may be invalid
   template <typename... A>
   RLinearizedIndex ComputeGlobalIndex(const std::tuple<A...> &args) const
   {
      if (sizeof...(A) != fAxes.size()) {
         throw std::invalid_argument("invalid number of arguments to ComputeGlobalIndex");
      }
      return ComputeGlobalIndexImpl<sizeof...(A)>(args);
   }
 
private:
   template <typename Container>
   RLinearizedIndex ComputeGlobalIndexImpl(const Container &indices) const
   {
      const auto N = indices.size();
      if (N != fAxes.size()) {
         throw std::invalid_argument("invalid number of indices passed to ComputeGlobalIndex");
      }
      std::uint64_t globalIndex = 0;
      for (std::size_t i = 0; i < N; i++) {
         const auto &index = indices[i];
         const auto &axis = fAxes[i];
         RLinearizedIndex linIndex;
         if (auto *regular = axis.GetRegularAxis()) {
            globalIndex *= regular->GetTotalNBins();
            linIndex = regular->GetLinearizedIndex(index);
         } else if (auto *variable = axis.GetVariableBinAxis()) {
            globalIndex *= variable->GetTotalNBins();
            linIndex = variable->GetLinearizedIndex(index);
         } else if (auto *categorical = axis.GetCategoricalAxis()) {
            globalIndex *= categorical->GetTotalNBins();
            linIndex = categorical->GetLinearizedIndex(index);
         } else {
            throw std::logic_error("unimplemented axis type"); // GCOVR_EXCL_LINE
         }
         if (!linIndex.fValid) {
            return {0, false};
         }
         globalIndex += linIndex.fIndex;
      }
      return {globalIndex, true};
   }
 
public:
   /// Compute the global index for all axes.
   ///
   /// \param[in] indices the array of RBinIndex
   /// \return the global index that may be invalid
   template <std::size_t N>
   RLinearizedIndex ComputeGlobalIndex(const std::array<RBinIndex, N> &indices) const
   {
      return ComputeGlobalIndexImpl(indices);
   }
 
   /// Compute the global index for all axes.
   ///
   /// \param[in] indices the vector of RBinIndex
   /// \return the global index that may be invalid
   RLinearizedIndex ComputeGlobalIndex(const std::vector<RBinIndex> &indices) const
   {
      return ComputeGlobalIndexImpl(indices);
   }
 
   /// Get the multidimensional range of all bins.
   ///
   /// \return the multidimensional range
   RBinIndexMultiDimRange GetFullMultiDimRange() const
   {
      std::vector<RBinIndexRange> ranges;
      for (auto &&axis : fAxes) {
         ranges.push_back(axis.GetFullRange());
      }
      return RBinIndexMultiDimRange(std::move(ranges));
   }
 
   /// %ROOT Streamer function to throw when trying to store an object of this class.
   void Streamer(TBuffer &) { throw std::runtime_error("unable to store RAxes"); }
};
 
} // namespace Internal
} // namespace Experimental
} // namespace ROOT
 
#endif