Statistics.hpp

Go to the documentation of this file.

#pragma once
 
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/count.hpp>
#include <boost/accumulators/statistics/max.hpp>
#include <boost/accumulators/statistics/mean.hpp>
#include <boost/accumulators/statistics/min.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/variance.hpp>
#include <fmt/ostream.h>
#include <iosfwd>
 
namespace precice::utils::statistics {
 
class DistanceAccumulator {
public:
  void operator()(double value)
  {
    _acc(value);
  }
  void operator()(double value) {…}
 
  double min() const
  {
    return empty() ? std::nan("") : boost::accumulators::extract::min(_acc);
  }
  double min() const {…}
 
  double max() const
  {
    return empty() ? std::nan("") : boost::accumulators::extract::max(_acc);
  }
  double max() const {…}
 
  double mean() const
  {
    return empty() ? std::nan("") : boost::accumulators::extract::mean(_acc);
  }
  double mean() const {…}
 
  double variance() const
  {
    return empty() ? std::nan("") : boost::accumulators::extract::variance(_acc);
  }
  double variance() const {…}
 
  std::size_t count() const
  {
    return boost::accumulators::extract::count(_acc);
  }
  std::size_t count() const {…}
 
  bool empty() const
  {
    return count() == 0;
  }
  bool empty() const {…}
 
private:
  boost::accumulators::accumulator_set<double, boost::accumulators::stats<
                                                   boost::accumulators::tag::min,
                                                   boost::accumulators::tag::max,
                                                   boost::accumulators::tag::mean,
                                                   boost::accumulators::tag::lazy_variance>>
      _acc;
};
class DistanceAccumulator {…};
 
inline std::ostream &operator<<(std::ostream &out, const DistanceAccumulator &accumulator)
{
  if (accumulator.empty()) {
    out << "empty";
  } else {
    out << "min:" << accumulator.min()
        << " max:" << accumulator.max()
        << " avg: " << accumulator.mean()
        << " var: " << accumulator.variance()
        << " cnt: " << accumulator.count();
  }
  return out;
}
inline std::ostream &operator<<(std::ostream &out, const DistanceAccumulator &accumulator) {…}
 
} // namespace precice::utils::statistics
namespace precice::utils::statistics {…}
 
template <>
struct fmt::formatter<precice::utils::statistics::DistanceAccumulator> : ostream_formatter {
};
struct fmt::formatter<precice::utils::statistics::DistanceAccumulator> : ostream_formatter {…};