refactor: add _ to large, small, sowds (#418)

Author: henryiii

docs/usage/accumulators.rst

@@ -132,7 +132,7 @@ WeightedMean
 This accumulator is contained in the WeightedMean storage, and supports Views.
 It provides four values; ``.sum_of_weights``, ``sum_of_weights_squared``,
 ``.value``, and ``.variance``. Internally, the variance is stored as
-``sum_of_weighted_deltas_squared``, which is used to compute ``variance``.
+``_sum_of_weighted_deltas_squared``, which is used to compute ``variance``.
 
 For example, you could compute the mean of the following values::
 

include/bh_python/accumulators/weighted_mean.hpp

@@ -37,18 +37,18 @@ struct weighted_mean {
         : sum_of_weights(wsum)
         , sum_of_weights_squared(wsum2)
         , value(mean)
-        , sum_of_weighted_deltas_squared(
+        , _sum_of_weighted_deltas_squared(
               variance * (sum_of_weights - sum_of_weights_squared / sum_of_weights)) {}
 
     weighted_mean(const value_type& wsum,
                   const value_type& wsum2,
                   const value_type& mean,
-                  const value_type& sum_of_weighted_deltas_squared,
+                  const value_type& _sum_of_weighted_deltas_squared,
                   bool /* tag to trigger Python internal constructor */)
         : sum_of_weights(wsum)
         , sum_of_weights_squared(wsum2)
         , value(mean)
-        , sum_of_weighted_deltas_squared(sum_of_weighted_deltas_squared) {}
+        , _sum_of_weighted_deltas_squared(_sum_of_weighted_deltas_squared) {}
 
     void operator()(const value_type& x) { operator()(boost::histogram::weight(1), x); }
 
@@ -58,7 +58,7 @@ struct weighted_mean {
         sum_of_weights_squared += w.value * w.value;
         const auto delta = x - value;
         value += w.value * delta / sum_of_weights;
-        sum_of_weighted_deltas_squared += w.value * delta * (x - value);
+        _sum_of_weighted_deltas_squared += w.value * delta * (x - value);
     }
 
     weighted_mean& operator+=(const weighted_mean& rhs) {
@@ -68,27 +68,28 @@ struct weighted_mean {
             sum_of_weights_squared += rhs.sum_of_weights_squared;
             value = tmp / sum_of_weights;
         }
-        sum_of_weighted_deltas_squared += rhs.sum_of_weighted_deltas_squared;
+        _sum_of_weighted_deltas_squared += rhs._sum_of_weighted_deltas_squared;
         return *this;
     }
 
     weighted_mean& operator*=(const value_type& s) {
         value *= s;
-        sum_of_weighted_deltas_squared *= s * s;
+        _sum_of_weighted_deltas_squared *= s * s;
         return *this;
     }
 
     bool operator==(const weighted_mean& rhs) const noexcept {
         return sum_of_weights == rhs.sum_of_weights
                && sum_of_weights_squared == rhs.sum_of_weights_squared
                && value == rhs.value
-               && sum_of_weighted_deltas_squared == rhs.sum_of_weighted_deltas_squared;
+               && _sum_of_weighted_deltas_squared
+                      == rhs._sum_of_weighted_deltas_squared;
     }
 
     bool operator!=(const weighted_mean rhs) const noexcept { return !operator==(rhs); }
 
     value_type variance() const {
-        return sum_of_weighted_deltas_squared
+        return _sum_of_weighted_deltas_squared
                / (sum_of_weights - sum_of_weights_squared / sum_of_weights);
     }
 
@@ -97,14 +98,14 @@ struct weighted_mean {
         ar& boost::make_nvp("sum_of_weights", sum_of_weights);
         ar& boost::make_nvp("sum_of_weights_squared", sum_of_weights_squared);
         ar& boost::make_nvp("value", value);
-        ar& boost::make_nvp("sum_of_weighted_deltas_squared",
-                            sum_of_weighted_deltas_squared);
+        ar& boost::make_nvp("_sum_of_weighted_deltas_squared",
+                            _sum_of_weighted_deltas_squared);
     }
 
     value_type sum_of_weights{};
     value_type sum_of_weights_squared{};
     value_type value{};
-    value_type sum_of_weighted_deltas_squared{};
+    value_type _sum_of_weighted_deltas_squared{};
 };
 
 } // namespace accumulators

src/boost_histogram/_internal/view.py

@@ -125,15 +125,15 @@ def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
     "sum_of_weights",
     "sum_of_weights_squared",
     "value",
-    "sum_of_weighted_deltas_squared",
+    "_sum_of_weighted_deltas_squared",
 )
 class WeightedMeanView(View):
     __slots__ = ()
     _PARENT = WeightedMean
 
     @property
     def variance(self):
-        return self["sum_of_weighted_deltas_squared"] / (
+        return self["_sum_of_weighted_deltas_squared"] / (
             self["sum_of_weights"]
             - self["sum_of_weights_squared"] / self["sum_of_weights"]
         )

src/register_accumulators.cpp

@@ -167,8 +167,8 @@ void register_accumulators(py::module& accumulators) {
             "value"_a,
             "Run over an array with the accumulator")
 
-        .def_property_readonly("small", &sum::small)
-        .def_property_readonly("large", &sum::large)
+        .def_property_readonly("_small", &sum::small)
+        .def_property_readonly("_large", &sum::large)
 
         ;
 
@@ -177,7 +177,7 @@ void register_accumulators(py::module& accumulators) {
                          sum_of_weights,
                          sum_of_weights_squared,
                          value,
-                         sum_of_weighted_deltas_squared);
+                         _sum_of_weighted_deltas_squared);
 
     register_accumulator<weighted_mean>(
         accumulators, "WeightedMean", py::buffer_protocol())
@@ -193,8 +193,8 @@ void register_accumulators(py::module& accumulators) {
         .def_readonly("sum_of_weights", &weighted_mean::sum_of_weights)
         .def_readonly("sum_of_weights_squared", &weighted_mean::sum_of_weights_squared)
         .def_readonly("value", &weighted_mean::value)
-        .def_readonly("sum_of_weighted_deltas_squared",
-                      &weighted_mean::sum_of_weighted_deltas_squared)
+        .def_readonly("_sum_of_weighted_deltas_squared",
+                      &weighted_mean::_sum_of_weighted_deltas_squared)
 
         .def_property_readonly("variance", &weighted_mean::variance)
 
@@ -223,13 +223,13 @@ void register_accumulators(py::module& accumulators) {
                      return self.sum_of_weights;
                  else if(key.equal(py::str("sum_of_weights_squared")))
                      return self.sum_of_weights_squared;
-                 else if(key.equal(py::str("sum_of_weighted_deltas_squared")))
-                     return self.sum_of_weighted_deltas_squared;
+                 else if(key.equal(py::str("_sum_of_weighted_deltas_squared")))
+                     return self._sum_of_weighted_deltas_squared;
                  else
                      throw py::key_error(
                          py::str(
                              "{0} not one of value, sum_of_weights, "
-                             "sum_of_weights_squared, sum_of_weighted_deltas_squared")
+                             "sum_of_weights_squared, _sum_of_weighted_deltas_squared")
                              .format(key));
              })
         .def("__setitem__",
@@ -240,13 +240,13 @@ void register_accumulators(py::module& accumulators) {
                      self.sum_of_weights = value;
                  else if(key.equal(py::str("sum_of_weights_squared")))
                      self.sum_of_weights_squared = value;
-                 else if(key.equal(py::str("sum_of_weighted_deltas_squared")))
-                     self.sum_of_weighted_deltas_squared = value;
+                 else if(key.equal(py::str("_sum_of_weighted_deltas_squared")))
+                     self._sum_of_weighted_deltas_squared = value;
                  else
                      throw py::key_error(
                          py::str(
                              "{0} not one of value, sum_of_weights, "
-                             "sum_of_weights_squared, sum_of_weighted_deltas_squared")
+                             "sum_of_weights_squared, _sum_of_weighted_deltas_squared")
                              .format(key));
              })
 
@@ -255,7 +255,7 @@ void register_accumulators(py::module& accumulators) {
                  return py::make_tuple("value",
                                        "sum_of_weights",
                                        "sum_of_weights_squared",
-                                       "sum_of_weighted_deltas_squared");
+                                       "_sum_of_weighted_deltas_squared");
              })
 
         ;

tests/test_storage.py

@@ -153,7 +153,9 @@ def test_setting_weighted_profile():
     assert b["value"][0] == h[0].value
     assert b["sum_of_weights"][0] == h[0].sum_of_weights
     assert b["sum_of_weights_squared"][0] == h[0].sum_of_weights_squared
-    assert b["sum_of_weighted_deltas_squared"][0] == h[0].sum_of_weighted_deltas_squared
+    assert (
+        b["_sum_of_weighted_deltas_squared"][0] == h[0]._sum_of_weighted_deltas_squared
+    )
 
     h[0] = bh.accumulators.WeightedMean(
         sum_of_weights=6, sum_of_weights_squared=12, value=3, variance=2
@@ -165,25 +167,29 @@ def test_setting_weighted_profile():
     assert h[0].variance == 2
     assert h[0].sum_of_weights == 6
     assert h[0].sum_of_weights_squared == 12
-    assert h[0].sum_of_weighted_deltas_squared == 8
+    assert h[0]._sum_of_weighted_deltas_squared == 8
 
     assert b["value"][0] == h[0].value
     assert b["sum_of_weights"][0] == h[0].sum_of_weights
     assert b["sum_of_weights_squared"][0] == h[0].sum_of_weights_squared
-    assert b["sum_of_weighted_deltas_squared"][0] == h[0].sum_of_weighted_deltas_squared
+    assert (
+        b["_sum_of_weighted_deltas_squared"][0] == h[0]._sum_of_weighted_deltas_squared
+    )
 
     assert b[0]["value"] == a[0]["value"]
     assert b[0]["sum_of_weights"] == a[0]["sum_of_weights"]
     assert b[0]["sum_of_weights_squared"] == a[0]["sum_of_weights_squared"]
     assert (
-        b[0]["sum_of_weighted_deltas_squared"] == a[0]["sum_of_weighted_deltas_squared"]
+        b[0]["_sum_of_weighted_deltas_squared"]
+        == a[0]["_sum_of_weighted_deltas_squared"]
     )
 
     assert b[0]["value"] == a["value"][0]
     assert b[0]["sum_of_weights"] == a["sum_of_weights"][0]
     assert b[0]["sum_of_weights_squared"] == a["sum_of_weights_squared"][0]
     assert (
-        b[0]["sum_of_weighted_deltas_squared"] == a["sum_of_weighted_deltas_squared"][0]
+        b[0]["_sum_of_weighted_deltas_squared"]
+        == a["_sum_of_weighted_deltas_squared"][0]
     )
 
     assert_array_equal(a.view().value, b.view()["value"])
@@ -192,6 +198,6 @@ def test_setting_weighted_profile():
         a.view().sum_of_weights_squared, b.view()["sum_of_weights_squared"]
     )
     assert_array_equal(
-        a.view().sum_of_weighted_deltas_squared,
-        b.view()["sum_of_weighted_deltas_squared"],
+        a.view()._sum_of_weighted_deltas_squared,
+        b.view()["_sum_of_weighted_deltas_squared"],
     )