vector.hpp

 
#ifndef OPENEV_CONTAINERS_VECTOR_HPP
#define OPENEV_CONTAINERS_VECTOR_HPP
 
#include "openev/containers/array.hpp"
#include "openev/containers/queue.hpp"
#include "openev/core/types.hpp"
#include <cstddef>
#include <numeric>
#include <utility>
#include <vector>
 
namespace ev {
#ifndef OPENEV_ARRAY_HPP
template <typename T, std::size_t N>
class Array_;
#endif
 
#ifndef OPENEV_QUEUE_HPP
template <typename T>
class Queue_;
#endif
template <typename T>
class Vector_ : public std::vector<T> {
  using std::vector<T>::vector;
 
public:
  inline void push_back(const T &e) {
    std::vector<T>::push_back(e);
  }
  template <std::size_t N>
  inline void push_back(const Array_<T, N> &array) {
    std::vector<T>::reserve(std::vector<T>::size() + array.size());
    std::vector<T>::insert(std::vector<T>::end(), array.begin(), array.end());
  }
 
  inline void push_back(Queue_<T> &queue, const bool keep_events_in_queue = false) {
    std::vector<T>::reserve(std::vector<T>::size() + queue.size());
    if(keep_events_in_queue) {
      const std::size_t size = queue.size();
      for(std::size_t i = 0; i < size; i++) {
        std::vector<T>::emplace_back(std::move(queue.front()));
        queue.emplace(queue.front());
        queue.pop();
      }
    } else {
      while(!queue.empty()) {
        std::vector<T>::emplace_back(std::move(queue.front()));
        queue.pop();
      }
    }
  }
 
  [[nodiscard]] inline double duration() const {
    return (std::vector<T>::back()).t - (std::vector<T>::front()).t;
  }
 
  [[nodiscard]] inline double rate() const {
    return std::vector<T>::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);
    }
 
    const std::size_t size = std::vector<T>::size();
    return {x / size, y / size, t / size, p / size >= 0.5};
  }
 
  [[nodiscard]] inline double meanTime() const {
    return std::accumulate(std::vector<T>::begin(), std::vector<T>::end(), 0.0, [](double sum, const T &e) { return sum + e.t; }) / std::vector<T>::size();
  }
};
using Vectori = Vector_<Eventi>;                   
using Vectorl = Vector_<Eventl>;                   
using Vectorf = Vector_<Eventf>;                   
using Vectord = Vector_<Eventd>;                   
using Vector = Vector_<Event>;                     
using AugmentedVectori = Vector_<AugmentedEventi>; 
using AugmentedVectorl = Vector_<AugmentedEventl>; 
using AugmentedVectorf = Vector_<AugmentedEventf>; 
using AugmentedVectord = Vector_<AugmentedEventd>; 
using AugmentedVector = Vector_<AugmentedEvent>;   
} // namespace ev
 
#endif // OPENEV_CONTAINERS_VECTOR_HPP