crossover.hpp

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

enum class AverageKind {
  SIMPLE,
  EXPONENTIAL,
};

struct MovingAverageCrossover {
  struct Params {
    InstrumentId instrument_;
    std::size_t fast_{20};
    std::size_t slow_{50};
    AverageKind kind_{AverageKind::SIMPLE};
    Decimal64 quantity_;
    std::string tag_{"ma-crossover"};
  };

  Params params_;

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

  template <class Ctx>
  void on_bar(Ctx& ctx, const BarEvent& bar) {
    if (!(bar.instrument_ == params_.instrument_)) {
      return;
    }
    if (params_.fast_ == 0 || params_.slow_ <= params_.fast_) {
      // A fast window that is not faster would invert the signal; do nothing instead.
      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;
    }
 
    const auto fast = line(closes, params_.fast_);
    const auto slow = line(closes, params_.slow_);
    const auto fast_pair = last_two(fast);
    const auto slow_pair = last_two(slow);
    if (!fast_pair || !slow_pair) {
      return;
    }
 
    TargetPosition target;
    target.instrument_ = params_.instrument_;
    target.target_quantity_ = slow_pair->current_ < fast_pair->current_ ?
      params_.quantity_ :
      Decimal64::parse("0");
    target.tag_ = params_.tag_;
    ctx.submit(target);
  }
 
private:
  // The chosen average of `closes`, the whole cached series; see `AverageKind`.
  math::Vector line(math::SeriesView closes, std::size_t span) const {
    if (params_.kind_ == AverageKind::EXPONENTIAL) {
      return exponential_line(closes, span);
    }
    // Only the window: slicing keeps the per-bar cost from growing with the cache. The slice is the
    // slow window's for both lines, as it always was, so these numbers do not move.
    return analytics::sma(closes.tail(static_cast<math::Index>(params_.slow_) + 1), span);
  }
};

struct SmaCrossover {
  MovingAverageCrossover inner_;

  explicit SmaCrossover(MovingAverageCrossover::Params params = {}) {
    params.kind_ = AverageKind::SIMPLE;
    inner_.params_ = std::move(params);
  }

  std::size_t warmup_bars() const { return inner_.warmup_bars(); }

  template <class Ctx>
  void on_bar(Ctx& ctx, const BarEvent& bar) {
    inner_.on_bar(ctx, bar);
  }
};

struct EmaCrossover {
  MovingAverageCrossover inner_;

  explicit EmaCrossover(MovingAverageCrossover::Params params = {}) {
    params.kind_ = AverageKind::EXPONENTIAL;
    inner_.params_ = std::move(params);
  }

  std::size_t warmup_bars() const { return inner_.warmup_bars(); }

  template <class Ctx>
  void on_bar(Ctx& ctx, const BarEvent& bar) {
    inner_.on_bar(ctx, bar);
  }
};
 
} // namespace vanilla
} // namespace strategy
} // namespace algotradelib