Class Accumulator

pose_graph/include/utils/Accumulator.h:47–166

// the vector has a fixed size.
template <typename SampleType, typename SumType, int WindowSize>
class Accumulator {
 public:
  Accumulator()
      : sample_index_(0),
        total_samples_(0),
        sum_(0),
        window_sum_(0),
        min_(std::numeric_limits<SampleType>::max()),
        max_(std::numeric_limits<SampleType>::lowest()),
        most_recent_(0) {
    CHECK_GT(WindowSize, 0);
    if (WindowSize < kInfiniteWindowSize) {
      samples_.reserve(WindowSize);
    }
  }

  /* ------------------------------------------------------------------------ */
  void Add(SampleType sample) {
    most_recent_ = sample;
    if (sample_index_ < WindowSize) {
      samples_.push_back(sample);
      window_sum_ += sample;
      ++sample_index_;
    } else {
      SampleType& oldest = samples_.at(sample_index_++ % WindowSize);
      window_sum_ += sample - oldest;
      oldest = sample;
    }
    sum_ += sample;
    ++total_samples_;
    if (sample > max_) {
      max_ = sample;
    }
    if (sample < min_) {
      min_ = sample;
    }
  }

  /* ------------------------------------------------------------------------ */
  int total_samples() const { return total_samples_; }

  /* ------------------------------------------------------------------------ */
  SumType sum() const { return sum_; }

  /* ------------------------------------------------------------------------ */
  SumType Mean() const { return (total_samples_ < 1) ? 0.0 : sum_ / total_samples_; }

  /* ------------------------------------------------------------------------ */
  // Rolling mean is only used for fixed sized data for now. We don't need this
  // function for our infinite accumulator at this point.
  SumType RollingMean() const {
    if (WindowSize < kInfiniteWindowSize) {
      return window_sum_ / std::min(sample_index_, WindowSize);
    } else {
      return Mean();
    }
  }