update source to Ceph Pacific 16.2.2

[ceph.git] / ceph / src / boost / boost / histogram / accumulators / mean.hpp

diff --git a/ceph/src/boost/boost/histogram/accumulators/mean.hpp b/ceph/src/boost/boost/histogram/accumulators/mean.hpp
index f814fc042d703c9b9c6ff5c1aa3b942939117d7b..6bdc27f7a02957f5f2151477c621fde7c9e8bd9a 100644 (file)
--- a/ceph/src/boost/boost/histogram/accumulators/mean.hpp
+++ b/ceph/src/boost/boost/histogram/accumulators/mean.hpp
@@ -23,58 +23,75 @@ namespace accumulators {
   Uses Welfords's incremental algorithm to improve the numerical
   stability of mean and variance computation.
 */
-template <class RealType>
+template <class ValueType>
 class mean {
 public:
+  using value_type = ValueType;
+  using const_reference = const value_type&;
+
   mean() = default;
-  mean(const RealType& n, const RealType& mean, const RealType& variance) noexcept
+
+  /// Allow implicit conversion from mean<T>
+  template <class T>
+  mean(const mean<T>& o) noexcept
+      : sum_{o.sum_}, mean_{o.mean_}, sum_of_deltas_squared_{o.sum_of_deltas_squared_} {}
+
+  /// Initialize to external count, mean, and variance
+  mean(const_reference n, const_reference mean, const_reference variance) noexcept
       : sum_(n), mean_(mean), sum_of_deltas_squared_(variance * (n - 1)) {}
 
-  void operator()(const RealType& x) noexcept {
-    sum_ += static_cast<RealType>(1);
+  /// Insert sample x
+  void operator()(const_reference x) noexcept {
+    sum_ += static_cast<value_type>(1);
     const auto delta = x - mean_;
     mean_ += delta / sum_;
     sum_of_deltas_squared_ += delta * (x - mean_);
   }
 
-  void operator()(const weight_type<RealType>& w, const RealType& x) noexcept {
+  /// Insert sample x with weight w
+  void operator()(const weight_type<value_type>& w, const_reference x) noexcept {
     sum_ += w.value;
     const auto delta = x - mean_;
     mean_ += w.value * delta / sum_;
     sum_of_deltas_squared_ += w.value * delta * (x - mean_);
   }
 
-  template <class T>
-  mean& operator+=(const mean<T>& rhs) noexcept {
+  /// Add another mean accumulator
+  mean& operator+=(const mean& rhs) noexcept {
     if (sum_ != 0 || rhs.sum_ != 0) {
-      const auto tmp = mean_ * sum_ + static_cast<RealType>(rhs.mean_ * rhs.sum_);
+      const auto tmp = mean_ * sum_ + rhs.mean_ * rhs.sum_;
       sum_ += rhs.sum_;
       mean_ = tmp / sum_;
     }
-    sum_of_deltas_squared_ += static_cast<RealType>(rhs.sum_of_deltas_squared_);
+    sum_of_deltas_squared_ += rhs.sum_of_deltas_squared_;
     return *this;
   }
 
-  mean& operator*=(const RealType& s) noexcept {
+  /** Scale by value
+
+   This acts as if all samples were scaled by the value.
+  */
+  mean& operator*=(const_reference s) noexcept {
     mean_ *= s;
     sum_of_deltas_squared_ *= s * s;
     return *this;
   }
 
-  template <class T>
-  bool operator==(const mean<T>& rhs) const noexcept {
+  bool operator==(const mean& rhs) const noexcept {
     return sum_ == rhs.sum_ && mean_ == rhs.mean_ &&
            sum_of_deltas_squared_ == rhs.sum_of_deltas_squared_;
   }
 
-  template <class T>
-  bool operator!=(const mean<T>& rhs) const noexcept {
-    return !operator==(rhs);
-  }
+  bool operator!=(const mean& rhs) const noexcept { return !operator==(rhs); }
+
+  /// Return how many samples were accumulated
+  const_reference count() const noexcept { return sum_; }
 
-  const RealType& count() const noexcept { return sum_; }
-  const RealType& value() const noexcept { return mean_; }
-  RealType variance() const noexcept { return sum_of_deltas_squared_ / (sum_ - 1); }
+  /// Return mean value of accumulated samples
+  const_reference value() const noexcept { return mean_; }
+
+  /// Return variance of accumulated samples
+  value_type variance() const noexcept { return sum_of_deltas_squared_ / (sum_ - 1); }
 
   template <class Archive>
   void serialize(Archive& ar, unsigned version) {
@@ -82,7 +99,7 @@ public:
       // read only
       std::size_t sum;
       ar& make_nvp("sum", sum);
-      sum_ = static_cast<RealType>(sum);
+      sum_ = static_cast<value_type>(sum);
     } else {
       ar& make_nvp("sum", sum_);
     }
@@ -91,7 +108,9 @@ public:
   }
 
 private:
-  RealType sum_ = 0, mean_ = 0, sum_of_deltas_squared_ = 0;
+  value_type sum_{};
+  value_type mean_{};
+  value_type sum_of_deltas_squared_{};
 };
 
 } // namespace accumulators
@@ -106,10 +125,10 @@ namespace serialization {
 template <class T>
 struct version;
 
-// version 1 for boost::histogram::accumulators::mean<RealType>
-template <class RealType>
-struct version<boost::histogram::accumulators::mean<RealType>>
-    : std::integral_constant<int, 1> {};
+// version 1 for boost::histogram::accumulators::mean<T>
+template <class T>
+struct version<boost::histogram::accumulators::mean<T>> : std::integral_constant<int, 1> {
+};
 
 } // namespace serialization
 } // namespace boost