sizing.hpp

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

struct VolatilityTargetSizing {
  struct Params {
    InstrumentId instrument_;
    std::size_t window_{20};
    Decimal64 risk_budget_;
    Decimal64 max_quantity_;
    std::string tag_{"volatility-target"};
  };

  Params params_;

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

  template <class Ctx>
  void on_bar(Ctx& ctx, const BarEvent& bar) {
    if (!(bar.instrument_ == params_.instrument_)) {
      return;
    }
    if (params_.window_ < 2) {
      return;
    }
    const auto* series = ctx.bars(bar.instrument_, bar.interval_);
    if (series == nullptr) {
      return;
    }
    const auto closes = series->column(analytics::BarField::CLOSE);
    // One extra row, because a return consumes one: a deviation over `window_` returns needs
    // `window_ + 1` closes.
    const auto window = trailing(closes, params_.window_ + 1);
    if (!window) {
      return;
    }
 
    const auto period_returns = analytics::returns(*window);
    const auto deviations = analytics::rolling_stdev(period_returns, params_.window_);
    const auto deviation = deviations[deviations.size() - 1];
    const auto close = (*window)[window->size() - 1];
    if (!math::observed(deviation) || !math::observed(close)) {
      return;
    }
    // A flat window has no volatility to size against; do not fall back to the maximum.
    if (deviation <= math::Scalar{0} || close <= math::Scalar{0}) {
      return;
    }
 
    const auto value_deviation = analytics::to_decimal(close * deviation, 4);
    if (!value_deviation || value_deviation->coefficient() == 0) {
      return;
    }
    const auto sized = decimal_divide(params_.risk_budget_, *value_deviation, 0);
    if (!sized) {
      return;
    }
 
    TargetPosition target;
    target.instrument_ = params_.instrument_;
    target.target_quantity_ =
      decimal_less(params_.max_quantity_, *sized) ? params_.max_quantity_ : *sized;
    target.tag_ = params_.tag_;
    ctx.submit(target);
  }
};

struct EqualWeightRebalance {
  struct Params {
    std::vector<InstrumentId> universe_;
    std::uint8_t weight_scale_{4};
    MarketPhase rebalance_at_{MarketPhase::OPEN};
    std::string tag_{"equal-weight"};
  };

  Params params_;

  static constexpr std::size_t warmup_bars = 0;

  template <class Ctx>
  void on_phase(Ctx& ctx, MarketPhase phase) {
    if (phase != params_.rebalance_at_ || params_.universe_.empty()) {
      return;
    }
    // One divided by the count, truncated at the stated scale, so the arithmetic is exact and the
    // sum is at most one rather than possibly over it.
    const auto share = decimal_divide(
      Decimal64::parse("1"),
      Decimal64(static_cast<std::int64_t>(params_.universe_.size()), 0),
      params_.weight_scale_
    );
    if (!share || share->coefficient() == 0) {
      return;
    }
 
    for (const auto& instrument : params_.universe_) {
      ctx.submit(
        OrderIntent::market(instrument, OrderSide::BUY, SizeSpec::target_weight(*share))
          .with_tag(params_.tag_)
      );
    }
  }
};
 
} // namespace vanilla
} // namespace strategy
} // namespace algotradelib