From 493d6c7974e6669cbcc0da9e37b9c2c19ddf4350 Mon Sep 17 00:00:00 2001
From: Hans Dembinski <hans.dembinski@gmail.com>
Date: Tue, 28 Mar 2017 23:21:21 +0200
Subject: [PATCH] unified both histogram classes

---
 include/boost/histogram.hpp                   |   3 +-
 .../histogram/axis_ostream_operators.hpp      |   1 -
 include/boost/histogram/detail/meta.hpp       |  29 +----
 include/boost/histogram/detail/variance.hpp   |   4 +-
 include/boost/histogram/histogram.hpp         |  14 +++
 ...stogram.hpp => histogram_dynamic_impl.hpp} | 111 ++++++++---------
 include/boost/histogram/histogram_fwd.hpp     |  22 ++++
 .../histogram/histogram_ostream_operators.hpp |   9 +-
 ...istogram.hpp => histogram_static_impl.hpp} | 117 ++++++++----------
 include/boost/histogram/serialization.hpp     |  11 +-
 .../histogram/storage/adaptive_storage.hpp    |   6 +-
 .../histogram/storage/container_storage.hpp   |   5 +-
 src/python/histogram.cpp                      |  35 +++---
 test/container_storage_test.cpp               |   5 +-
 test/dynamic_histogram_test.cpp               |  40 +++---
 test/speed_cpp.cpp                            |  63 ++++++++--
 test/speed_gsl.cpp                            |  24 ++++
 test/speed_numpy.py.in                        |  32 +++++
 test/speed_root.cpp                           |  22 ++++
 test/static_histogram_test.cpp                |  29 ++++-
 20 files changed, 356 insertions(+), 226 deletions(-)
 create mode 100644 include/boost/histogram/histogram.hpp
 rename include/boost/histogram/{dynamic_histogram.hpp => histogram_dynamic_impl.hpp} (70%)
 create mode 100644 include/boost/histogram/histogram_fwd.hpp
 rename include/boost/histogram/{static_histogram.hpp => histogram_static_impl.hpp} (58%)

diff --git a/include/boost/histogram.hpp b/include/boost/histogram.hpp
index 61a736a2..79a4fd0c 100644
--- a/include/boost/histogram.hpp
+++ b/include/boost/histogram.hpp
@@ -8,8 +8,7 @@
 #define BOOST_HISTOGRAM_HPP_
 
 #include <boost/histogram/axis.hpp>
-#include <boost/histogram/dynamic_histogram.hpp>
-#include <boost/histogram/static_histogram.hpp>
+#include <boost/histogram/histogram.hpp>
 #include <boost/histogram/storage/adaptive_storage.hpp>
 #include <boost/histogram/storage/container_storage.hpp>
 #include <boost/histogram/utility.hpp>
diff --git a/include/boost/histogram/axis_ostream_operators.hpp b/include/boost/histogram/axis_ostream_operators.hpp
index ee63427f..da9addf8 100644
--- a/include/boost/histogram/axis_ostream_operators.hpp
+++ b/include/boost/histogram/axis_ostream_operators.hpp
@@ -11,7 +11,6 @@
 #include <boost/histogram/detail/utility.hpp>
 #include <boost/math/constants/constants.hpp>
 #include <ostream>
-#include <string>
 
 namespace boost {
 namespace histogram {
diff --git a/include/boost/histogram/detail/meta.hpp b/include/boost/histogram/detail/meta.hpp
index 8c86d580..33892cb3 100644
--- a/include/boost/histogram/detail/meta.hpp
+++ b/include/boost/histogram/detail/meta.hpp
@@ -19,12 +19,11 @@ namespace boost {
 namespace histogram {
 namespace detail {
 
-template <typename T> struct has_weight_support {
+template <typename T> struct has_variance {
   template <typename> static std::false_type test(...);
 
   template <typename C>
-  static decltype(std::declval<C &>().increase(0, 0.0),
-                  std::declval<C &>().variance(0), std::true_type{})
+  static decltype(std::declval<C &>().variance(0), std::true_type{})
   test(int);
 
   static bool const value = decltype(test<T>(0))::value;
@@ -43,11 +42,6 @@ template <typename T, typename = decltype(std::begin(std::declval<T &>()),
                                           std::end(std::declval<T &>()))>
 struct is_sequence {};
 
-struct histogram_tag {};
-
-template <typename T, typename = typename T::histogram_tag>
-struct is_histogram {};
-
 template <typename S1, typename S2> struct intersection {
   using type = typename std::conditional<
       mpl::equal<S1, S2>::value, S1,
@@ -55,25 +49,6 @@ template <typename S1, typename S2> struct intersection {
       type;
 };
 
-// // prefer dynamic over static storage, choose
-// // static_storage with larger capacity
-// template <typename Storage1,
-//           typename Storage2>
-// struct select_storage {
-//     using type = typename std::conditional<
-//         (is_dynamic_storage<Storage1>::value ||
-//          is_dynamic_storage<Storage2>::value),
-//         typename std::conditional<
-//             is_dynamic_storage<Storage1>::value,
-//             Storage1, Storage2
-//         >::type,
-//         typename std::conditional<
-//             (std::numeric_limits<typename Storage1::value_t>::max() >
-//              std::numeric_limits<typename Storage2::value_t>::max()),
-//             Storage1, Storage2
-//         >::type
-//     >::type;
-// };
 } // namespace detail
 } // namespace histogram
 } // namespace boost
diff --git a/include/boost/histogram/detail/variance.hpp b/include/boost/histogram/detail/variance.hpp
index f123a52b..8476f382 100644
--- a/include/boost/histogram/detail/variance.hpp
+++ b/include/boost/histogram/detail/variance.hpp
@@ -15,14 +15,14 @@ namespace detail {
 
 namespace {
 template <typename Storage>
-typename std::enable_if<has_weight_support<Storage>::value,
+typename std::enable_if<has_variance<Storage>::value,
                         typename Storage::value_type>::type
 variance_impl(const Storage &s, std::size_t i) {
   return s.variance(i);
 } // delegate to Storage implementation
 
 template <typename Storage>
-typename std::enable_if<!(has_weight_support<Storage>::value),
+typename std::enable_if<!(has_variance<Storage>::value),
                         typename Storage::value_type>::type
 variance_impl(const Storage &s, std::size_t i) {
   return s.value(i);
diff --git a/include/boost/histogram/histogram.hpp b/include/boost/histogram/histogram.hpp
new file mode 100644
index 00000000..7c73269f
--- /dev/null
+++ b/include/boost/histogram/histogram.hpp
@@ -0,0 +1,14 @@
+// Copyright 2015-2017 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_HISTOGRAM_HPP_
+#define _BOOST_HISTOGRAM_HISTOGRAM_HPP_
+
+#include <boost/histogram/histogram_fwd.hpp>
+#include <boost/histogram/histogram_static_impl.hpp>
+#include <boost/histogram/histogram_dynamic_impl.hpp>
+
+#endif
diff --git a/include/boost/histogram/dynamic_histogram.hpp b/include/boost/histogram/histogram_dynamic_impl.hpp
similarity index 70%
rename from include/boost/histogram/dynamic_histogram.hpp
rename to include/boost/histogram/histogram_dynamic_impl.hpp
index d5952f8f..7605b7c6 100644
--- a/include/boost/histogram/dynamic_histogram.hpp
+++ b/include/boost/histogram/histogram_dynamic_impl.hpp
@@ -4,18 +4,17 @@
 // (See accompanying file LICENSE_1_0.txt
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef _BOOST_HISTOGRAM_DYNAMIC_HISTOGRAM_HPP_
-#define _BOOST_HISTOGRAM_DYNAMIC_HISTOGRAM_HPP_
+#ifndef _BOOST_HISTOGRAM_HISTOGRAM_DYNAMIC_IMPL_HPP_
+#define _BOOST_HISTOGRAM_HISTOGRAM_DYNAMIC_IMPL_HPP_
 
 #include <algorithm>
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
+#include <boost/histogram/histogram_fwd.hpp>
 #include <boost/histogram/axis.hpp>
 #include <boost/histogram/detail/axis_visitor.hpp>
 #include <boost/histogram/detail/meta.hpp>
 #include <boost/histogram/detail/utility.hpp>
-#include <boost/histogram/detail/variance.hpp>
-#include <boost/histogram/storage/adaptive_storage.hpp>
 #include <boost/mpl/empty.hpp>
 #include <boost/mpl/vector.hpp>
 #include <boost/variant.hpp>
@@ -28,12 +27,11 @@
 namespace boost {
 namespace histogram {
 
-template <typename Axes = default_axes, typename Storage = adaptive_storage<>>
-class dynamic_histogram {
+template <typename Axes, typename Storage>
+class histogram<true, Axes, Storage> {
   static_assert(!mpl::empty<Axes>::value, "at least one axis required");
-  using pairs = std::pair<std::size_t, std::size_t>;
+  using size_pair = std::pair<std::size_t, std::size_t>;
 public:
-  using histogram_tag = detail::histogram_tag;
   using axis_type = typename make_variant_over<Axes>::type;
   using value_type = typename Storage::value_type;
 
@@ -41,34 +39,34 @@ private:
   using axes_type = std::vector<axis_type>;
 
 public:
-  dynamic_histogram() = default;
+  histogram() = default;
 
   template <typename... Axes1>
-  explicit dynamic_histogram(const Axes1 &... axes)
+  explicit histogram(const Axes1 &... axes)
       : axes_({axis_type(axes)...}) {
     storage_ = Storage(field_count());
   }
 
   template <typename Iterator, typename = detail::is_iterator<Iterator>>
-  dynamic_histogram(Iterator axes_begin, Iterator axes_end)
+  histogram(Iterator axes_begin, Iterator axes_end)
       : axes_(std::distance(axes_begin, axes_end)) {
     std::copy(axes_begin, axes_end, axes_.begin());
     storage_ = Storage(field_count());
   }
 
   template <typename OtherAxes, typename OtherStorage>
-  explicit dynamic_histogram(
-      const dynamic_histogram<OtherAxes, OtherStorage> &other)
+  explicit histogram(
+      const histogram<true, OtherAxes, OtherStorage> &other)
       : axes_(other.axes_.begin(), other.axes_.end()),
         storage_(other.storage_) {}
 
   template <typename OtherAxes, typename OtherStorage>
-  explicit dynamic_histogram(dynamic_histogram<OtherAxes, OtherStorage> &&other)
+  explicit histogram(histogram<true, OtherAxes, OtherStorage> &&other)
       : axes_(std::move(other.axes_)), storage_(std::move(other.storage_)) {}
 
   template <typename OtherAxes, typename OtherStorage>
-  dynamic_histogram &
-  operator=(const dynamic_histogram<OtherAxes, OtherStorage> &other) {
+  histogram &
+  operator=(const histogram<true, OtherAxes, OtherStorage> &other) {
     if (static_cast<const void *>(this) != static_cast<const void *>(&other)) {
       axes_ = other.axes_;
       storage_ = other.storage_;
@@ -77,8 +75,8 @@ public:
   }
 
   template <typename OtherAxes, typename OtherStorage>
-  dynamic_histogram &
-  operator=(dynamic_histogram<OtherAxes, OtherStorage> &&other) {
+  histogram &
+  operator=(histogram<true, OtherAxes, OtherStorage> &&other) {
     if (static_cast<const void *>(this) != static_cast<const void *>(&other)) {
       axes_ = std::move(other.axes_);
       storage_ = std::move(other.storage_);
@@ -88,7 +86,7 @@ public:
 
   template <typename OtherAxes, typename OtherStorage>
   bool
-  operator==(const dynamic_histogram<OtherAxes, OtherStorage> &other) const {
+  operator==(const histogram<true, OtherAxes, OtherStorage> &other) const {
     if (mpl::empty<
             typename detail::intersection<Axes, OtherAxes>::type>::value) {
       return false;
@@ -105,13 +103,12 @@ public:
     return true;
   }
 
-  template <template <class, class> class Histogram, typename OtherAxes,
-            typename OtherStorage>
-  dynamic_histogram &
-  operator+=(const Histogram<OtherAxes, OtherStorage> &other) {
+  template <bool D, typename A, typename S>
+  histogram &
+  operator+=(const histogram<D, A, S> &other) {
     static_assert(
         !mpl::empty<
-            typename detail::intersection<Axes, OtherAxes>::type>::value,
+            typename detail::intersection<Axes, A>::type>::value,
         "histograms lack common axes types");
     if (dim() != other.dim()) {
       throw std::logic_error("dimensions of histograms differ");
@@ -129,7 +126,7 @@ public:
   template <typename... Values> void fill(Values... values) {
     BOOST_ASSERT_MSG(sizeof...(values) == dim(),
                      "number of arguments does not match histogram dimension");
-    const auto p = apply_lin<detail::xlin, Values...>(pairs(0, 1), values...);
+    const auto p = apply_lin<detail::xlin, Values...>(size_pair(0, 1), values...);
     if (p.second) {
       storage_.increase(p.first);
     }
@@ -139,33 +136,27 @@ public:
   void fill(Iterator begin, Iterator end) {
     BOOST_ASSERT_MSG(std::distance(begin, end) == dim(),
                      "number of arguments does not match histogram dimension");
-    const auto p = apply_lin_iter<detail::xlin>(pairs(0, 1), begin);
+    const auto p = apply_lin_iter<detail::xlin>(size_pair(0, 1), begin);
     if (p.second) {
       storage_.increase(p.first);
     }
   }
 
-  template <
-      bool has_weight_support = detail::has_weight_support<Storage>::value,
-      typename... Values>
-  typename std::enable_if<has_weight_support>::type wfill(value_type w,
-                                                          Values... values) {
+  template <typename... Values>
+  void wfill(value_type w, Values... values) {
     BOOST_ASSERT_MSG(sizeof...(values) == dim(),
                      "number of arguments does not match histogram dimension");
-    const auto p = apply_lin<detail::xlin, Values...>(pairs(0, 1), values...);
+    const auto p = apply_lin<detail::xlin, Values...>(size_pair(0, 1), values...);
     if (p.second) {
       storage_.increase(p.first, w);
     }
   }
 
-  template <
-      bool has_weight_support = detail::has_weight_support<Storage>::value,
-      typename Iterator, typename = detail::is_iterator<Iterator>>
-  typename std::enable_if<has_weight_support>::type
-  wfill(value_type w, Iterator begin, Iterator end) {
+  template <typename Iterator, typename = detail::is_iterator<Iterator>>
+  void wfill(value_type w, Iterator begin, Iterator end) {
     BOOST_ASSERT_MSG(std::distance(begin, end) == dim(),
                      "number of arguments does not match histogram dimension");
-    const auto p = apply_lin_iter<detail::xlin>(pairs(0, 1), begin);
+    const auto p = apply_lin_iter<detail::xlin>(size_pair(0, 1), begin);
     if (p.second) {
       storage_.increase(p.first, w);
     }
@@ -174,7 +165,7 @@ public:
   template <typename... Indices> value_type value(Indices... indices) const {
     BOOST_ASSERT_MSG(sizeof...(indices) == dim(),
                      "number of arguments does not match histogram dimension");
-    const auto p = apply_lin<detail::lin, Indices...>(pairs(0, 1), indices...);
+    const auto p = apply_lin<detail::lin, Indices...>(size_pair(0, 1), indices...);
     if (p.second == 0) {
       throw std::out_of_range("invalid index");
     }
@@ -185,7 +176,7 @@ public:
   value_type value(Iterator begin, Iterator end) const {
     BOOST_ASSERT_MSG(std::distance(begin, end) == dim(),
                      "number of arguments does not match histogram dimension");
-    const auto p = apply_lin_iter<detail::lin>(pairs(0, 1), begin);
+    const auto p = apply_lin_iter<detail::lin>(size_pair(0, 1), begin);
     if (p.second == 0) {
       throw std::out_of_range("invalid index");
     }
@@ -193,24 +184,26 @@ public:
   }
 
   template <typename... Indices> value_type variance(Indices... indices) const {
+    static_assert(detail::has_variance<Storage>::value, "Storage lacks variance support");
     BOOST_ASSERT_MSG(sizeof...(indices) == dim(),
                      "number of arguments does not match histogram dimension");
-    const auto p = apply_lin<detail::lin, Indices...>(pairs(0, 1), indices...);
+    const auto p = apply_lin<detail::lin, Indices...>(size_pair(0, 1), indices...);
     if (p.second == 0) {
       throw std::out_of_range("invalid index");
     }
-    return detail::variance(storage_, p.first);
+    return storage_.variance(p.first);
   }
 
   template <typename Iterator, typename = detail::is_iterator<Iterator>>
   value_type variance(Iterator begin, Iterator end) const {
+    static_assert(detail::has_variance<Storage>::value, "Storage lacks variance support");
     BOOST_ASSERT_MSG(std::distance(begin, end) == dim(),
                      "number of arguments does not match histogram dimension");
-    const auto p = apply_lin_iter<detail::lin>(pairs(0, 1), begin);
+    const auto p = apply_lin_iter<detail::lin>(size_pair(0, 1), begin);
     if (p.second == 0) {
       throw std::out_of_range("invalid index");
     }
-    return detail::variance(storage_, p.first);
+    return storage_.variance(p.first);
   }
 
   /// Number of axes (dimensions) of histogram
@@ -271,19 +264,19 @@ private:
   }
 
   template <template <class, class> class Lin, typename Value>
-  struct lin_visitor : public static_visitor<pairs> {
-    mutable pairs pa;
+  struct lin_visitor : public static_visitor<size_pair> {
+    mutable size_pair pa;
     const Value &val;
-    lin_visitor(const pairs& p, const Value &v)
+    lin_visitor(const size_pair& p, const Value &v)
         : pa(p), val(v) {}
-    template <typename A> pairs operator()(const A &a) const {
+    template <typename A> size_pair operator()(const A &a) const {
       Lin<A, Value>::apply(pa.first, pa.second, a, val);
       return pa;
     }
   };
 
   template <template <class, class> class Lin, typename First, typename... Rest>
-  pairs apply_lin(pairs&& p, const First &first,
+  size_pair apply_lin(size_pair&& p, const First &first,
                  const Rest &... rest) const {
     p = apply_visitor(lin_visitor<Lin, First>(p, first),
                       axes_[dim() - 1 - sizeof...(Rest)]);
@@ -291,10 +284,10 @@ private:
   }
 
   template <template <class, class> class Lin>
-  pairs apply_lin(pairs&& p) const { return p; }
+  size_pair apply_lin(size_pair&& p) const { return p; }
 
   template <template <class, class> class Lin, typename Iterator>
-  pairs apply_lin_iter(pairs&& p, Iterator iter) const {
+  size_pair apply_lin_iter(size_pair&& p, Iterator iter) const {
     for (const auto &a : axes_) {
       p = apply_visitor(lin_visitor<Lin, decltype(*iter)>(p, *iter), a);
       ++iter;
@@ -304,23 +297,23 @@ private:
 
   friend struct storage_access;
 
-  template <typename OtherAxes, typename OtherStorage>
-  friend class dynamic_histogram;
+  template <bool D, typename A, typename S>
+  friend class histogram;
 
-  template <typename Archiv, typename OtherAxes, typename OtherStorage>
-  friend void serialize(Archiv &, dynamic_histogram<OtherAxes, OtherStorage> &,
+  template <typename Archiv, typename A, typename S>
+  friend void serialize(Archiv &, histogram<true, A, S> &,
                         unsigned);
 };
 
 template <typename... Axes>
-inline dynamic_histogram<> make_dynamic_histogram(Axes &&... axes) {
-  return dynamic_histogram<>(std::forward<Axes>(axes)...);
+inline histogram<true, default_axes> make_dynamic_histogram(Axes &&... axes) {
+  return histogram<true, default_axes>(std::forward<Axes>(axes)...);
 }
 
 template <typename Storage, typename... Axes>
-inline dynamic_histogram<default_axes, Storage>
+inline histogram<true, default_axes, Storage>
 make_dynamic_histogram_with(Axes &&... axes) {
-  return dynamic_histogram<default_axes, Storage>(std::forward<Axes>(axes)...);
+  return histogram<true, default_axes, Storage>(std::forward<Axes>(axes)...);
 }
 } // namespace histogram
 } // namespace boost
diff --git a/include/boost/histogram/histogram_fwd.hpp b/include/boost/histogram/histogram_fwd.hpp
new file mode 100644
index 00000000..c7f3a058
--- /dev/null
+++ b/include/boost/histogram/histogram_fwd.hpp
@@ -0,0 +1,22 @@
+// Copyright 2015-2017 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_HISTOGRAM_FWD_HPP_
+#define _BOOST_HISTOGRAM_HISTOGRAM_FWD_HPP_
+
+#include <boost/histogram/storage/adaptive_storage.hpp>
+
+namespace boost {
+namespace histogram { 
+
+template <bool Dynamic,
+          class Axes,
+          class Storage = adaptive_storage<> > class histogram;
+
+} // namespace histogram
+} // namespace boost
+
+#endif
diff --git a/include/boost/histogram/histogram_ostream_operators.hpp b/include/boost/histogram/histogram_ostream_operators.hpp
index 4f618d62..9bf164ac 100644
--- a/include/boost/histogram/histogram_ostream_operators.hpp
+++ b/include/boost/histogram/histogram_ostream_operators.hpp
@@ -8,8 +8,7 @@
 #define _BOOST_HISTOGRAM_HISTOGRAM_OSTREAM_OPERATORS_HPP_
 
 #include <boost/histogram/axis_ostream_operators.hpp>
-#include <boost/histogram/detail/meta.hpp>
-#include <boost/histogram/utility.hpp>
+#include <boost/histogram/histogram_fwd.hpp>
 #include <ostream>
 
 namespace boost {
@@ -25,11 +24,9 @@ struct axis_ostream_visitor {
 };
 } // namespace detail
 
-template <template <typename, typename> class Histogram, typename Axes,
-          typename Storage,
-          typename = detail::is_histogram<Histogram<Axes, Storage>>>
+template <bool D, typename A, typename S>
 inline std::ostream &operator<<(std::ostream &os,
-                                const Histogram<Axes, Storage> &h) {
+                                const histogram<D, A, S> &h) {
   os << "histogram(";
   detail::axis_ostream_visitor sh(os);
   h.for_each_axis(sh);
diff --git a/include/boost/histogram/static_histogram.hpp b/include/boost/histogram/histogram_static_impl.hpp
similarity index 58%
rename from include/boost/histogram/static_histogram.hpp
rename to include/boost/histogram/histogram_static_impl.hpp
index d91786d1..c8a25423 100644
--- a/include/boost/histogram/static_histogram.hpp
+++ b/include/boost/histogram/histogram_static_impl.hpp
@@ -1,11 +1,11 @@
-// Copyright 2015-2016 Hans Dembinski
+// Copyright 2015-2017 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_STATIC_HISTOGRAM_HPP_
-#define _BOOST_HISTOGRAM_STATIC_HISTOGRAM_HPP_
+#ifndef _BOOST_HISTOGRAM_HISTOGRAM_STATIC_IMPL_HPP_
+#define _BOOST_HISTOGRAM_HISTOGRAM_STATIC_IMPL_HPP_
 
 #include <boost/config.hpp>
 #include <boost/fusion/adapted/mpl.hpp>
@@ -18,11 +18,11 @@
 #include <boost/fusion/include/sequence.hpp>
 #include <boost/fusion/sequence.hpp>
 #include <boost/fusion/sequence/comparison.hpp>
+#include <boost/histogram/histogram_fwd.hpp>
 #include <boost/histogram/axis.hpp>
 #include <boost/histogram/detail/axis_visitor.hpp>
 #include <boost/histogram/detail/meta.hpp>
 #include <boost/histogram/detail/utility.hpp>
-#include <boost/histogram/detail/variance.hpp>
 #include <boost/histogram/storage/adaptive_storage.hpp>
 #include <boost/mpl/empty.hpp>
 #include <boost/mpl/vector.hpp>
@@ -31,42 +31,41 @@
 namespace boost {
 namespace histogram {
 
-template <typename Axes, typename Storage = adaptive_storage<>>
-class static_histogram {
+template <typename Axes, typename Storage>
+class histogram<false, Axes, Storage> {
   static_assert(!mpl::empty<Axes>::value, "at least one axis required");
-  using pairs = std::pair<std::size_t, std::size_t>;
-
+  using size_pair = std::pair<std::size_t, std::size_t>;
+  using axes_size = typename fusion::result_of::size<Axes>::type;
 public:
-  using histogram_tag = detail::histogram_tag;
   using value_type = typename Storage::value_type;
 
 private:
   using axes_type = typename fusion::result_of::as_vector<Axes>::type;
 
 public:
-  static_histogram() = default;
+  histogram() = default;
 
   template <typename... Axes1>
-  explicit static_histogram(const Axes1 &... axes) : axes_(axes...) {
+  explicit histogram(const Axes1 &... axes) : axes_(axes...) {
     storage_ = Storage(field_count());
   }
 
-  static_histogram(const static_histogram &other) = default;
-  static_histogram(static_histogram &&other) = default;
-  static_histogram &operator=(const static_histogram &other) = default;
-  static_histogram &operator=(static_histogram &&other) = default;
+  histogram(const histogram &other) = default;
+  histogram(histogram &&other) = default;
+  histogram &operator=(const histogram &other) = default;
+  histogram &operator=(histogram &&other) = default;
 
-  template <typename OtherStorage>
-  explicit static_histogram(const static_histogram<Axes, OtherStorage> &other)
+  template <typename S>
+  explicit histogram(const histogram<false, Axes, S> &other)
       : axes_(other.axes_), storage_(other.storage_) {}
 
-  template <typename OtherStorage>
-  explicit static_histogram(static_histogram<Axes, OtherStorage> &&other)
+  template <typename S>
+  explicit histogram(histogram<false, Axes, S> &&other)
       : axes_(std::move(other.axes_)), storage_(std::move(other.storage_)) {}
 
-  template <typename OtherStorage>
-  static_histogram &
-  operator=(const static_histogram<Axes, OtherStorage> &other) {
+  template <typename S>
+  histogram &
+  operator=(const histogram<false, Axes, S> &other) {
     if (static_cast<const void *>(this) != static_cast<const void *>(&other)) {
       axes_ = other.axes_;
       storage_ = other.storage_;
@@ -74,8 +73,8 @@ public:
     return *this;
   }
 
-  template <typename OtherStorage>
-  static_histogram &operator=(static_histogram<Axes, OtherStorage> &&other) {
+  template <typename S>
+  histogram &operator=(histogram<false, Axes, S> &&other) {
     if (static_cast<const void *>(this) != static_cast<const void *>(&other)) {
       axes_ = std::move(other.axes_);
       storage_ = std::move(other.storage_);
@@ -83,18 +82,18 @@ public:
     return *this;
   }
 
-  template <typename OtherAxes, typename OtherStorage>
+  template <typename A, typename S>
   bool
-  operator==(const static_histogram<OtherAxes, OtherStorage> &other) const {
+  operator==(const histogram<false, A, S> &other) const {
     if (!axes_equal_to(other.axes_)) {
       return false;
     }
     return storage_ == other.storage_;
   }
 
-  template <typename OtherStorage>
-  static_histogram &
-  operator+=(const static_histogram<Axes, OtherStorage> &other) {
+  template <typename S>
+  histogram &
+  operator+=(const histogram<false, Axes, S> &other) {
     if (!axes_equal_to(other.axes_)) {
       throw std::logic_error("axes of histograms differ");
     }
@@ -103,31 +102,27 @@ public:
   }
 
   template <typename... Values> void fill(Values... values) {
-    static_assert(sizeof...(values) == dim(),
+    static_assert(sizeof...(values) == axes_size::value,
                   "number of arguments does not match histogram dimension");
-    const auto p = apply_lin<detail::xlin, Values...>(pairs(0, 1), values...);
+    const auto p = apply_lin<detail::xlin, Values...>(size_pair(0, 1), values...);
     if (p.second) {
       storage_.increase(p.first);
     }
   }
 
-  template <
-      bool has_weight_support = detail::has_weight_support<Storage>::value,
-      typename... Values>
-  typename std::enable_if<has_weight_support>::type wfill(value_type w,
-                                                          Values... values) {
-    static_assert(sizeof...(values) == dim(),
+  template <typename... Values> void wfill(value_type w, Values... values) {
+    static_assert(sizeof...(values) == axes_size::value,
                   "number of arguments does not match histogram dimension");
-    const auto p = apply_lin<detail::xlin, Values...>(pairs(0, 1), values...);
+    const auto p = apply_lin<detail::xlin, Values...>(size_pair(0, 1), values...);
     if (p.second) {
       storage_.increase(p.first, w);
     }
   }
 
   template <typename... Indices> value_type value(Indices... indices) const {
-    static_assert(sizeof...(indices) == dim(),
+    static_assert(sizeof...(indices) == axes_size::value,
                   "number of arguments does not match histogram dimension");
-    const auto p = apply_lin<detail::lin, Indices...>(pairs(0, 1), indices...);
+    const auto p = apply_lin<detail::lin, Indices...>(size_pair(0, 1), indices...);
     if (p.second == 0) {
       throw std::out_of_range("invalid index");
     }
@@ -135,19 +130,18 @@ public:
   }
 
   template <typename... Indices> value_type variance(Indices... indices) const {
-    static_assert(sizeof...(indices) == dim(),
+    static_assert(detail::has_variance<Storage>::value, "Storage lacks variance support");
+    static_assert(sizeof...(indices) == axes_size::value,
                   "number of arguments does not match histogram dimension");
-    const auto p = apply_lin<detail::lin, Indices...>(pairs(0, 1), indices...);
+    const auto p = apply_lin<detail::lin, Indices...>(size_pair(0, 1), indices...);
     if (p.second == 0) {
       throw std::out_of_range("invalid index");
     }
-    return detail::variance(storage_, p.first);
+    return storage_.variance(p.first);
   }
 
   /// Number of axes (dimensions) of histogram
-  static constexpr unsigned dim() {
-    return fusion::result_of::size<Axes>::type::value;
-  }
+  constexpr unsigned dim() const { return axes_size::value; }
 
   /// Total number of bins in the histogram (including underflow/overflow)
   std::size_t size() const { return storage_.size(); }
@@ -165,8 +159,7 @@ public:
   typename std::add_const<
       typename fusion::result_of::value_at_c<axes_type, N>::type>::type &
   axis() const {
-    static_assert(N < fusion::result_of::size<axes_type>::value,
-                  "axis index out of range");
+    static_assert(N < axes_size::value, "axis index out of range");
     return fusion::at_c<N>(axes_);
   }
 
@@ -185,8 +178,8 @@ private:
     return fc.value;
   }
 
-  template <typename OtherAxes>
-  bool axes_equal_to(const OtherAxes & /*unused*/) const {
+  template <typename A>
+  bool axes_equal_to(const A & /*unused*/) const {
     return false;
   }
 
@@ -195,38 +188,38 @@ private:
   }
 
   template <template <class, class> class Lin, typename First, typename... Rest>
-  pairs apply_lin(pairs&& p, const First &x,
+  size_pair apply_lin(size_pair&& p, const First &x,
                  const Rest &... rest) const {
     Lin<typename fusion::result_of::value_at_c<
-            axes_type, (dim() - 1 - sizeof...(Rest))>::type,
+            axes_type, (axes_size::value - 1 - sizeof...(Rest))>::type,
         First>::apply(p.first, p.second,
-                      fusion::at_c<(dim() - 1 - sizeof...(Rest))>(axes_), x);
+                      fusion::at_c<(axes_size::value - 1 - sizeof...(Rest))>(axes_), x);
     return apply_lin<Lin, Rest...>(std::move(p), rest...);
   }
 
   template <template <class, class> class Lin>
-  pairs apply_lin(pairs&& p) const { return p; }
+  size_pair apply_lin(size_pair&& p) const { return p; }
 
-  template <typename OtherAxes, typename OtherStorage>
-  friend class static_histogram;
+  template <bool D, typename A, typename S>
+  friend class histogram;
 
-  template <class Archive, class OtherStorage, class OtherAxes>
-  friend void serialize(Archive &, static_histogram<OtherStorage, OtherAxes> &,
+  template <class Archive, class S, class A>
+  friend void serialize(Archive &, histogram<false, S, A> &,
                         unsigned);
 };
 
 /// default static type factory
 template <typename... Axes>
-inline static_histogram<mpl::vector<Axes...>>
+inline histogram<false, mpl::vector<Axes...>>
 make_static_histogram(const Axes &... axes) {
-  return static_histogram<mpl::vector<Axes...>>(axes...);
+  return histogram<false, mpl::vector<Axes...>>(axes...);
 }
 
 /// static type factory with variable storage type
 template <typename Storage, typename... Axes>
-inline static_histogram<mpl::vector<Axes...>, Storage>
+inline histogram<false, mpl::vector<Axes...>, Storage>
 make_static_histogram_with(const Axes &... axes) {
-  return static_histogram<mpl::vector<Axes...>, Storage>(axes...);
+  return histogram<false, mpl::vector<Axes...>, Storage>(axes...);
 }
 } // namespace histogram
 } // namespace boost
diff --git a/include/boost/histogram/serialization.hpp b/include/boost/histogram/serialization.hpp
index 518570e1..dc6774b5 100644
--- a/include/boost/histogram/serialization.hpp
+++ b/include/boost/histogram/serialization.hpp
@@ -11,8 +11,7 @@
 #include <boost/fusion/include/for_each.hpp>
 #include <boost/histogram/detail/utility.hpp>
 #include <boost/histogram/detail/weight.hpp>
-#include <boost/histogram/dynamic_histogram.hpp>
-#include <boost/histogram/static_histogram.hpp>
+#include <boost/histogram/histogram.hpp>
 #include <boost/histogram/storage/adaptive_storage.hpp>
 #include <boost/histogram/storage/container_storage.hpp>
 #include <boost/serialization/array.hpp>
@@ -177,16 +176,16 @@ template <typename Archive> struct serialize_helper {
 };
 } // namespace
 
-template <class Archive, class Storage, class Axes>
-inline void serialize(Archive &ar, static_histogram<Storage, Axes> &h,
+template <class Archive, class S, class A>
+inline void serialize(Archive &ar, histogram<false, S, A> &h,
                       unsigned /* version */) {
   serialize_helper<Archive> sh(ar);
   fusion::for_each(h.axes_, sh);
   ar &h.storage_;
 }
 
-template <class Archive, class Storage, class Axes>
-inline void serialize(Archive &ar, dynamic_histogram<Storage, Axes> &h,
+template <class Archive, class S, class A>
+inline void serialize(Archive &ar, histogram<true, S, A> &h,
                       unsigned /* version */) {
   ar &h.axes_;
   ar &h.storage_;
diff --git a/include/boost/histogram/storage/adaptive_storage.hpp b/include/boost/histogram/storage/adaptive_storage.hpp
index e41a6959..d34db318 100644
--- a/include/boost/histogram/storage/adaptive_storage.hpp
+++ b/include/boost/histogram/storage/adaptive_storage.hpp
@@ -160,7 +160,7 @@ public:
     }
   }
 
-  template <typename OtherStorage, typename = detail::is_storage<OtherStorage>>
+  template <typename OtherStorage>
   adaptive_storage &operator=(const OtherStorage &rhs) {
     if (static_cast<const void *>(this) != static_cast<const void *>(&rhs)) {
       if (size() != rhs.size()) {
@@ -193,7 +193,7 @@ public:
     return apply_visitor(variance_visitor(i), buffer_);
   }
 
-  template <typename OtherStorage, typename = detail::is_storage<OtherStorage>>
+  template <typename OtherStorage>
   adaptive_storage &operator+=(const OtherStorage &rhs) {
     for (std::size_t i = 0, n = rhs.size(); i < n; ++i)
       apply_visitor(add_visitor<typename OtherStorage::value_type>(
@@ -206,7 +206,7 @@ public:
     return apply_visitor(bicmp_visitor(), buffer_, o.buffer_);
   }
 
-  template <typename OtherStorage, typename = detail::is_storage<OtherStorage>>
+  template <typename OtherStorage>
   bool operator==(const OtherStorage &o) const {
     return apply_visitor(cmp_visitor<OtherStorage>(o), buffer_);
   }
diff --git a/include/boost/histogram/storage/container_storage.hpp b/include/boost/histogram/storage/container_storage.hpp
index 446eaa73..332c53c4 100644
--- a/include/boost/histogram/storage/container_storage.hpp
+++ b/include/boost/histogram/storage/container_storage.hpp
@@ -50,7 +50,7 @@ public:
     }
   }
 
-  template <typename OtherStorage, typename = detail::is_storage<OtherStorage>>
+  template <typename OtherStorage>
   container_storage &operator=(const OtherStorage &other) {
     detail::init(container_, other.size());
     for (std::size_t i = 0; i < container_.size(); ++i) {
@@ -61,9 +61,10 @@ public:
 
   std::size_t size() const { return container_.size(); }
   void increase(std::size_t i) { ++(container_[i]); }
+  void increase(std::size_t i, value_type w) { container_[i] += w; }
   value_type value(std::size_t i) const { return container_[i]; }
 
-  template <typename OtherStorage, typename = detail::is_storage<OtherStorage>>
+  template <typename OtherStorage>
   void operator+=(const OtherStorage &other) {
     for (std::size_t i = 0; i < container_.size(); ++i) {
       container_[i] += other.value(i);
diff --git a/src/python/histogram.cpp b/src/python/histogram.cpp
index 33ffd869..f71eaead 100644
--- a/src/python/histogram.cpp
+++ b/src/python/histogram.cpp
@@ -6,7 +6,7 @@
 
 #include "serialization_suite.hpp"
 #include <boost/histogram/axis.hpp>
-#include <boost/histogram/dynamic_histogram.hpp>
+#include <boost/histogram/histogram.hpp>
 #include <boost/histogram/histogram_ostream_operators.hpp>
 #include <boost/histogram/serialization.hpp>
 #include <boost/histogram/utility.hpp>
@@ -26,10 +26,11 @@
 #define BOOST_HISTOGRAM_AXIS_LIMIT 32
 #endif
 
-
 namespace boost {
 namespace histogram {
 
+using dynamic_histogram = histogram<true, default_axes, adaptive_storage<>>;
+
 #ifdef HAVE_NUMPY
 auto array_cast = [](python::handle<>& h) {
   return python::downcast<PyArrayObject>(h.get());
@@ -42,7 +43,7 @@ struct axis_visitor : public static_visitor<python::object> {
   }
 };
 
-python::object histogram_axis(const dynamic_histogram<> &self, int i) {
+python::object histogram_axis(const dynamic_histogram &self, int i) {
   if (i < 0)
     i += self.dim();
   if (i < 0 || i >= int(self.dim())) {
@@ -65,7 +66,7 @@ python::object histogram_init(python::tuple args, python::dict kwargs) {
   const unsigned dim = len(args) - 1;
 
   // normal constructor
-  std::vector<dynamic_histogram<>::axis_type> axes;
+  std::vector<dynamic_histogram::axis_type> axes;
   for (unsigned i = 0; i < dim; ++i) {
     python::object pa = args[i + 1];
     python::extract<regular_axis<>> er(pa);
@@ -98,13 +99,13 @@ python::object histogram_init(python::tuple args, python::dict kwargs) {
     PyErr_SetString(PyExc_TypeError, msg.c_str());
     python::throw_error_already_set();
   }
-  dynamic_histogram<> h(axes.begin(), axes.end());
+  dynamic_histogram h(axes.begin(), axes.end());
   return pyinit(h);
 }
 
 python::object histogram_fill(python::tuple args, python::dict kwargs) {
   const unsigned nargs = python::len(args);
-  dynamic_histogram<> &self = python::extract<dynamic_histogram<> &>(args[0]);
+  dynamic_histogram &self = python::extract<dynamic_histogram &>(args[0]);
 
   python::object ow;
   if (kwargs) {
@@ -210,7 +211,7 @@ python::object histogram_fill(python::tuple args, python::dict kwargs) {
 }
 
 python::object histogram_value(python::tuple args, python::dict kwargs) {
-  const dynamic_histogram<> & self = python::extract<const dynamic_histogram<> &>(args[0]);
+  const dynamic_histogram & self = python::extract<const dynamic_histogram &>(args[0]);
 
   const unsigned dim = len(args) - 1;
   if (self.dim() != dim) {
@@ -238,8 +239,8 @@ python::object histogram_value(python::tuple args, python::dict kwargs) {
 }
 
 python::object histogram_variance(python::tuple args, python::dict kwargs) {
-  const dynamic_histogram<> &self =
-      python::extract<const dynamic_histogram<> &>(args[0]);
+  const dynamic_histogram &self =
+      python::extract<const dynamic_histogram &>(args[0]);
 
   const unsigned dim = len(args) - 1;
   if (self.dim() != dim) {
@@ -266,7 +267,7 @@ python::object histogram_variance(python::tuple args, python::dict kwargs) {
   return python::object(self.variance(idx + 0, idx + self.dim()));
 }
 
-std::string histogram_repr(const dynamic_histogram<> &h) {
+std::string histogram_repr(const dynamic_histogram &h) {
   std::ostringstream os;
   os << h;
   return os.str();
@@ -353,7 +354,7 @@ struct storage_access {
     }
   };
 
-  static python::object array_interface(const dynamic_histogram<> &self) {
+  static python::object array_interface(const dynamic_histogram &self) {
     python::dict d;
 
     python::list shapes;
@@ -389,18 +390,18 @@ struct storage_access {
 void register_histogram() {
   python::docstring_options dopt(true, true, false);
 
-  python::class_<dynamic_histogram<>, boost::shared_ptr<dynamic_histogram<>>>(
+  python::class_<dynamic_histogram, boost::shared_ptr<dynamic_histogram>>(
       "histogram", "N-dimensional histogram for real-valued data.", python::no_init)
       .def("__init__", python::raw_function(histogram_init),
            ":param axis args: axis objects"
            "\nPass one or more axis objects to define"
-           "\nthe dimensions of the dynamic_histogram<>.")
+           "\nthe dimensions of the dynamic_histogram.")
       // shadowed C++ ctors
-      .def(python::init<const dynamic_histogram<> &>())
+      .def(python::init<const dynamic_histogram &>())
 #ifdef HAVE_NUMPY
       .add_property("__array_interface__", &storage_access::array_interface)
 #endif
-      .def("__len__", &dynamic_histogram<>::dim)
+      .def("__len__", &dynamic_histogram::dim)
       .def("__getitem__", histogram_axis)
       .def("fill", python::raw_function(histogram_fill),
            "Pass a sequence of values with a length n is"
@@ -412,7 +413,7 @@ void register_histogram() {
            "\nbe a 2d-array of shape (m, n), where m is"
            "\nthe number of tuples, and optionally"
            "\nanother a second 1d-array w of shape (n,).")
-      .add_property("sum", &dynamic_histogram<>::sum)
+      .add_property("sum", &dynamic_histogram::sum)
       .def("value", python::raw_function(histogram_value),
            ":param int args: indices of the bin"
            "\n:return: count for the bin")
@@ -423,7 +424,7 @@ void register_histogram() {
            ":returns: string representation of the histogram")
       .def(python::self == python::self)
       .def(python::self += python::self)
-      .def_pickle(serialization_suite<dynamic_histogram<>>());
+      .def_pickle(serialization_suite<dynamic_histogram>());
 }
 
 } // NS histogram
diff --git a/test/container_storage_test.cpp b/test/container_storage_test.cpp
index fefdee0a..47e5696a 100644
--- a/test/container_storage_test.cpp
+++ b/test/container_storage_test.cpp
@@ -43,11 +43,12 @@ int main() {
     c.increase(0);
     c.increase(0);
     d.increase(0);
+    d.increase(1, 5);
     BOOST_TEST_EQ(a.value(0), 1u);
     BOOST_TEST_EQ(b.value(0), 1u);
     BOOST_TEST_EQ(c.value(0), 2u);
     BOOST_TEST_EQ(d.value(0), 1u);
-    BOOST_TEST_EQ(d.value(1), 0u);
+    BOOST_TEST_EQ(d.value(1), 5u);
     BOOST_TEST(a == a);
     BOOST_TEST(a == b);
     BOOST_TEST(!(a == c));
@@ -55,6 +56,8 @@ int main() {
 
     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));
diff --git a/test/dynamic_histogram_test.cpp b/test/dynamic_histogram_test.cpp
index d1177dca..c7080122 100644
--- a/test/dynamic_histogram_test.cpp
+++ b/test/dynamic_histogram_test.cpp
@@ -10,7 +10,7 @@
 #include <boost/archive/text_oarchive.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <boost/histogram/axis_ostream_operators.hpp>
-#include <boost/histogram/dynamic_histogram.hpp>
+#include <boost/histogram/histogram.hpp>
 #include <boost/histogram/histogram_ostream_operators.hpp>
 #include <boost/histogram/serialization.hpp>
 #include <boost/histogram/storage/adaptive_storage.hpp>
@@ -27,22 +27,22 @@ int main() {
 
   // init_0
   {
-    auto h = dynamic_histogram<default_axes, adaptive_storage<>>();
+    auto h = histogram<true, default_axes>();
     BOOST_TEST_EQ(h.dim(), 0u);
     BOOST_TEST_EQ(h.size(), 0u);
-    auto h2 = dynamic_histogram<default_axes,
+    auto h2 = histogram<true, default_axes,
                                 container_storage<std::vector<unsigned>>>();
     BOOST_TEST(h2 == h);
   }
 
   // init_1
   {
-    auto h = dynamic_histogram<default_axes, adaptive_storage<>>(
+    auto h = histogram<true, default_axes>(
         regular_axis<>{3, -1, 1});
     BOOST_TEST_EQ(h.dim(), 1u);
     BOOST_TEST_EQ(h.size(), 5u);
     BOOST_TEST_EQ(shape(h.axis(0)), 5);
-    auto h2 = dynamic_histogram<default_axes,
+    auto h2 = histogram<true, default_axes,
                                 container_storage<std::vector<unsigned>>>(
         regular_axis<>{3, -1, 1});
     BOOST_TEST(h2 == h);
@@ -50,13 +50,13 @@ int main() {
 
   // init_2
   {
-    auto h = dynamic_histogram<default_axes, adaptive_storage<>>(
+    auto h = histogram<true, default_axes>(
         regular_axis<>{3, -1, 1}, integer_axis{-1, 1});
     BOOST_TEST_EQ(h.dim(), 2u);
     BOOST_TEST_EQ(h.size(), 25u);
     BOOST_TEST_EQ(shape(h.axis(0)), 5);
     BOOST_TEST_EQ(shape(h.axis(1)), 5);
-    auto h2 = dynamic_histogram<default_axes,
+    auto h2 = histogram<true, default_axes,
                                 container_storage<std::vector<unsigned>>>(
         regular_axis<>{3, -1, 1}, integer_axis{-1, 1});
     BOOST_TEST(h2 == h);
@@ -64,11 +64,11 @@ int main() {
 
   // init_3
   {
-    auto h = dynamic_histogram<default_axes, adaptive_storage<>>(
+    auto h = histogram<true, default_axes>(
         regular_axis<>{3, -1, 1}, integer_axis{-1, 1}, circular_axis<>{3});
     BOOST_TEST_EQ(h.dim(), 3u);
     BOOST_TEST_EQ(h.size(), 75u);
-    auto h2 = dynamic_histogram<default_axes,
+    auto h2 = histogram<true, default_axes,
                                 container_storage<std::vector<unsigned>>>(
         regular_axis<>{3, -1, 1}, integer_axis{-1, 1}, circular_axis<>{3});
     BOOST_TEST(h2 == h);
@@ -76,12 +76,12 @@ int main() {
 
   // init_4
   {
-    auto h = dynamic_histogram<default_axes, adaptive_storage<>>(
+    auto h = histogram<true, default_axes>(
         regular_axis<>{3, -1, 1}, integer_axis{-1, 1}, circular_axis<>{3},
         variable_axis<>{-1, 0, 1});
     BOOST_TEST_EQ(h.dim(), 4u);
     BOOST_TEST_EQ(h.size(), 300u);
-    auto h2 = dynamic_histogram<default_axes,
+    auto h2 = histogram<true, default_axes,
                                 container_storage<std::vector<unsigned>>>(
         regular_axis<>{3, -1, 1}, integer_axis{-1, 1}, circular_axis<>{3},
         variable_axis<>{-1, 0, 1});
@@ -103,10 +103,10 @@ int main() {
 
   // init_6
   {
-    auto v = std::vector<dynamic_histogram<>::axis_type>();
+    auto v = std::vector<histogram<true, default_axes>::axis_type>();
     v.push_back(regular_axis<>(100, -1, 1));
     v.push_back(integer_axis(1, 6));
-    auto h = dynamic_histogram<>(v.begin(), v.end());
+    auto h = histogram<true, default_axes>(v.begin(), v.end());
     BOOST_TEST_EQ(h.axis(0), v[0]);
     BOOST_TEST_EQ(h.axis(1), v[1]);
   }
@@ -118,7 +118,7 @@ int main() {
     h.fill(0, 0);
     auto h2 = decltype(h)(h);
     BOOST_TEST(h2 == h);
-    auto h3 = dynamic_histogram<default_axes,
+    auto h3 = histogram<true, default_axes,
                                 container_storage<std::vector<unsigned>>>(h);
     BOOST_TEST(h3 == h);
   }
@@ -135,7 +135,7 @@ int main() {
     // test self-assign
     h2 = h2;
     BOOST_TEST(h == h2);
-    auto h3 = dynamic_histogram<default_axes,
+    auto h3 = histogram<true, default_axes,
                                 container_storage<std::vector<unsigned>>>();
     h3 = h;
     BOOST_TEST(h == h3);
@@ -161,12 +161,12 @@ int main() {
   // equal_compare
   {
     auto a =
-        dynamic_histogram<default_axes, adaptive_storage<>>(integer_axis(0, 1));
-    auto b = dynamic_histogram<default_axes, adaptive_storage<>>(
+        histogram<true, default_axes>(integer_axis(0, 1));
+    auto b = histogram<true, default_axes>(
         integer_axis(0, 1), integer_axis(0, 2));
     BOOST_TEST(!(a == b));
     BOOST_TEST(!(b == a));
-    auto c = dynamic_histogram<mpl::vector<integer_axis>,
+    auto c = histogram<true, mpl::vector<integer_axis>,
                                container_storage<std::vector<unsigned>>>(
         integer_axis(0, 1));
     BOOST_TEST(!(b == c));
@@ -386,9 +386,9 @@ int main() {
 
   // add_1
   {
-    auto a = dynamic_histogram<mpl::vector<integer_axis>, adaptive_storage<>>(
+    auto a = histogram<true, mpl::vector<integer_axis>>(
         integer_axis(-1, 1));
-    auto b = dynamic_histogram<mpl::vector<integer_axis, regular_axis<>>,
+    auto b = histogram<true, mpl::vector<integer_axis, regular_axis<>>,
                                container_storage<std::vector<unsigned>>>(
         integer_axis(-1, 1));
     a.fill(-1);
diff --git a/test/speed_cpp.cpp b/test/speed_cpp.cpp
index 6fc9ab30..05054664 100644
--- a/test/speed_cpp.cpp
+++ b/test/speed_cpp.cpp
@@ -47,6 +47,22 @@ template <typename Histogram> double compare_1d(unsigned n, int distrib) {
   return best;
 }
 
+template <typename Histogram> double compare_2d(unsigned n, int distrib) {
+  auto r = random_array(2 * n, distrib);
+
+  auto best = std::numeric_limits<double>::max();
+  for (unsigned k = 0; k < 50; ++k) {
+    auto h = Histogram(regular_axis<>(100, 0, 1), regular_axis<>(100, 0, 1));
+    auto t = clock();
+    for (unsigned i = 0; i < n; ++i)
+      h.fill(r[2 * i], r[2 * i + 1]);
+    t = clock() - t;
+    best = std::min(best, double(t) / CLOCKS_PER_SEC);
+  }
+
+  return best;
+}
+
 template <typename Histogram> double compare_3d(unsigned n, int distrib) {
   auto r = random_array(3 * n, distrib);
 
@@ -96,21 +112,44 @@ int main() {
     else
       printf("normal distribution\n");
     printf("hs_ss %.3f\n",
-           compare_1d<static_histogram<mpl::vector<regular_axis<>>,
+           compare_1d<histogram<false,mpl::vector<regular_axis<>>,
                                        container_storage<std::vector<int>>>>(
                12000000, itype));
     printf("hs_sd %.3f\n",
-           compare_1d<static_histogram<mpl::vector<regular_axis<>>,
+           compare_1d<histogram<false,mpl::vector<regular_axis<>>,
                                        adaptive_storage<>>>(12000000, itype));
     printf("hd_ss %.3f\n",
-           compare_1d<dynamic_histogram<default_axes,
+           compare_1d<histogram<true, default_axes,
                                         container_storage<std::vector<int>>>>(
                12000000, itype));
     printf("hd_sd %.3f\n",
-           compare_1d<dynamic_histogram<default_axes, adaptive_storage<>>>(
+           compare_1d<histogram<true, default_axes, adaptive_storage<>>>(
                12000000, itype));
   }
 
+  printf("2D\n");
+  for (int itype = 0; itype < 2; ++itype) {
+    if (itype == 0)
+      printf("uniform distribution\n");
+    else
+      printf("normal distribution\n");
+    printf("hs_ss %.3f\n",
+           compare_2d<histogram<false,
+               mpl::vector<regular_axis<>, regular_axis<>>,
+               container_storage<std::vector<int>>>>(6000000, itype));
+    printf("hs_sd %.3f\n",
+           compare_2d<histogram<false,
+               mpl::vector<regular_axis<>, regular_axis<>>,
+               adaptive_storage<>>>(6000000, itype));
+    printf("hd_ss %.3f\n",
+           compare_2d<histogram<true, default_axes,
+                      container_storage<std::vector<int>>>>(
+               6000000, itype));
+    printf("hd_sd %.3f\n",
+           compare_2d<histogram<true, default_axes, adaptive_storage<>>>(
+               6000000, itype));
+  }
+
   printf("3D\n");
   for (int itype = 0; itype < 2; ++itype) {
     if (itype == 0)
@@ -118,19 +157,19 @@ int main() {
     else
       printf("normal distribution\n");
     printf("hs_ss %.3f\n",
-           compare_3d<static_histogram<
+           compare_3d<histogram<false,
                mpl::vector<regular_axis<>, regular_axis<>, regular_axis<>>,
                container_storage<std::vector<int>>>>(4000000, itype));
     printf("hs_sd %.3f\n",
-           compare_3d<static_histogram<
+           compare_3d<histogram<false,
                mpl::vector<regular_axis<>, regular_axis<>, regular_axis<>>,
                adaptive_storage<>>>(4000000, itype));
     printf("hd_ss %.3f\n",
-           compare_3d<dynamic_histogram<default_axes,
+           compare_3d<histogram<true, default_axes,
                                         container_storage<std::vector<int>>>>(
                4000000, itype));
     printf("hd_sd %.3f\n",
-           compare_3d<dynamic_histogram<default_axes, adaptive_storage<>>>(
+           compare_3d<histogram<true, default_axes, adaptive_storage<>>>(
                4000000, itype));
   }
 
@@ -141,21 +180,21 @@ int main() {
     else
       printf("normal distribution\n");
     printf("hs_ss %.3f\n",
-           compare_6d<static_histogram<
+           compare_6d<histogram<false,
                mpl::vector<regular_axis<>, regular_axis<>, regular_axis<>,
                            regular_axis<>, regular_axis<>, regular_axis<>>,
                container_storage<std::vector<int>>>>(2000000, itype));
     printf("hs_sd %.3f\n",
-           compare_6d<static_histogram<
+           compare_6d<histogram<false,
                mpl::vector<regular_axis<>, regular_axis<>, regular_axis<>,
                            regular_axis<>, regular_axis<>, regular_axis<>>,
                adaptive_storage<>>>(2000000, itype));
     printf("hd_ss %.3f\n",
-           compare_6d<dynamic_histogram<default_axes,
+           compare_6d<histogram<true, default_axes,
                                         container_storage<std::vector<int>>>>(
                2000000, itype));
     printf("hd_sd %.3f\n",
-           compare_6d<dynamic_histogram<default_axes, adaptive_storage<>>>(
+           compare_6d<histogram<true, default_axes, adaptive_storage<>>>(
                2000000, itype));
   }
 }
diff --git a/test/speed_gsl.cpp b/test/speed_gsl.cpp
index 8fe38553..bd9bc604 100644
--- a/test/speed_gsl.cpp
+++ b/test/speed_gsl.cpp
@@ -5,6 +5,7 @@
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <gsl/gsl_histogram.h>
+#include <gsl/gsl_histogram2d.h>
 
 #include <algorithm>
 #include <cstdio>
@@ -45,10 +46,33 @@ void compare_1d(unsigned n, int distrib) {
   printf("gsl %.3f\n", best);
 }
 
+void compare_2d(unsigned n, int distrib) {
+  auto r = random_array(2 * n, distrib);
+
+  double best = std::numeric_limits<double>::max();
+  for (unsigned k = 0; k < 50; ++k) {
+    gsl_histogram2d *h = gsl_histogram2d_alloc(100, 100);
+    gsl_histogram2d_set_ranges_uniform(h, 0, 1, 0, 1);
+    auto t = clock();
+    for (unsigned i = 0; i < n; ++i)
+      gsl_histogram2d_increment(h, r[2 * i], r[2 * i + 1]);
+    t = clock() - t;
+    best = std::min(best, double(t) / CLOCKS_PER_SEC);
+    gsl_histogram2d_free(h);
+  }
+  printf("gsl %.3f\n", best);
+}
+
 int main(int argc, char **argv) {
   printf("1D\n");
   printf("uniform distribution\n");
   compare_1d(12000000, 0);
   printf("normal distribution\n");
   compare_1d(12000000, 1);
+
+  printf("2D\n");
+  printf("uniform distribution\n");
+  compare_2d(6000000, 0);
+  printf("normal distribution\n");
+  compare_2d(6000000, 1);
 }
diff --git a/test/speed_numpy.py.in b/test/speed_numpy.py.in
index 86e296a8..2840075d 100755
--- a/test/speed_numpy.py.in
+++ b/test/speed_numpy.py.in
@@ -34,6 +34,32 @@ def compare_1d(n, distrib):
     print "py:numpy %.3f" % best_numpy
     print "py:hd_sd %.3f" % best_boost
 
+def compare_2d(n, distrib):
+    if distrib == 0:
+        r = np.random.rand(2 * n)
+    else:
+        r = 0.3 * np.random.randn(2 * n)
+    r = r.reshape(n, 2)
+
+    best_numpy = float("infinity")
+    best_boost = float("infinity")
+    for k in xrange(50):
+        t = timer()
+        w, xe, ye = np.histogram2d(r[:,0], r[:,1], bins=(100, 100),
+                                   range=((0.0, 1.0), (0.0, 1.0)))
+        t = timer() - t
+        best_numpy = min(t, best_numpy)
+
+        h = histogram(regular_axis(100, 0, 1), regular_axis(100, 0, 1))
+        t = timer()
+        h.fill(r)
+        t = timer() - t
+        best_boost = min(t, best_boost)
+    assert(np.all(w == np.array(h)[:-2,:-2]))
+
+    print "py:numpy %.3f" % best_numpy
+    print "py:hd_sd %.3f" % best_boost
+
 def compare_3d(n, distrib):
     if distrib == 0:
         r = np.random.rand(3 * n)
@@ -107,6 +133,12 @@ compare_1d(12000000, 0)
 print "normal distribution"
 compare_1d(12000000, 1)
 
+print "2D"
+print "uniform distribution"
+compare_2d(6000000, 0)
+print "normal distribution"
+compare_2d(6000000, 1)
+
 print "3D"
 print "uniform distribution"
 compare_3d(4000000, 0)
diff --git a/test/speed_root.cpp b/test/speed_root.cpp
index 71607de8..036e7663 100644
--- a/test/speed_root.cpp
+++ b/test/speed_root.cpp
@@ -5,6 +5,7 @@
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <TH1I.h>
+#include <TH2I.h>
 #include <TH3I.h>
 #include <THn.h>
 
@@ -45,6 +46,21 @@ void compare_1d(unsigned n, int distrib) {
   printf("root %.3f\n", best_root);
 }
 
+void compare_2d(unsigned n, int distrib) {
+  auto r = random_array(2 * n, distrib);
+
+  double best_root = std::numeric_limits<double>::max();
+  for (unsigned k = 0; k < 50; ++k) {
+    TH2I hroot("", "", 100, 0, 1, 100, 0, 1);
+    auto t = clock();
+    for (unsigned i = 0; i < n; ++i)
+      hroot.Fill(r[2 * i], r[2 * i + 1]);
+    t = clock() - t;
+    best_root = std::min(best_root, double(t) / CLOCKS_PER_SEC);
+  }
+  printf("root %.3f\n", best_root);
+}
+
 void compare_3d(unsigned n, int distrib) {
   auto r = random_array(3 * n, distrib);
 
@@ -90,6 +106,12 @@ int main(int argc, char **argv) {
   printf("normal distribution\n");
   compare_1d(12000000, 1);
 
+  printf("2D\n");
+  printf("uniform distribution\n");
+  compare_2d(6000000, 0);
+  printf("normal distribution\n");
+  compare_2d(6000000, 1);
+
   printf("3D\n");
   printf("uniform distribution\n");
   compare_3d(4000000, 0);
diff --git a/test/static_histogram_test.cpp b/test/static_histogram_test.cpp
index 57d13a7e..4365e8ce 100644
--- a/test/static_histogram_test.cpp
+++ b/test/static_histogram_test.cpp
@@ -10,7 +10,7 @@
 #include <boost/histogram/axis_ostream_operators.hpp>
 #include <boost/histogram/histogram_ostream_operators.hpp>
 #include <boost/histogram/serialization.hpp>
-#include <boost/histogram/static_histogram.hpp>
+#include <boost/histogram/histogram.hpp>
 #include <boost/histogram/storage/adaptive_storage.hpp>
 #include <boost/histogram/storage/container_storage.hpp>
 #include <boost/histogram/utility.hpp>
@@ -24,14 +24,14 @@ int main() {
 
   // init_0
   {
-    auto h = static_histogram<mpl::vector<integer_axis>, adaptive_storage<>>();
+    auto h = histogram<false, mpl::vector<integer_axis>, adaptive_storage<>>();
     BOOST_TEST_EQ(h.dim(), 1);
     BOOST_TEST_EQ(h.size(), 0);
-    auto h2 = static_histogram<mpl::vector<integer_axis>,
+    auto h2 = histogram<false, mpl::vector<integer_axis>,
                                container_storage<std::vector<unsigned>>>();
     BOOST_TEST(h2 == h);
     auto h3 =
-        static_histogram<mpl::vector<regular_axis<>>, adaptive_storage<>>();
+        histogram<false, mpl::vector<regular_axis<>>, adaptive_storage<>>();
     BOOST_TEST(!(h3 == h));
   }
 
@@ -108,7 +108,7 @@ int main() {
     h.fill(0, 0);
     auto h2 = decltype(h)(h);
     BOOST_TEST(h2 == h);
-    auto h3 = static_histogram<mpl::vector<integer_axis, integer_axis>,
+    auto h3 = histogram<false, mpl::vector<integer_axis, integer_axis>,
                                container_storage<std::vector<unsigned>>>(h);
     BOOST_TEST(h3 == h);
   }
@@ -124,7 +124,7 @@ int main() {
     // test self-assign
     h2 = h2;
     BOOST_TEST(h == h2);
-    auto h3 = static_histogram<mpl::vector<integer_axis, integer_axis>,
+    auto h3 = histogram<false, mpl::vector<integer_axis, integer_axis>,
                                container_storage<std::vector<unsigned>>>();
     h3 = h;
     BOOST_TEST(h == h3);
@@ -247,6 +247,23 @@ int main() {
     BOOST_TEST_EQ(h.variance(2), 25.0);
   }
 
+  // d1w2
+  {
+    auto h = make_static_histogram_with<container_storage<std::vector<float>>>(regular_axis<>(2, -1, 1));
+    h.fill(0);
+    h.wfill(2.0, -1.0);
+    h.fill(-1.0);
+    h.fill(-2.0);
+    h.wfill(5.0, 10.0);
+
+    BOOST_TEST_EQ(h.sum(), 10);
+
+    BOOST_TEST_EQ(h.value(-1), 1.0);
+    BOOST_TEST_EQ(h.value(0), 3.0);
+    BOOST_TEST_EQ(h.value(1), 1.0);
+    BOOST_TEST_EQ(h.value(2), 5.0);
+  }
+
   // d2
   {
     auto h = make_static_histogram(regular_axis<>(2, -1, 1),