BinnedUtils.h

Go to the documentation of this file.

// -*- C++ -*-
//
// This file is part of YODA -- Yet more Objects for Data Analysis
// Copyright (C) 2008-2023 The YODA collaboration (see AUTHORS for details)
//
#ifndef YODA_BinnedUtils_h
#define YODA_BinnedUtils_h
 
#include "YODA/Utils/BinningUtils.h"
 
namespace YODA {
 
 
  template <class Derived, typename EdgeT = double>
  struct XAxisMixin {
 
 
    size_t numBinsX(const bool includeOverflows=false) const {
      return static_cast<const Derived*>(this)->numBinsAt(0, includeOverflows);
    }
 
    template <class T = EdgeT>
    enable_if_CAxisT<T> xMin() const { return static_cast<const Derived*>(this)->template min<0>(); }
 
    template <class T = EdgeT>
    enable_if_CAxisT<T> xMax() const { return static_cast<const Derived*>(this)->template max<0>(); }
 
    std::vector<EdgeT> xEdges(const bool includeOverflows = false) const {
      return static_cast<const Derived*>(this)->template edges<0>(includeOverflows);
    }
 
    template <class T = EdgeT>
    std::enable_if_t<std::is_floating_point<T>::value, std::vector<T>>
    xWidths(const bool includeOverflows = false) const {
      return static_cast<const Derived*>(this)->template widths<0>(includeOverflows);
    }
 
    void rebinXBy(unsigned int n, size_t begin=1, size_t end=UINT_MAX) {
      static_cast<Derived*>(this)->template rebinBy<0>(n, begin, end);
    }
 
    void rebinXTo(const std::vector<double>& newedges) {
      static_cast<Derived*>(this)->template rebinTo<0>(newedges);
    }
 
    void rebinX(unsigned int n, size_t begin=1, size_t end=UINT_MAX) {
      static_cast<Derived*>(this)->template rebinBy<0>(n, begin, end);
    }
 
    void rebinX(const std::vector<double>& newedges) {
      static_cast<Derived*>(this)->template rebinTo<0>(newedges);
    }
 
 
  };
 
 
  template <class Derived>
  struct XStatsMixin {
 
 
    double xMean(const bool includeOverflows=true) const noexcept {
      return static_cast<const Derived*>(this)->mean(0, includeOverflows);
    }
 
    double xVariance(const bool includeOverflows=true) const noexcept {
      return static_cast<const Derived*>(this)->variance(0, includeOverflows);
    }
 
    double xStdDev(const bool includeOverflows=true) const noexcept {
      return static_cast<const Derived*>(this)->stdDev(0, includeOverflows);
    }
 
    double xStdErr(const bool includeOverflows=true) const noexcept {
      return static_cast<const Derived*>(this)->stdErr(0, includeOverflows);
    }
 
    double xRMS(const bool includeOverflows=true) const noexcept {
      return static_cast<const Derived*>(this)->rms(0, includeOverflows);
    }
 
  };
 
 
  template <class Derived, typename EdgeT = double>
  struct YAxisMixin {
 
 
    size_t numBinsY(const bool includeOverflows=false) const {
      return static_cast<const Derived*>(this)->numBinsAt(1, includeOverflows);
    }
 
    template <class T = EdgeT>
    enable_if_CAxisT<T> yMin() const { return static_cast<const Derived*>(this)->template min<1>(); }
 
    template <class T = EdgeT>
    enable_if_CAxisT<T> yMax() const { return static_cast<const Derived*>(this)->template max<1>(); }
 
    std::vector<EdgeT> yEdges(const bool includeOverflows = false) const {
      return static_cast<const Derived*>(this)->template edges<1>(includeOverflows);
    }
 
    template <class T = EdgeT>
    std::enable_if_t<std::is_floating_point<T>::value, std::vector<T>>
    yWidths(const bool includeOverflows = false) const {
      return static_cast<const Derived*>(this)->template widths<1>(includeOverflows);
    }
 
    void rebinYBy(unsigned int n, size_t begin=1, size_t end=UINT_MAX) {
      static_cast<Derived*>(this)->template rebinBy<1>(n, begin, end);
    }
 
    void rebinYTo(const std::vector<double>& newedges) {
      static_cast<Derived*>(this)->template rebinTo<1>(newedges);
    }
 
    void rebinY(unsigned int n, size_t begin=1, size_t end=UINT_MAX) {
      static_cast<Derived*>(this)->template rebinBy<1>(n, begin, end);
    }
 
    void rebinY(const std::vector<double>& newedges) {
      static_cast<Derived*>(this)->template rebinTo<1>(newedges);
    }
 
 
  };
 
  template <class Derived>
  struct YStatsMixin {
 
 
    double yMean(const bool includeOverflows=true) const noexcept {
      return static_cast<const Derived*>(this)->mean(1, includeOverflows);
    }
 
    double yVariance(const bool includeOverflows=true) const noexcept {
      return static_cast<const Derived*>(this)->variance(1, includeOverflows);
    }
 
    double yStdDev(const bool includeOverflows=true) const noexcept {
      return static_cast<const Derived*>(this)->stdDev(1, includeOverflows);
    }
 
    double yStdErr(const bool includeOverflows=true) const noexcept {
      return static_cast<const Derived*>(this)->stdErr(1, includeOverflows);
    }
 
    double yRMS(const bool includeOverflows=true) const noexcept {
      return static_cast<const Derived*>(this)->rms(1, includeOverflows);
    }
 
  };
 
 
  template <class Derived, typename EdgeT = double>
  struct ZAxisMixin {
 
 
    size_t numBinsZ(const bool includeOverflows=false) const {
      return static_cast<const Derived*>(this)->numBinsAt(2, includeOverflows);
    }
 
    template <class T = EdgeT>
    enable_if_CAxisT<T> zMin() const { return static_cast<const Derived*>(this)->template min<2>(); }
 
    template <class T = EdgeT>
    enable_if_CAxisT<T> zMax() const { return static_cast<const Derived*>(this)->template max<2>(); }
 
    std::vector<EdgeT> zEdges(const bool includeOverflows = false) const {
      return static_cast<const Derived*>(this)->template edges<2>(includeOverflows);
    }
 
    template <class T = EdgeT>
    std::enable_if_t<std::is_floating_point<T>::value, std::vector<T>>
    zWidths(const bool includeOverflows = false) const {
      return static_cast<const Derived*>(this)->template widths<2>(includeOverflows);
    }
 
    void rebinZBy(unsigned int n, size_t begin=1, size_t end=UINT_MAX) {
      static_cast<Derived*>(this)->template rebinBy<2>(n, begin, end);
    }
 
    void rebinZTo(const std::vector<double>& newedges) {
      static_cast<Derived*>(this)->template rebinTo<2>(newedges);
    }
 
    void rebinZ(unsigned int n, size_t begin=1, size_t end=UINT_MAX) {
      static_cast<Derived*>(this)->template rebinBy<2>(n, begin, end);
    }
 
    void rebinZ(const std::vector<double>& newedges) {
      static_cast<Derived*>(this)->template rebinTo<2>(newedges);
    }
 
 
  };
 
  template <class Derived>
  struct ZStatsMixin {
 
 
    double zMean(const bool includeOverflows=true) const noexcept {
      return static_cast<const Derived*>(this)->mean(2, includeOverflows);
    }
 
    double zVariance(const bool includeOverflows=true) const noexcept {
      return static_cast<const Derived*>(this)->variance(2, includeOverflows);
    }
 
    double zStdDev(const bool includeOverflows=true) const noexcept {
      return static_cast<const Derived*>(this)->stdDev(2, includeOverflows);
    }
 
    double zStdErr(const bool includeOverflows=true) const noexcept {
      return static_cast<const Derived*>(this)->stdErr(2, includeOverflows);
    }
 
    double zRMS(const bool includeOverflows=true) const noexcept {
      return static_cast<const Derived*>(this)->rms(2, includeOverflows);
    }
 
  };
 
 
}
 
#endif