rate_of_change.hpp

// A structure for calculating the Rate of Change (ROC) over a rolling window.
// Copyright 2020 Christian Kauten
//
// Author: Christian Kauten (kautenja@auburn.edu)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
 
#ifndef MATHS_RATE_OF_CHANGE
#define MATHS_RATE_OF_CHANGE
 
#include <algorithm>
#include <atomic>
#include <limits>
#include <vector>
 
namespace Maths {
 
template<typename Observation = double, typename RoC = double>
struct RateOfChange {
 private:
    std::vector<Observation> history;
    std::size_t index = 0;
    RoC rate_of_change = 0;
 
 public:
    static constexpr std::size_t LENGTH_MIN = 2;
    static constexpr std::size_t LENGTH_MAX = std::numeric_limits<uint16_t>::max() - 1;
 
    explicit RateOfChange(std::size_t length) {
        if (length < LENGTH_MIN)
            throw "length must be >= " + std::to_string(LENGTH_MIN);
        if (length > LENGTH_MAX)
            throw "length must be <= " + std::to_string(LENGTH_MAX);
        history.resize(length, 0);
    }
 
    std::size_t get_length() const { return history.size(); }
 
    inline RoC get_rate_of_change() const { return rate_of_change; }
 
    inline void reset() {
        std::fill(history.begin(), history.end(), 0);
        index = 0;
        rate_of_change = 0;
    }
 
    inline void process(Observation observation) {
        // add the current observation to the history
        history[index] = observation;
        auto next_index = (index + 1) % history.size();
        // get the price from the beginning of the history
        auto value = history[next_index];
        index = next_index;
        // return if still learning value information (prevent divide by 0)
        if (value == 0) return;
        // set the rate of change
        rate_of_change = (observation - value) / value;
    }
};
 
}  // namespace Maths
 
#endif  // MATHS_RATE_OF_CHANGE