From 7e8b2bb40357d82b018c4f4a7fd9fe4498f39952 Mon Sep 17 00:00:00 2001
From: Hans Dembinski <hans.dembinski@gmail.com>
Date: Fri, 13 Oct 2017 11:20:59 +0200
Subject: [PATCH] replaced container_storage with array_storage, simplified
 comparison between storage types

---
 doc/benchmarks.qbk                            |   6 +-
 doc/changelog.qbk                             |   2 +-
 doc/concepts.qbk                              |   2 +-
 doc/rationale.qbk                             |   2 +-
 include/boost/histogram.hpp                   |   2 +-
 include/boost/histogram/axis.hpp              |   2 +-
 include/boost/histogram/histogram_fwd.hpp     |   4 +-
 .../histogram/histogram_impl_dynamic.hpp      |   1 +
 .../boost/histogram/histogram_impl_static.hpp |   1 +
 include/boost/histogram/serialization.hpp     |   6 +-
 .../histogram/storage/adaptive_storage.hpp    |  58 +--------
 .../boost/histogram/storage/array_storage.hpp | 112 ++++++++++++++++++
 .../histogram/storage/container_storage.hpp   |  99 ----------------
 include/boost/histogram/storage/operators.hpp |  35 ++++++
 test/adaptive_storage_test.cpp                |  36 +++---
 ...torage_test.cpp => array_storage_test.cpp} |  46 ++-----
 test/histogram_test.cpp                       |  33 +++---
 test/speed_cpp.cpp                            |  19 ++-
 18 files changed, 215 insertions(+), 251 deletions(-)
 create mode 100644 include/boost/histogram/storage/array_storage.hpp
 delete mode 100644 include/boost/histogram/storage/container_storage.hpp
 create mode 100644 include/boost/histogram/storage/operators.hpp
 rename test/{container_storage_test.cpp => array_storage_test.cpp} (59%)

diff --git a/doc/benchmarks.qbk b/doc/benchmarks.qbk
index 7aa23b61..e8bb4e52 100644
--- a/doc/benchmarks.qbk
+++ b/doc/benchmarks.qbk
@@ -10,13 +10,13 @@ The following plot shows results of a benchmark on a 9 GHz Macbook Pro. Random n
 	[[root] [[@https://root.cern.ch ROOT classes] (`TH1I` for 1D, `TH3I` for 3D and `THnI` for 6D)]]
 	[[py:numpy] [numpy functions ([python]`numpy.histogram` for 1D, `numpy.histogramdd` for 2D, 3D, and 6D)]]
 	[[py:hd_sd] [[classref boost::histogram::histogram<Dynamic,...>] with [classref boost::histogram::adaptive_storage<>], called from Python]]
-	[[hs_ss] [[classref boost::histogram::histogram<Static,...>] with [classref boost::histogram::container_storage<std::vector<int>>]]]
+	[[hs_ss] [[classref boost::histogram::histogram<Static,...>] with [classref boost::histogram::array_storage<int>]]]
 	[[hs_sd] [[classref boost::histogram::histogram<Static,...>] with [classref boost::histogram::adaptive_storage<>]]]
-	[[hd_ss] [[classref boost::histogram::histogram<Dynamic,...>] with [classref boost::histogram::container_storage<std::vector<int>>]]]
+	[[hd_ss] [[classref boost::histogram::histogram<Dynamic,...>] with [classref boost::histogram::array_storage<int>]]]
 	[[hd_sd] [[classref boost::histogram::histogram<Dynamic,...>] with [classref boost::histogram::adaptive_storage<>]]]
 ]
 
-[classref boost::histogram::histogram<Static,...>] is always faster than [classref boost::histogram::histogram<Dynamic,...>] and safer to use, as more checks are done at compile time. It is recommended when working in C++ only. [classref boost::histogram::adaptive_storage] is faster than [classref boost::histogram::container_storage] for histograms with many bins, because it uses the cache more effectively due to its smaller memory consumption per bin. If the number of bins is small, it is slower because of the instruction and allocation overhead of handling memory in a dynamic way.
+[classref boost::histogram::histogram<Static,...>] is always faster than [classref boost::histogram::histogram<Dynamic,...>] and safer to use, as more checks are done at compile time. It is recommended when working in C++ only. [classref boost::histogram::adaptive_storage] is faster than [classref boost::histogram::array_storage] for histograms with many bins, because it uses the cache more effectively due to its smaller memory consumption per bin. If the number of bins is small, it is slower because of overhead of handling memory in a dynamic way.
 
 The histograms in this library are mostly faster than the competition, in some cases by a factor of 2. Simultaneously they are more flexible, since binning strategies can be customised. The Python-wrapped histogram is slower than numpy's own specialized function for 1D, but beats numpy's multi-dimensional histogramming function by a factor 2 to 3.
 
diff --git a/doc/changelog.qbk b/doc/changelog.qbk
index 85fba763..2d91c097 100644
--- a/doc/changelog.qbk
+++ b/doc/changelog.qbk
@@ -5,7 +5,7 @@
 * Added static_histogram (v1.0 only had dynamic_histogram).
 * Merged wfill(...) and fill(...) interface.
 * Support custom allocators in storage classes.
-* Replaced static_storage with container_storage, which may use any STL-compatible container with random access iterators as a backend, including std::array.
+* Replaced static_storage with array_storage.
 * Replaced dynamic_storage with adaptive_storage, which adds the capability to grow the bin counter into a cpp_int, thus avoiding integer overflow completely.
 * Serialization uses binary_archive instead of text_archive. The latter is portable, but the performance is terrible.
 * Python interface changed: histograms are now iterable, returning axis classes
diff --git a/doc/concepts.qbk b/doc/concepts.qbk
index e5e88695..00f53c8f 100644
--- a/doc/concepts.qbk
+++ b/doc/concepts.qbk
@@ -54,7 +54,7 @@ To support weighted fills, an additional method is required:
 
 * `void weighted_increase(std::size_t index, value_type weight)`
 
-[classref boost::histogram::container_storage] is a simple example of a storage type which does not support weighted fills.
+[classref boost::histogram::array_storage] is a simple example of a storage type which does not support weighted fills.
 
 [endsect]
 
diff --git a/doc/rationale.qbk b/doc/rationale.qbk
index c48d9e84..044665be 100644
--- a/doc/rationale.qbk
+++ b/doc/rationale.qbk
@@ -54,7 +54,7 @@ Library users can create their own axis classes and use them with the library, b
 
 [section:storage_types Storage types]
 
-Dense (aka contiguous) storage in memory is needed for fast bin lookup, which is of the random-access variety and may be happening in a tight loop. All storage types therefore implement dense storage of bin counters. [classref boost::histogram::container_storage] implements a storage based on an STL-conforming container and that could be the end of story, but there are several issues with this approach. For one, it is not convenient, because the user has to decide what type to use to hold the bin counts and it is not an obvious choice. The integer needs to be large enough to avoid counter overflow, but if it is too large and only a fraction of the bits are used, then it is a waste of memory. Using floating point numbers is even more dangerous. They don't overflow, but cap the bin count when the bits in the mantissa are used up.
+Dense (aka contiguous) storage in memory is needed for fast bin lookup, which is of the random-access variety and may be happening in a tight loop. All storage types therefore implement dense storage of bin counters. [classref boost::histogram::array_storage] implements a storage based on a heap-allocated array. That could be the end of story, but there are several issues with this approach. For one, it is not convenient, because the user has to decide what type to use to hold the bin counts and it is not an obvious choice. The integer needs to be large enough to avoid counter overflow, but if it is too large and only a fraction of the bits are used, then it is a waste of memory. Using floating point numbers is even more dangerous. They don't overflow, but cap the bin count when the bits in the mantissa are used up.
 
 The standard storage used in the library is [classref boost::histogram::adaptive_storage], which solves these issues in an effective way, based on the following insight.
 
diff --git a/include/boost/histogram.hpp b/include/boost/histogram.hpp
index d42561f8..d1409d64 100644
--- a/include/boost/histogram.hpp
+++ b/include/boost/histogram.hpp
@@ -11,7 +11,7 @@
 #include <boost/histogram/histogram.hpp>
 #include <boost/histogram/literals.hpp>
 #include <boost/histogram/storage/adaptive_storage.hpp>
-#include <boost/histogram/storage/container_storage.hpp>
+#include <boost/histogram/storage/array_storage.hpp>
 #include <boost/histogram/utility.hpp>
 
 /**
diff --git a/include/boost/histogram/axis.hpp b/include/boost/histogram/axis.hpp
index f6bf8ebf..f57852a6 100644
--- a/include/boost/histogram/axis.hpp
+++ b/include/boost/histogram/axis.hpp
@@ -22,11 +22,11 @@
 #endif
 #include <cmath>
 #include <limits>
+#include <memory>
 #include <stdexcept>
 #include <string>
 #include <type_traits>
 #include <vector>
-#include <memory>
 
 // forward declaration for serialization
 namespace boost {
diff --git a/include/boost/histogram/histogram_fwd.hpp b/include/boost/histogram/histogram_fwd.hpp
index b188cd09..fa527aaf 100644
--- a/include/boost/histogram/histogram_fwd.hpp
+++ b/include/boost/histogram/histogram_fwd.hpp
@@ -8,7 +8,6 @@
 #define _BOOST_HISTOGRAM_HISTOGRAM_FWD_HPP_
 
 #include <boost/histogram/detail/meta.hpp>
-#include <boost/histogram/storage/adaptive_storage.hpp>
 #include <set>
 #include <type_traits>
 
@@ -18,6 +17,9 @@ namespace histogram {
 using Static = std::integral_constant<int, 0>;
 using Dynamic = std::integral_constant<int, 1>;
 
+template <template <class> class Allocator = std::allocator>
+class adaptive_storage;
+
 template <class Variant, class Axes, class Storage = adaptive_storage<>>
 class histogram;
 
diff --git a/include/boost/histogram/histogram_impl_dynamic.hpp b/include/boost/histogram/histogram_impl_dynamic.hpp
index 8e476a7e..f3a23bbb 100644
--- a/include/boost/histogram/histogram_impl_dynamic.hpp
+++ b/include/boost/histogram/histogram_impl_dynamic.hpp
@@ -15,6 +15,7 @@
 #include <boost/histogram/detail/meta.hpp>
 #include <boost/histogram/detail/utility.hpp>
 #include <boost/histogram/histogram_fwd.hpp>
+#include <boost/histogram/storage/operators.hpp>
 #include <boost/mpl/count.hpp>
 #include <boost/mpl/empty.hpp>
 #include <boost/mpl/int.hpp>
diff --git a/include/boost/histogram/histogram_impl_static.hpp b/include/boost/histogram/histogram_impl_static.hpp
index d4e1e0ef..be216d58 100644
--- a/include/boost/histogram/histogram_impl_static.hpp
+++ b/include/boost/histogram/histogram_impl_static.hpp
@@ -26,6 +26,7 @@
 #include <boost/histogram/detail/meta.hpp>
 #include <boost/histogram/detail/utility.hpp>
 #include <boost/histogram/histogram_fwd.hpp>
+#include <boost/histogram/storage/operators.hpp>
 #include <boost/mpl/count.hpp>
 #include <boost/mpl/empty.hpp>
 #include <boost/mpl/int.hpp>
diff --git a/include/boost/histogram/serialization.hpp b/include/boost/histogram/serialization.hpp
index eb1b9cb2..71167f5a 100644
--- a/include/boost/histogram/serialization.hpp
+++ b/include/boost/histogram/serialization.hpp
@@ -13,7 +13,7 @@
 #include <boost/histogram/detail/weight.hpp>
 #include <boost/histogram/histogram.hpp>
 #include <boost/histogram/storage/adaptive_storage.hpp>
-#include <boost/histogram/storage/container_storage.hpp>
+#include <boost/histogram/storage/array_storage.hpp>
 #include <boost/serialization/array.hpp>
 #include <boost/serialization/variant.hpp>
 #include <boost/serialization/vector.hpp>
@@ -43,9 +43,9 @@ template <typename Archive> struct serialize_helper {
 } // namespace detail
 
 template <class Archive, typename Container>
-void serialize(Archive &ar, container_storage<Container> &store,
+void serialize(Archive &ar, array_storage<Container> &store,
                unsigned /* version */) {
-  ar &store.c_;
+  ar &store.array_;
 }
 
 template <template <class> class Allocator>
diff --git a/include/boost/histogram/storage/adaptive_storage.hpp b/include/boost/histogram/storage/adaptive_storage.hpp
index 01e1a8c9..207f96c8 100644
--- a/include/boost/histogram/storage/adaptive_storage.hpp
+++ b/include/boost/histogram/storage/adaptive_storage.hpp
@@ -138,8 +138,7 @@ template <> struct next_type<uint64_t> { using type = mp_int; };
 
 } // namespace detail
 
-template <template <class> class Allocator = std::allocator>
-class adaptive_storage {
+template <template <class> class Allocator> class adaptive_storage {
   template <typename T> using array = detail::array<Allocator, T>;
   template <typename T> using next = typename detail::next_type<T>::type;
   using weight = detail::weight;
@@ -221,10 +220,6 @@ public:
     return apply_visitor(bicmp_visitor(), buffer_, rhs.buffer_);
   }
 
-  template <typename S> bool operator==(const S &rhs) const {
-    return apply_visitor(cmp_visitor<S>(rhs), buffer_);
-  }
-
 private:
   struct size_visitor : public static_visitor<std::size_t> {
     template <typename Array> std::size_t operator()(const Array &b) const {
@@ -418,52 +413,6 @@ private:
     }
   };
 
-  template <typename S> struct cmp_visitor : public static_visitor<bool> {
-    const S &os;
-    cmp_visitor(const S &o) : os(o) {}
-
-    template <typename Array> bool operator()(const Array &b) const {
-      if (b.size != os.size())
-        return false;
-      for (std::size_t i = 0; i < b.size; ++i) {
-        if (b[i] != os.value(i))
-          return false;
-      }
-      return true;
-    }
-
-    bool operator()(const array<mp_int> &b) const {
-      if (b.size != os.size())
-        return false;
-      for (std::size_t i = 0; i < b.size; ++i) {
-        if (static_cast<value_type>(b[i]) != os.value(i))
-          return false;
-      }
-      return true;
-    }
-
-    bool operator()(const array<weight> &b) const {
-      if (b.size != os.size())
-        return false;
-      for (std::size_t i = 0; i < b.size; ++i) {
-        auto &x = b[i];
-        if (x.w != os.value(i) || x.w2 != os.variance(i))
-          return false;
-      }
-      return true;
-    }
-
-    bool operator()(const array<void> &b) const {
-      if (b.size != os.size())
-        return false;
-      for (std::size_t i = 0; i < b.size; ++i) {
-        if (os.value(i) != 0)
-          return false;
-      }
-      return true;
-    }
-  };
-
   buffer_type buffer_;
 
   friend class ::boost::python::access;
@@ -471,11 +420,6 @@ private:
   template <class Archive> void serialize(Archive &, unsigned);
 };
 
-template <template <class> class Allocator, typename S>
-bool operator==(const S &a, const adaptive_storage<Allocator> &b) {
-  return b == a;
-}
-
 } // namespace histogram
 } // namespace boost
 
diff --git a/include/boost/histogram/storage/array_storage.hpp b/include/boost/histogram/storage/array_storage.hpp
new file mode 100644
index 00000000..00b168b5
--- /dev/null
+++ b/include/boost/histogram/storage/array_storage.hpp
@@ -0,0 +1,112 @@
+// Copyright 2015-2016 Hans Dembinski
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef _BOOST_HISTOGRAM_STORAGE_ARRAY_HPP_
+#define _BOOST_HISTOGRAM_STORAGE_ARRAY_HPP_
+
+#include <algorithm>
+#include <boost/histogram/detail/meta.hpp>
+#include <boost/type_traits.hpp>
+#include <cstddef>
+#include <memory>
+
+// forward declaration for serialization
+namespace boost {
+namespace serialization {
+class access;
+}
+} // namespace boost
+
+namespace boost {
+namespace histogram {
+
+namespace detail {} // namespace detail
+
+template <typename T> class array_storage {
+public:
+  static_assert(is_arithmetic<T>::value, "T must support arithmetic operators");
+  using value_type = T;
+
+  explicit array_storage(std::size_t s) { init(s); }
+
+  array_storage() = default;
+  array_storage(const array_storage &other) {
+    reset(other.size());
+    std::copy(other.array_.get(), other.array_.get() + size_, array_.get());
+  }
+  array_storage &operator=(const array_storage &other) {
+    if (this != &other) {
+      reset(other.size());
+      std::copy(other.array_.get(), other.array_.get() + size_, array_.get());
+    }
+    return *this;
+  }
+  array_storage(array_storage &&other) {
+    std::swap(size_, other.size_);
+    std::swap(array_, other.array_);
+  }
+  array_storage &operator=(array_storage &&other) {
+    if (this != &other) {
+      std::swap(size_, other.size_);
+      std::swap(array_, other.array_);
+    }
+    return *this;
+  }
+
+  template <typename S, typename = detail::is_storage<S>>
+  explicit array_storage(const S &other) {
+    reset(other.size());
+    for (decltype(size_) i = 0u; i < size_; ++i) {
+      array_[i] = other.value(i);
+    }
+  }
+
+  template <typename S> array_storage &operator=(const S &other) {
+    reset(other.size());
+    for (decltype(size_) i = 0u; i < size_; ++i) {
+      array_[i] = other.value(i);
+    }
+    return *this;
+  }
+
+  std::size_t size() const noexcept { return size_; }
+  void increase(std::size_t i) noexcept { ++array_[i]; }
+  template <typename Value>
+  void increase(std::size_t i, const Value &n) noexcept {
+    array_[i] += n;
+  }
+
+  void add(std::size_t i, const value_type &val,
+           const value_type & /* var */) noexcept {
+    array_[i] += val;
+  }
+
+  value_type value(std::size_t i) const noexcept { return array_[i]; }
+  value_type variance(std::size_t i) const noexcept { return array_[i]; }
+
+private:
+  std::size_t size_ = 0;
+  std::unique_ptr<T[]> array_;
+
+  void reset(std::size_t size) {
+    size_ = size;
+    array_.reset(new T[size]);
+  }
+  void init(std::size_t size) {
+    reset(size);
+    std::fill(array_.get(), array_.get() + size, T(0));
+  }
+
+  template <typename U> friend class array_storage;
+
+  friend class ::boost::serialization::access;
+  template <typename Archive> void serialize(Archive &, unsigned);
+};
+
+} // namespace histogram
+} // namespace boost
+
+#endif
diff --git a/include/boost/histogram/storage/container_storage.hpp b/include/boost/histogram/storage/container_storage.hpp
deleted file mode 100644
index f61e58a5..00000000
--- a/include/boost/histogram/storage/container_storage.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-// Copyright 2015-2016 Hans Dembinski
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt
-// or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef _BOOST_HISTOGRAM_STORAGE_CONTAINER_HPP_
-#define _BOOST_HISTOGRAM_STORAGE_CONTAINER_HPP_
-
-#include <algorithm>
-#include <boost/histogram/detail/meta.hpp>
-#include <cstddef>
-
-// forward declaration for serialization
-namespace boost {
-namespace serialization {
-class access;
-}
-} // namespace boost
-
-namespace boost {
-namespace histogram {
-
-namespace detail {
-template <typename Container> void init(Container &c, unsigned s) {
-  if (c.size() != s) {
-    c = Container(s, typename Container::value_type(0));
-  } else {
-    std::fill(c.begin(), c.end(), typename Container::value_type(0));
-  }
-}
-
-// template signature of both std::array and boost::array
-template <template <class, std::size_t> class Array, typename T, std::size_t N>
-void init(Array<T, N> &c, unsigned /*unused*/) {
-  std::fill(c.begin(), c.end(), typename Array<T, N>::value_type(0));
-}
-} // namespace detail
-
-template <typename Container> class container_storage {
-public:
-  using value_type = typename Container::value_type;
-
-  explicit container_storage(std::size_t s) { detail::init(container_, s); }
-
-  container_storage() : container_() {} // cannot be defaulted
-  container_storage(const container_storage &) = default;
-  container_storage &operator=(const container_storage &) = default;
-  container_storage(container_storage &&) = default;
-  container_storage &operator=(container_storage &&) = default;
-
-  template <typename S, typename = detail::is_storage<S>>
-  explicit container_storage(const S &other) {
-    detail::init(container_, other.size());
-    for (std::size_t i = 0; i < container_.size(); ++i) {
-      container_[i] = other.value(i);
-    }
-  }
-
-  template <typename S> container_storage &operator=(const S &other) {
-    detail::init(container_, other.size());
-    for (std::size_t i = 0; i < container_.size(); ++i) {
-      container_[i] = other.value(i);
-    }
-    return *this;
-  }
-
-  std::size_t size() const { return container_.size(); }
-  void increase(std::size_t i) { ++(container_[i]); }
-  template <typename Value> void increase(std::size_t i, const Value &n) {
-    container_[i] += n;
-  }
-
-  void add(std::size_t i, const value_type &val, const value_type & /* var */) {
-    container_[i] += val;
-  }
-
-  value_type value(std::size_t i) const { return container_[i]; }
-  value_type variance(std::size_t i) const { return container_[i]; }
-
-  template <typename C> bool operator==(const container_storage<C> &rhs) {
-    return container_.size() == rhs.container_.size() &&
-           std::equal(container_.begin(), container_.end(),
-                      rhs.container_.begin());
-  }
-
-private:
-  Container container_;
-
-  template <typename C> friend class container_storage;
-
-  friend class ::boost::serialization::access;
-  template <typename Archive> void serialize(Archive &, unsigned);
-};
-
-} // namespace histogram
-} // namespace boost
-
-#endif
diff --git a/include/boost/histogram/storage/operators.hpp b/include/boost/histogram/storage/operators.hpp
new file mode 100644
index 00000000..194054dc
--- /dev/null
+++ b/include/boost/histogram/storage/operators.hpp
@@ -0,0 +1,35 @@
+// Copyright 2015-2016 Hans Dembinski
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef _BOOST_HISTOGRAM_STORAGE_OPERATORS_HPP_
+#define _BOOST_HISTOGRAM_STORAGE_OPERATORS_HPP_
+
+#include <boost/histogram/detail/meta.hpp>
+
+namespace boost {
+namespace histogram {
+
+template <typename S1, typename S2, typename = detail::is_storage<S1>,
+          typename = detail::is_storage<S2>>
+bool operator==(const S1 &s1, const S2 &s2) noexcept {
+  if (s1.size() != s2.size())
+    return false;
+  for (decltype(s1.size()) i = 0, n = s1.size(); i < n; ++i)
+    if (s1.value(i) != s2.value(i) || s1.variance(i) != s2.variance(i))
+      return false;
+  return true;
+}
+
+template <typename S1, typename S2, typename = detail::is_storage<S1>,
+          typename = detail::is_storage<S2>>
+bool operator!=(const S1 &s1, const S2 &s2) noexcept {
+  return !operator==(s1, s2);
+}
+
+} // namespace histogram
+} // namespace boost
+
+#endif
diff --git a/test/adaptive_storage_test.cpp b/test/adaptive_storage_test.cpp
index f6c1c29b..31619328 100644
--- a/test/adaptive_storage_test.cpp
+++ b/test/adaptive_storage_test.cpp
@@ -9,7 +9,7 @@
 #include <boost/core/lightweight_test.hpp>
 #include <boost/histogram/serialization.hpp>
 #include <boost/histogram/storage/adaptive_storage.hpp>
-#include <boost/histogram/storage/container_storage.hpp>
+#include <boost/histogram/storage/array_storage.hpp>
 #include <limits>
 #include <sstream>
 
@@ -131,7 +131,7 @@ template <typename T> void equal_impl() {
   b.increase(0);
   BOOST_TEST(!(a == b));
 
-  container_storage<std::vector<unsigned>> c(1);
+  array_storage<unsigned> c(1);
   auto d = python::access::set_value(1, T(0));
   BOOST_TEST(c == d);
   c.increase(0);
@@ -142,7 +142,7 @@ template <> void equal_impl<void>() {
   adaptive_storage<> a(1);
   auto b = python::access::set_value(1, uint8_t(0));
   auto c = python::access::set_value(2, uint8_t(0));
-  auto d = container_storage<std::vector<unsigned>>(1);
+  auto d = array_storage<unsigned>(1);
   BOOST_TEST_EQ(a.value(0), 0.0);
   BOOST_TEST_EQ(a.variance(0), 0.0);
   BOOST_TEST(a == b);
@@ -188,9 +188,9 @@ template <> void increase_and_grow_impl<void>() {
   BOOST_TEST_EQ(s.value(1), 0.0);
 }
 
-template <typename T> void convert_container_storage_impl() {
+template <typename T> void convert_array_storage_impl() {
   const auto aref = python::access::set_value(1, T(0));
-  container_storage<std::vector<uint8_t>> s(1);
+  array_storage<uint8_t> s(1);
   s.increase(0);
 
   auto a = aref;
@@ -212,7 +212,7 @@ template <typename T> void convert_container_storage_impl() {
   BOOST_TEST(c == s);
   BOOST_TEST(s == c);
 
-  container_storage<std::vector<float>> t(1);
+  array_storage<float> t(1);
   t.increase(0);
   while (t.value(0) < 1e20)
     t.increase(0, t.value(0));
@@ -239,7 +239,7 @@ template <typename T> void convert_container_storage_impl() {
   BOOST_TEST(g == s);
   BOOST_TEST(s == g);
 
-  container_storage<std::vector<uint8_t>> u(2);
+  array_storage<uint8_t> u(2);
   u.increase(0);
   auto h = aref;
   BOOST_TEST(!(h == u));
@@ -247,10 +247,10 @@ template <typename T> void convert_container_storage_impl() {
   BOOST_TEST(h == u);
 }
 
-template <> void convert_container_storage_impl<void>() {
+template <> void convert_array_storage_impl<void>() {
   const auto aref = adaptive_storage<>(1);
   BOOST_TEST_EQ(aref.value(0), 0.0);
-  container_storage<std::vector<uint8_t>> s(1);
+  array_storage<uint8_t> s(1);
   s.increase(0);
 
   auto a = aref;
@@ -266,7 +266,7 @@ template <> void convert_container_storage_impl<void>() {
   BOOST_TEST(c == s);
   BOOST_TEST(s == c);
 
-  container_storage<std::vector<uint8_t>> t(2);
+  array_storage<uint8_t> t(2);
   t.increase(0);
   auto d = aref;
   BOOST_TEST(!(d == t));
@@ -351,15 +351,15 @@ int main() {
     }
   }
 
-  // convert_container_storage
+  // convert_array_storage
   {
-    convert_container_storage_impl<void>();
-    convert_container_storage_impl<uint8_t>();
-    convert_container_storage_impl<uint16_t>();
-    convert_container_storage_impl<uint32_t>();
-    convert_container_storage_impl<uint64_t>();
-    convert_container_storage_impl<detail::mp_int>();
-    convert_container_storage_impl<detail::weight>();
+    convert_array_storage_impl<void>();
+    convert_array_storage_impl<uint8_t>();
+    convert_array_storage_impl<uint16_t>();
+    convert_array_storage_impl<uint32_t>();
+    convert_array_storage_impl<uint64_t>();
+    convert_array_storage_impl<detail::mp_int>();
+    convert_array_storage_impl<detail::weight>();
   }
 
   // serialization_test
diff --git a/test/container_storage_test.cpp b/test/array_storage_test.cpp
similarity index 59%
rename from test/container_storage_test.cpp
rename to test/array_storage_test.cpp
index fb03bdc9..00aa46f1 100644
--- a/test/container_storage_test.cpp
+++ b/test/array_storage_test.cpp
@@ -10,7 +10,8 @@
 #include <boost/histogram/detail/meta.hpp>
 #include <boost/histogram/detail/utility.hpp>
 #include <boost/histogram/storage/adaptive_storage.hpp>
-#include <boost/histogram/storage/container_storage.hpp>
+#include <boost/histogram/storage/array_storage.hpp>
+#include <boost/histogram/storage/operators.hpp>
 #include <deque>
 #include <limits>
 #include <vector>
@@ -20,24 +21,15 @@ int main() {
 
   // ctor
   {
-    container_storage<std::vector<unsigned>> a(1);
+    array_storage<unsigned> a(1);
     BOOST_TEST_EQ(a.size(), 1u);
     BOOST_TEST_EQ(a.value(0), 0u);
-    container_storage<std::deque<unsigned>> b(1);
-    BOOST_TEST_EQ(b.size(), 1u);
-    BOOST_TEST_EQ(b.value(0), 0u);
-    container_storage<std::array<unsigned, 1>> c(1);
-    BOOST_TEST_EQ(c.size(), 1u);
-    BOOST_TEST_EQ(c.value(0), 0u);
-    container_storage<boost::array<unsigned, 1>> d(1);
-    BOOST_TEST_EQ(d.size(), 1u);
-    BOOST_TEST_EQ(d.value(0), 0u);
   }
 
   // increase
   {
-    container_storage<std::vector<unsigned>> a(1), b(1);
-    container_storage<std::vector<unsigned char>> c(1), d(2);
+    array_storage<unsigned> a(1), b(1);
+    array_storage<unsigned char> c(1), d(2);
     a.increase(0);
     b.increase(0);
     c.increase(0);
@@ -53,19 +45,11 @@ int main() {
     BOOST_TEST(a == b);
     BOOST_TEST(!(a == c));
     BOOST_TEST(!(a == d));
-
-    container_storage<std::array<unsigned, 2>> e;
-    e.increase(0);
-    for (int i = 0; i < 5; ++i)
-      e.increase(1);
-    BOOST_TEST(d == e);
-    e.increase(1);
-    BOOST_TEST(!(d == e));
   }
 
   // copy
   {
-    container_storage<std::vector<unsigned>> a(1);
+    array_storage<unsigned> a(1);
     a.increase(0);
     decltype(a) b(2);
     BOOST_TEST(!(a == b));
@@ -79,31 +63,17 @@ int main() {
     BOOST_TEST_EQ(c.size(), 1u);
     BOOST_TEST_EQ(c.value(0), 1u);
 
-    container_storage<std::vector<unsigned char>> d(1);
+    array_storage<unsigned char> d(1);
     BOOST_TEST(!(a == d));
     d = a;
     BOOST_TEST(a == d);
     decltype(d) e(a);
     BOOST_TEST(a == e);
-
-    container_storage<std::array<unsigned, 1>> f;
-    BOOST_TEST(!(a == f));
-    f = a;
-    BOOST_TEST(f == a);
-    decltype(f) g(a);
-    BOOST_TEST(g == a);
-
-    container_storage<std::array<unsigned char, 1>> h;
-    BOOST_TEST(!(h == f));
-    h = f;
-    BOOST_TEST(h == f);
-    decltype(h) i(f);
-    BOOST_TEST(i == f);
   }
 
   // move
   {
-    container_storage<std::vector<unsigned>> a(1);
+    array_storage<unsigned> a(1);
     a.increase(0);
     decltype(a) b;
     BOOST_TEST(!(a == b));
diff --git a/test/histogram_test.cpp b/test/histogram_test.cpp
index a5abf9be..1dccde15 100644
--- a/test/histogram_test.cpp
+++ b/test/histogram_test.cpp
@@ -13,7 +13,7 @@
 #include <boost/histogram/literals.hpp>
 #include <boost/histogram/serialization.hpp>
 #include <boost/histogram/storage/adaptive_storage.hpp>
-#include <boost/histogram/storage/container_storage.hpp>
+#include <boost/histogram/storage/array_storage.hpp>
 #include <boost/histogram/utility.hpp>
 #include <limits>
 #include <sstream>
@@ -44,7 +44,7 @@ template <typename Type> void run_tests() {
     BOOST_TEST_EQ(h.dim(), 1);
     BOOST_TEST_EQ(h.size(), 0);
     auto h2 = histogram<Static, mpl::vector<axis::integer>,
-                        container_storage<std::vector<unsigned>>>();
+                        array_storage<unsigned>>();
     BOOST_TEST(h2 == h);
     auto h3 =
         histogram<Static, mpl::vector<axis::regular<>>, adaptive_storage<>>();
@@ -59,7 +59,7 @@ template <typename Type> void run_tests() {
     BOOST_TEST_EQ(h.size(), 5);
     BOOST_TEST_EQ(shape(h.axis(0_c)), 5);
     BOOST_TEST_EQ(shape(h.axis()), 5);
-    auto h2 = make_histogram<container_storage<std::vector<unsigned>>>(
+    auto h2 = make_histogram<array_storage<unsigned>>(
         Type(), axis::regular<>{3, -1, 1});
     BOOST_TEST(h2 == h);
   }
@@ -72,7 +72,7 @@ template <typename Type> void run_tests() {
     BOOST_TEST_EQ(h.size(), 25);
     BOOST_TEST_EQ(shape(h.axis(0_c)), 5);
     BOOST_TEST_EQ(shape(h.axis(1_c)), 5);
-    auto h2 = make_histogram<container_storage<std::vector<unsigned>>>(
+    auto h2 = make_histogram<array_storage<unsigned>>(
         Type(), axis::regular<>{3, -1, 1}, axis::integer{-1, 1});
     BOOST_TEST(h2 == h);
   }
@@ -84,7 +84,7 @@ template <typename Type> void run_tests() {
         axis::circular<>{3});
     BOOST_TEST_EQ(h.dim(), 3);
     BOOST_TEST_EQ(h.size(), 75);
-    auto h2 = make_histogram<container_storage<std::vector<unsigned>>>(
+    auto h2 = make_histogram<array_storage<unsigned>>(
         Type(), axis::regular<>{3, -1, 1}, axis::integer{-1, 1},
         axis::circular<>{3});
     BOOST_TEST(h2 == h);
@@ -97,7 +97,7 @@ template <typename Type> void run_tests() {
         axis::circular<>{3}, axis::variable<>{-1, 0, 1});
     BOOST_TEST_EQ(h.dim(), 4);
     BOOST_TEST_EQ(h.size(), 300);
-    auto h2 = make_histogram<container_storage<std::vector<unsigned>>>(
+    auto h2 = make_histogram<array_storage<unsigned>>(
         Type(), axis::regular<>{3, -1, 1}, axis::integer{-1, 1},
         axis::circular<>{3}, axis::variable<>{-1, 0, 1});
     BOOST_TEST(h2 == h);
@@ -111,7 +111,7 @@ template <typename Type> void run_tests() {
         axis::category{"A", "B", "C"});
     BOOST_TEST_EQ(h.dim(), 5);
     BOOST_TEST_EQ(h.size(), 900);
-    auto h2 = make_histogram<container_storage<std::vector<unsigned>>>(
+    auto h2 = make_histogram<array_storage<unsigned>>(
         Type(), axis::regular<>{3, -1, 1}, axis::integer{-1, 1},
         axis::circular<>{3}, axis::variable<>{-1, 0, 1},
         axis::category{"A", "B", "C"});
@@ -126,7 +126,7 @@ template <typename Type> void run_tests() {
     auto h2 = decltype(h)(h);
     BOOST_TEST(h2 == h);
     auto h3 = histogram<Static, mpl::vector<axis::integer, axis::integer>,
-                        container_storage<std::vector<unsigned>>>(h);
+                        array_storage<unsigned>>(h);
     BOOST_TEST(h3 == h);
   }
 
@@ -143,7 +143,7 @@ template <typename Type> void run_tests() {
     h2 = h2;
     BOOST_TEST(h == h2);
     auto h3 = histogram<Static, mpl::vector<axis::integer, axis::integer>,
-                        container_storage<std::vector<unsigned>>>();
+                        array_storage<unsigned>>();
     h3 = h;
     BOOST_TEST(h == h3);
   }
@@ -294,8 +294,8 @@ template <typename Type> void run_tests() {
 
   // d1w2
   {
-    auto h = make_histogram<container_storage<std::vector<float>>>(
-        Type(), axis::regular<>(2, -1, 1));
+    auto h =
+        make_histogram<array_storage<float>>(Type(), axis::regular<>(2, -1, 1));
     h.fill(0);
     h.fill(count(2.0), -1.0);
     h.fill(-1.0);
@@ -427,8 +427,8 @@ template <typename Type> void run_tests() {
   // add_1
   {
     auto a = make_histogram<adaptive_storage<>>(Type(), axis::integer(-1, 1));
-    auto b = make_histogram<container_storage<std::vector<unsigned>>>(
-        Type(), axis::integer(-1, 1));
+    auto b =
+        make_histogram<array_storage<unsigned>>(Type(), axis::integer(-1, 1));
     a.fill(-1);
     b.fill(1);
     auto c = a;
@@ -476,10 +476,9 @@ template <typename Type> void run_tests() {
 
   // add_3
   {
-    auto a = make_histogram<container_storage<std::vector<char>>>(
-        Type(), axis::integer(-1, 1));
-    auto b = make_histogram<container_storage<std::vector<unsigned>>>(
-        Type(), axis::integer(-1, 1));
+    auto a = make_histogram<array_storage<char>>(Type(), axis::integer(-1, 1));
+    auto b =
+        make_histogram<array_storage<unsigned>>(Type(), axis::integer(-1, 1));
     a.fill(-1);
     b.fill(1);
     auto c = a;
diff --git a/test/speed_cpp.cpp b/test/speed_cpp.cpp
index 5250ec32..2c15ff4f 100644
--- a/test/speed_cpp.cpp
+++ b/test/speed_cpp.cpp
@@ -6,7 +6,6 @@
 
 #include <algorithm>
 #include <boost/histogram.hpp>
-#include <boost/histogram/storage/adaptive_storage.hpp>
 #include <cstdio>
 #include <ctime>
 #include <limits>
@@ -110,14 +109,14 @@ int main() {
       printf("normal distribution\n");
     printf("hs_ss %.3f\n",
            compare_1d<histogram<Static,mpl::vector<axis::regular<>>,
-                                       container_storage<std::vector<int>>>>(
+                                array_storage<int>>>(
                6000000, itype));
     printf("hs_sd %.3f\n",
            compare_1d<histogram<Static,mpl::vector<axis::regular<>>,
-                                       adaptive_storage<>>>(6000000, itype));
+                                adaptive_storage<>>>(6000000, itype));
     printf("hd_ss %.3f\n",
            compare_1d<histogram<Dynamic, builtin_axes,
-                                        container_storage<std::vector<int>>>>(
+                                array_storage<int>>>(
                6000000, itype));
     printf("hd_sd %.3f\n",
            compare_1d<histogram<Dynamic, builtin_axes, adaptive_storage<>>>(
@@ -133,14 +132,14 @@ int main() {
     printf("hs_ss %.3f\n",
            compare_2d<histogram<Static,
                mpl::vector<axis::regular<>, axis::regular<>>,
-               container_storage<std::vector<int>>>>(6000000, itype));
+               array_storage<int>>>(6000000, itype));
     printf("hs_sd %.3f\n",
            compare_2d<histogram<Static,
                mpl::vector<axis::regular<>, axis::regular<>>,
                adaptive_storage<>>>(6000000, itype));
     printf("hd_ss %.3f\n",
            compare_2d<histogram<Dynamic, builtin_axes,
-                      container_storage<std::vector<int>>>>(
+                      array_storage<int>>>(
                6000000, itype));
     printf("hd_sd %.3f\n",
            compare_2d<histogram<Dynamic, builtin_axes, adaptive_storage<>>>(
@@ -156,14 +155,14 @@ int main() {
     printf("hs_ss %.3f\n",
            compare_3d<histogram<Static,
                mpl::vector<axis::regular<>, axis::regular<>, axis::regular<>>,
-               container_storage<std::vector<int>>>>(6000000, itype));
+               array_storage<int>>>(6000000, itype));
     printf("hs_sd %.3f\n",
            compare_3d<histogram<Static,
                mpl::vector<axis::regular<>, axis::regular<>, axis::regular<>>,
                adaptive_storage<>>>(6000000, itype));
     printf("hd_ss %.3f\n",
            compare_3d<histogram<Dynamic, builtin_axes,
-                                        container_storage<std::vector<int>>>>(
+                                array_storage<int>>>(
                6000000, itype));
     printf("hd_sd %.3f\n",
            compare_3d<histogram<Dynamic, builtin_axes, adaptive_storage<>>>(
@@ -180,7 +179,7 @@ int main() {
            compare_6d<histogram<Static,
                mpl::vector<axis::regular<>, axis::regular<>, axis::regular<>,
                            axis::regular<>, axis::regular<>, axis::regular<>>,
-               container_storage<std::vector<int>>>>(6000000, itype));
+               array_storage<int>>>(6000000, itype));
     printf("hs_sd %.3f\n",
            compare_6d<histogram<Static,
                mpl::vector<axis::regular<>, axis::regular<>, axis::regular<>,
@@ -188,7 +187,7 @@ int main() {
                adaptive_storage<>>>(6000000, itype));
     printf("hd_ss %.3f\n",
            compare_6d<histogram<Dynamic, builtin_axes,
-                                        container_storage<std::vector<int>>>>(
+                                array_storage<int>>>(
                6000000, itype));
     printf("hd_sd %.3f\n",
            compare_6d<histogram<Dynamic, builtin_axes, adaptive_storage<>>>(