simpler

Author: HDembinski

include/boost/histogram/axis.hpp

@@ -15,7 +15,9 @@
 #include <boost/version.hpp>
 #if BOOST_VERSION < 106100
 #include <boost/utility/string_ref.hpp>
-namespace boost { using string_view = string_ref; }
+namespace boost {
+using string_view = string_ref;
+}
 #else
 #include <boost/utility/string_view.hpp>
 #endif
@@ -38,10 +40,7 @@ namespace boost {
 namespace histogram {
 namespace axis {
 
-enum {
-  with_uoflow = true,
-  without_uoflow = false
-};
+enum { with_uoflow = true, without_uoflow = false };
 
 template <typename Value> struct bin {
   int idx;
@@ -308,7 +307,8 @@ class regular : public axis_base<with_uoflow>,
  * bins for this axis. Binning is a O(1) operation.
  */
 template <typename RealType = double>
-class circular : public axis_base<without_uoflow>, boost::operators<regular<RealType>> {
+class circular : public axis_base<without_uoflow>,
+                 boost::operators<regular<RealType>> {
 public:
   using value_type = RealType;
   using const_iterator = axis_iterator<circular>;
@@ -323,7 +323,8 @@ class circular : public axis_base<without_uoflow>, boost::operators<regular<Real
   explicit circular(unsigned n, value_type phase = 0.0,
                     value_type perimeter = math::double_constants::two_pi,
                     string_view label = string_view())
-      : axis_base<without_uoflow>(n, label), phase_(phase), perimeter_(perimeter) {}
+      : axis_base<without_uoflow>(n, label), phase_(phase),
+        perimeter_(perimeter) {}
 
   circular() = default;
   circular(const circular &) = default;
@@ -369,7 +370,8 @@ class circular : public axis_base<without_uoflow>, boost::operators<regular<Real
  * and the problem domain allows it, prefer a regular.
  */
 template <typename RealType = double>
-class variable : public axis_base<with_uoflow>, boost::operators<variable<RealType>> {
+class variable : public axis_base<with_uoflow>,
+                 boost::operators<variable<RealType>> {
 public:
   using value_type = RealType;
   using const_iterator = axis_iterator<variable>;
@@ -392,8 +394,8 @@ class variable : public axis_base<with_uoflow>, boost::operators<variable<RealTy
   }
 
   template <typename Iterator>
-  variable(Iterator begin, Iterator end,
-           string_view label = string_view(), bool uoflow = true)
+  variable(Iterator begin, Iterator end, string_view label = string_view(),
+           bool uoflow = true)
       : axis_base<with_uoflow>(std::distance(begin, end) - 1, label, uoflow),
         x_(new value_type[std::distance(begin, end)]) {
     std::copy(begin, end, x_.get());
@@ -460,7 +462,8 @@ class variable : public axis_base<with_uoflow>, boost::operators<variable<RealTy
  * faster than a regular.
  */
 template <typename IntType = int>
-class integer : public axis_base<with_uoflow>, boost::operators<integer<IntType>> {
+class integer : public axis_base<with_uoflow>,
+                boost::operators<integer<IntType>> {
 public:
   using value_type = IntType;
   using const_iterator = axis_iterator<integer>;
@@ -470,8 +473,8 @@ class integer : public axis_base<with_uoflow>, boost::operators<integer<IntType>
    * \param min smallest integer of the covered range.
    * \param max largest integer of the covered range.
    */
-  integer(value_type min, value_type max,
-          string_view label = string_view(), bool uoflow = true)
+  integer(value_type min, value_type max, string_view label = string_view(),
+          bool uoflow = true)
       : axis_base<with_uoflow>(max + 1 - min, label, uoflow), min_(min) {
     if (min > max) {
       throw std::logic_error("min <= max required");
@@ -525,8 +528,7 @@ class category : public axis_base<without_uoflow>, boost::operators<category> {
   using const_iterator = axis_iterator<category>;
 
   template <typename Iterator>
-  category(Iterator begin, Iterator end,
-           string_view label = string_view())
+  category(Iterator begin, Iterator end, string_view label = string_view())
       : axis_base<without_uoflow>(std::distance(begin, end), label),
         ptr_(new std::string[bins()]) {
     std::copy(begin, end, ptr_.get());
@@ -555,7 +557,8 @@ class category : public axis_base<without_uoflow>, boost::operators<category> {
   }
 
   category(category &&other)
-      : axis_base<without_uoflow>(std::move(other)), ptr_(std::move(other.ptr_)) {}
+      : axis_base<without_uoflow>(std::move(other)),
+        ptr_(std::move(other.ptr_)) {}
 
   category &operator=(category &&other) {
     if (this != &other) {
@@ -598,8 +601,8 @@ class category : public axis_base<without_uoflow>, boost::operators<category> {
 } // namespace axis
 
 using builtin_axes =
-    mpl::vector<axis::regular<>, axis::circular<>,
-                axis::variable<>, axis::integer<>, axis::category>;
+    mpl::vector<axis::regular<>, axis::circular<>, axis::variable<>,
+                axis::integer<>, axis::category>;
 
 } // namespace histogram
 } // namespace boost

include/boost/histogram/detail/meta.hpp

@@ -65,7 +65,7 @@ template <typename Ns> std::vector<bool> bool_mask(unsigned n, bool v) {
 template <typename Axes, typename Ns> struct axes_assign_subset_op {
   const Axes &axes_;
   template <int N, typename R>
-  auto operator()(mpl::int_<N>, R &r) const -> mpl::int_<N+1> {
+  auto operator()(mpl::int_<N>, R &r) const -> mpl::int_<N + 1> {
     using I2 = typename mpl::at_c<Ns, N>::type;
     r = fusion::at_c<I2::value>(axes_);
     return {};
@@ -74,8 +74,7 @@ template <typename Axes, typename Ns> struct axes_assign_subset_op {
 
 template <typename Ns, typename Axes1, typename Axes>
 void axes_assign_subset(Axes1 &axes1, const Axes &axes) {
-  fusion::fold(axes1, mpl::int_<0>(),
-               axes_assign_subset_op<Axes, Ns>{axes});
+  fusion::fold(axes1, mpl::int_<0>(), axes_assign_subset_op<Axes, Ns>{axes});
 }
 
 template <typename Ns>

include/boost/histogram/detail/utility.hpp

@@ -29,35 +29,33 @@ inline void escape(std::ostream &os, const String &s) {
   os << '\'';
 }
 
-template <typename A, typename> struct lin {
-  static inline void apply(std::size_t &out, std::size_t &stride, const A &a,
-                           int j) noexcept {
-    // the following is highly optimized code that runs in a hot loop;
-    // please measure the performance impact of changes
-    const int uoflow = a.uoflow();
-    // set stride to zero if 'j' is not in range,
-    // this communicates the out-of-range condition to the caller
-    stride *= (j >= -uoflow) & (j < (a.bins() + uoflow));
-    j += (j < 0) * (a.bins() + 2); // wrap around if in < 0
-    out += j * stride;
+template <typename A>
+inline void lin(std::size_t &out, std::size_t &stride, const A &a,
+                int j) noexcept {
+  // the following is highly optimized code that runs in a hot loop;
+  // please measure the performance impact of changes
+  const int uoflow = a.uoflow();
+  // set stride to zero if 'j' is not in range,
+  // this communicates the out-of-range condition to the caller
+  stride *= (j >= -uoflow) & (j < (a.bins() + uoflow));
+  j += (j < 0) * (a.bins() + 2); // wrap around if in < 0
+  out += j * stride;
 #pragma GCC diagnostic ignored "-Wstrict-overflow"
-    stride *= a.shape();
-  }
-};
+  stride *= a.shape();
+}
 
-template <typename A, typename T> struct xlin {
-  static inline void apply(std::size_t &out, std::size_t &stride, const A &a,
-                           typename call_traits<T>::param_type x) noexcept {
-    // the following is highly optimized code that runs in a hot loop;
-    // please measure the performance impact of changes
-    int j = a.index(x);
-    // j is guaranteed to be in range [-1, bins]
-    j += (j < 0) * (a.bins() + 2); // wrap around if j < 0
-    out += j * stride;
+template <typename A, typename X>
+inline void xlin(std::size_t &out, std::size_t &stride, const A &a,
+                 X &&x) noexcept {
+  // the following is highly optimized code that runs in a hot loop;
+  // please measure the performance impact of changes
+  int j = a.index(std::forward<X>(x));
+  // j is guaranteed to be in range [-1, bins]
+  j += (j < 0) * (a.bins() + 2); // wrap around if j < 0
+  out += j * stride;
 #pragma GCC diagnostic ignored "-Wstrict-overflow"
-    stride *= (j < a.shape()) * a.shape(); // stride == 0 indicates out-of-range
-  }
-};
+  stride *= (j < a.shape()) * a.shape(); // stride == 0 indicates out-of-range
+}
 
 struct index_mapper {
   std::size_t first = 0, second = 0;

include/boost/histogram/histogram_fwd.hpp

@@ -8,11 +8,11 @@
 #define _BOOST_HISTOGRAM_HISTOGRAM_FWD_HPP_
 
 #include <boost/histogram/detail/meta.hpp>
-#include <boost/mpl/vector.hpp>
 #include <boost/mpl/int.hpp>
+#include <boost/mpl/vector.hpp>
+#include <initializer_list>
 #include <set>
 #include <type_traits>
-#include <initializer_list>
 
 namespace boost {
 namespace histogram {
@@ -26,37 +26,30 @@ class adaptive_storage;
 template <class Variant, class Axes, class Storage = adaptive_storage<>>
 class histogram;
 
-class weight {
-public:
-  explicit weight(double v) : value(v) {}
-  explicit operator double() const { return value; }
-
-private:
+struct weight {
+  weight(double w) : value(w) {}
   double value;
 };
 
-class count {
-public:
-  explicit count(unsigned v) : value(v) {}
-  explicit operator unsigned() const { return value; }
-
-private:
+struct count {
+  count(unsigned n) : value(n) {}
   unsigned value;
 };
 
 // for static and dynamic histogram
 template <int N, typename... Rest>
-inline auto keep(mpl::int_<N>, Rest...) -> detail::unique_sorted<mpl::vector<mpl::int_<N>, Rest...>> {
+inline auto keep(mpl::int_<N>, Rest...)
+    -> detail::unique_sorted<mpl::vector<mpl::int_<N>, Rest...>> {
   return {};
 }
 
 // for dynamic histogram only
 namespace detail {
 using keep_dynamic = std::set<unsigned>;
-inline void insert(keep_dynamic&) {} // end recursion
-template <typename First, typename... Rest>
-inline void insert(keep_dynamic& s, First f, Rest... rest) {
-  s.insert(static_cast<unsigned>(f));
+inline void insert(keep_dynamic &) {} // end recursion
+template <typename... Rest>
+inline void insert(keep_dynamic &s, unsigned i, Rest... rest) {
+  s.insert(i);
   insert(s, rest...);
 }
 } // namespace detail
@@ -67,9 +60,9 @@ inline detail::keep_dynamic keep(Iterator begin, Iterator end) {
 }
 
 template <typename... Rest>
-inline detail::keep_dynamic keep(unsigned dim, Rest... rest) {
+inline detail::keep_dynamic keep(unsigned i, Rest... rest) {
   detail::keep_dynamic s;
-  detail::insert(s, dim, rest...);
+  detail::insert(s, i, rest...);
   return s;
 }