indicators.h

Go to the documentation of this file.

 
#ifndef INDICATORS_H
#define INDICATORS_H
 
#include <cstddef>
#include <vector>
#include "defs.h"
 
namespace tzu {

template <class T, typename In, typename Out>
class Indicator {
public:
    Out get() const noexcept {
        return static_cast<const T*>(this)->get();
    }
    Out update(In value) {
        return static_cast<T*>(this)->update(value);
    }
};

class SMA: public Indicator<SMA, double, double> {
    double data = std::nan("");
    std::vector<double> prev;
    size_t pos = 0;
    size_t len = 0;
    double sum = 0.0;
public:
    SMA(size_t window_size): prev(window_size, std::nan("")) {}
    double get() const noexcept { return data; }
    double update(double value) {
        if (len < prev.size())
            len++;
        else
            sum -= prev[pos];
        sum += value;
        prev[pos] = value;
        pos = (pos + 1) % prev.size();
        data = len < prev.size()
                ? std::nan("") 
                : sum / static_cast<double>(prev.size());
        return data;
    }
};

class EMA: public Indicator<EMA, double, double> {
    double data = std::nan("");
    double alpha;
    double prev = 0.0;
    size_t len = 0;
    size_t period;
public:
    EMA(size_t period, double smoothing = 2.0)
        : alpha(smoothing / (period + 1.0)), period(period) {}
    double get() const noexcept { return data; }
    double update(double value) {
        len++;
        if (len < period) {
            prev += value;
            data = std::nan("");
        } else if (len == period) {
            prev += value;
            prev /= period;
            data = prev;
        } else {
            prev = (value * alpha) + (prev * (1.0 - alpha));
            data = prev;
        }
        return data;
    }
};

class MVar {
    double data = std::nan("");
    SMA sma;
    std::vector<double> prev;
    size_t pos = 0;
    size_t len = 0;
    // double sum = 0.0;
    size_t dof;
public:
    MVar(size_t window_size, size_t dof)
        : sma(window_size), prev(window_size, std::nan("")), dof(dof) {}
    double get() const noexcept { return data; }
    double update(double value) {
        if (len < prev.size()) len++;
        prev[pos] = value;
        pos = (pos + 1) % prev.size();
        sma.update(value);
        if (len < prev.size())
            return std::nan("");
        double accum = 0.0;
        for (size_t prev_value : prev) {
            if (std::isnan(prev_value))
                return std::nan("");
            double diff = prev_value - sma.get();
            accum += diff * diff;
        }
        data = accum / (prev.size() - dof);
        return data;
    }
};

class RSI: public Indicator<RSI, Ohlcv, double> {
    double data = std::nan("");
    SMA gains;
    SMA losses;
public:
    RSI(size_t period): gains(period), losses(period) {}
    double get() const noexcept { return data; }
    double update(Ohlcv value) {
        double diff = value.close - value.open;
        gains.update(diff >= 0.0 ? diff : 0.0);
        losses.update(diff < 0 ? -diff : 0.0);
        if (std::isnan(losses.get()))
            return std::nan("");
        data = 100.0 - 100.0 / (1.0 + gains.get() / losses.get());
        return data;
    }
};

struct MACDResult {
    double macd;
    double signal;
    double histogram;
};

class MACD: public Indicator<MACD, double, MACDResult> {
    MACDResult data;
    EMA short_ema;
    EMA long_ema;
    EMA signal_ema;
    size_t len = 0;
    size_t start;
public:
    MACD(size_t short_period, size_t long_period, size_t signal_period,
            double smoothing = 2.0)
        : short_ema(short_period, smoothing),
          long_ema(long_period, smoothing),
          signal_ema(signal_period, smoothing),
          start(std::fmax(short_period, long_period)) {}
    MACDResult get() const noexcept { return data; }
    MACDResult update(double value) {
        len++;
        short_ema.update(value);
        long_ema.update(value);
        if (len <= start)
            return {std::nan(""), std::nan(""), std::nan("")};
        double diff = short_ema.get() - long_ema.get();
        signal_ema.update(diff);
        data = {diff, signal_ema.get(), diff - signal_ema.get()};
        return data;
    }
};

class MDD: public Indicator<MDD, double, double> {
    double data = 0.0;
    double peak = 0.0;
public:
    double get() const noexcept { return data; }
    double update(double value) {
        if (value > peak)
            peak = value;
        if (peak > 0.0) {
            double curr = (value - peak) / peak;
            if (curr < data)
                data = curr;
        }
        return data;
    }
};
 
} // namespace tzu
 
#endif // INDICATORS_H