reversion.hpp

#pragma once
 
#include "./signal.hpp"
 
#include "../event.hpp"
#include "../intent.hpp"
 
#include <algotradelib/analytics>
#include <algotradelib/core>
 
#include <cstddef>
#include <string>
 
namespace algotradelib {
namespace strategy {
namespace vanilla {

struct ZScoreReversion {
  struct Params {
    InstrumentId instrument_;
    std::size_t window_{20};
    math::Scalar entry_{2.0};
    math::Scalar exit_{0.5};
    Decimal64 quantity_;
    std::string tag_{"zscore-reversion"};
  };

  Params params_;

  std::size_t warmup_bars() const { return params_.window_ + 1; }

  template <class Ctx>
  void on_bar(Ctx& ctx, const BarEvent& bar) {
    if (!(bar.instrument_ == params_.instrument_)) {
      return;
    }
    if (params_.window_ < 2 || !(params_.entry_ > 0) || !(params_.exit_ > 0) ||
        !(params_.exit_ < params_.entry_)) {
      // An entry that is not below the mean, an exit that is not, or an exit at or beyond the entry
      // is contradictory; do nothing.
      return;
    }
    const auto* series = ctx.bars(bar.instrument_, bar.interval_);
    if (series == nullptr) {
      return;
    }
    const auto closes = series->column(analytics::BarField::CLOSE);
    const auto window = trailing(closes, params_.window_);
    if (!window) {
      return;
    }
    const auto scores = analytics::zscore(*window, params_.window_);
    const auto score = scores[scores.size() - 1];
    // Unobserved covers both the warm-up and a window with no dispersion, where a score does not
    // exist. Either way there is nothing to act on.
    if (!math::observed(score)) {
      return;
    }
 
    // Net across every position row: a spent lot of 0 beside a live one is not flat.
    const auto held = ctx.portfolio().net_quantity_of(params_.instrument_);
    if (!held) {
      // Rows that do not add up say nothing about what is held; reading them as flat would enter.
      return;
    }
    const bool holding = held->coefficient() != 0;
 
    TargetPosition target;
    target.instrument_ = params_.instrument_;
    target.tag_ = params_.tag_;
    if (!holding && score <= -params_.entry_) {
      target.target_quantity_ = params_.quantity_;
    } else if (holding && -params_.exit_ <= score) {
      target.target_quantity_ = Decimal64::parse("0");
    } else {
      return;
    }
    ctx.submit(target);
  }
};

struct RsiThreshold {
  struct Params {
    InstrumentId instrument_;
    std::size_t period_{14};
    math::Scalar oversold_{30.0};
    math::Scalar overbought_{70.0};
    Decimal64 quantity_;
    std::string tag_{"rsi-threshold"};
  };

  Params params_;

  std::size_t warmup_bars() const { return params_.period_ + 1; }

  template <class Ctx>
  void on_bar(Ctx& ctx, const BarEvent& bar) {
    if (!(bar.instrument_ == params_.instrument_)) {
      return;
    }
    if (params_.period_ == 0 || !(params_.oversold_ < params_.overbought_)) {
      return;
    }
    const auto* series = ctx.bars(bar.instrument_, bar.interval_);
    if (series == nullptr) {
      return;
    }
    const auto closes = series->column(analytics::BarField::CLOSE);
    if (static_cast<std::size_t>(closes.size()) < warmup_bars()) {
      return;
    }
    // The whole cache, not a slice: Wilder's smoothing depends on its seed.
    const auto index = analytics::rsi(closes, params_.period_);
    const auto level = index[index.size() - 1];
    if (!math::observed(level)) {
      return;
    }
 
    // Net across every position row: a spent lot of 0 beside a live one is not flat.
    const auto held = ctx.portfolio().net_quantity_of(params_.instrument_);
    if (!held) {
      // Rows that do not add up say nothing about what is held; reading them as flat would enter.
      return;
    }
    const bool holding = held->coefficient() != 0;
 
    TargetPosition target;
    target.instrument_ = params_.instrument_;
    target.tag_ = params_.tag_;
    if (!holding && level <= params_.oversold_) {
      target.target_quantity_ = params_.quantity_;
    } else if (holding && params_.overbought_ <= level) {
      target.target_quantity_ = Decimal64::parse("0");
    } else {
      return;
    }
    ctx.submit(target);
  }
};

struct DonchianBreakout {
  struct Params {
    InstrumentId instrument_;
    std::size_t lookback_{20};
    Decimal64 quantity_;
    std::string tag_{"donchian-breakout"};
  };

  Params params_;

  std::size_t warmup_bars() const { return params_.lookback_ + 1; }

  template <class Ctx>
  void on_bar(Ctx& ctx, const BarEvent& bar) {
    if (!(bar.instrument_ == params_.instrument_)) {
      return;
    }
    if (params_.lookback_ == 0) {
      return;
    }
    const auto* series = ctx.bars(bar.instrument_, bar.interval_);
    if (series == nullptr) {
      return;
    }
    const auto closes = series->column(analytics::BarField::CLOSE);
    const auto window = trailing(closes, params_.lookback_);
    if (!window) {
      return;
    }
 
    // The channel excludes the latest row, so a break is measurable at all.
    const auto prior = window->head(window->size() - 1);
    const auto highest = analytics::rolling_max(prior, params_.lookback_);
    const auto lowest = analytics::rolling_min(prior, params_.lookback_);
    const auto ceiling = highest[highest.size() - 1];
    const auto floor = lowest[lowest.size() - 1];
    const auto close = (*window)[window->size() - 1];
    if (!math::observed(ceiling) || !math::observed(floor) || !math::observed(close)) {
      return;
    }
 
    TargetPosition target;
    target.instrument_ = params_.instrument_;
    target.tag_ = params_.tag_;
    if (ceiling < close) {
      target.target_quantity_ = params_.quantity_;
    } else if (close < floor) {
      target.target_quantity_ = Decimal64::parse("0");
    } else {
      return;
    }
    ctx.submit(target);
  }
};
 
} // namespace vanilla
} // namespace strategy
} // namespace algotradelib