array.hpp

 
#ifndef OPENEV_CONTAINERS_ARRAY_HPP
#define OPENEV_CONTAINERS_ARRAY_HPP
 
#include "openev/core/types.hpp"
#include <array>
#include <cstddef>
#include <numeric>
 
namespace ev {
template <typename T, std::size_t N>
class Array_ : public std::array<T, N> {
  using std::array<T, N>::array;
 
public:
  [[nodiscard]] inline double duration() const {
    return (std::array<T, N>::back()).t - (std::array<T, N>::front()).t;
  }
 
  [[nodiscard]] inline double rate() const {
    return std::array<T, N>::size() / duration();
  }
 
  [[nodiscard]] Eventd mean() const {
    double x = 0.0;
    double y = 0.0;
    double t = 0.0;
    double p = 0.0;
 
    for(const T &e : *this) {
      x += static_cast<double>(e.x);
      y += static_cast<double>(e.y);
      t += static_cast<double>(e.t);
      p += static_cast<double>(e.p);
    }
 
    return {x / N, y / N, t / N, p / N >= 0.5};
  }
 
  [[nodiscard]] inline double meanTime() const {
    return std::accumulate(std::array<T, N>::begin(), std::array<T, N>::end(), 0.0, [](double sum, const T &e) { return sum + e.t; }) / N;
  }
};
template <std::size_t N>
using Arrayi = Array_<Eventi, N>; 
template <std::size_t N>
using Arrayl = Array_<Eventl, N>; 
template <std::size_t N>
using Arrayf = Array_<Eventf, N>; 
template <std::size_t N>
using Arrayd = Array_<Eventd, N>; 
template <std::size_t N>
using Array = Array_<Event, N>; 
template <std::size_t N>
using AugmentedArrayi = Array_<AugmentedEventi, N>; 
template <std::size_t N>
using AugmentedArrayl = Array_<AugmentedEventl, N>; 
template <std::size_t N>
using AugmentedArrayf = Array_<AugmentedEventf, N>; 
template <std::size_t N>
using AugmentedArrayd = Array_<AugmentedEventd, N>; 
template <std::size_t N>
using AugmentedArray = Array_<AugmentedEvent, N>; 
} // namespace ev
 
#endif // OPENEV_CONTAINERS_ARRAY_HPP