TimeHistory.hpp

Go to the documentation of this file.

#ifndef PHYTH_TIME_HISTORY_HPP
#define PHYTH_TIME_HISTORY_HPP
 
#include "Phyth/Core/Units.hpp"
#include "QuantityFuncs.hpp"
#include "Phyth/Physical/PhysicalConfig.hpp"
 
#include <vector>
#include <cmath>
 
namespace Phyth {
    template<typename T>
    class TimeHistory {
    public:
        using ValueType = T;
 
        void Register(T value) {
            history_.push_back(value);
        }
 
        [[nodiscard]] ValueType GetValueByTime(const Quantity<Second> time) const {
            const Scalar tick = time / Config::dt;
 
            const auto index = Utils::floor(tick).To<long long>();
 
            if (index < 0 || index >= static_cast<long long>(history_.size())) {
                throw std::out_of_range("TimeHistory::GetValueByTime: time out of range");
            }
 
            ValueType result = history_[index];
 
            const Scalar frac = tick - Scalar(static_cast<double>(index));
 
            // If there is a fractional part and we have a next sample, interpolate
            if (frac > Config::epsilon) {
                if (static_cast<size_t>(index + 1) < history_.size()) {
                    result += (history_[index + 1] - result) * frac;
                }
            }
            return result;
        }
 
        [[nodiscard]] ValueType GetValueByOffset(const Quantity<Second> offset) const {
            if (history_.empty()) {
                throw std::out_of_range("TimeHistory::GetValueByOffset: history is empty");
            }
 
            if (offset < 0_s) {
                throw std::out_of_range("TimeHistory::GetValueByOffset: offset cannot be negative");
            }
 
            const Quantity<Second> time = static_cast<double>(history_.size()) * Config::dt - offset;
            if (time < 0_s) {
                throw std::out_of_range("TimeHistory::GetValueByOffset: offset exceeds history range");
            }
 
            return GetValueByTime(time);
        }
 
        [[nodiscard]] size_t GetSize() const noexcept { return history_.size(); }
 
        [[nodiscard]] bool IsEmpty() const noexcept { return history_.empty(); }
 
    protected:
        std::vector<ValueType> history_;
    };
}
 
#endif // PHYTH_TIME_HISTORY_HPP