clock.hpp

Go to the documentation of this file.

#pragma once
 
#include "../strategy/event.hpp"
 
#include "../math/scalar.hpp"
 
#include <algotradelib/core>
 
#include <chrono>
#include <utility>
#include <optional>
 
namespace algotradelib {
namespace backtest {


inline std::optional<std::chrono::seconds> interval_duration(BarInterval interval) {
  return bar_interval_length(interval);
}

inline std::optional<math::Scalar> periods_per_year(
  BarInterval interval,
  const strategy::SessionWindow& session,
  math::Scalar trading_days
) {
  if (!(trading_days > math::Scalar{0})) {
    return std::nullopt;
  }
  if (interval == BarInterval::ONE_DAY) {
    return trading_days;
  }
  const auto duration = interval_duration(interval);
  if (!duration) {
    return std::nullopt;
  }
  const auto session_seconds =
    std::chrono::duration_cast<std::chrono::seconds>(session.close_ - session.open_).count();
  if (session_seconds <= 0 || duration->count() <= 0) {
    return std::nullopt;
  }
  // Rounded up: the session's last bar may be shorter than the others.
  const auto per_day = (session_seconds + duration->count() - 1) / duration->count();
  return static_cast<math::Scalar>(per_day) * trading_days;
}

class ReplayClock {
public:
  explicit ReplayClock(strategy::SessionWindow session = strategy::SessionWindow::krx())
  : session_(std::move(session)) {}

  const strategy::SessionWindow& session() const noexcept { return session_; }

  std::chrono::system_clock::time_point now() const noexcept { return now_; }

  strategy::MarketPhase phase() const noexcept { return phase_; }

  bool advance(const strategy::BarEvent& event, std::optional<bool> trading_day) {
    return advance_to(event.period_end_, trading_day);
  }

  bool advance_to(
    std::chrono::system_clock::time_point at,
    std::optional<bool> trading_day
  ) {
    now_ = at;
    const auto next = session_.phase(now_, trading_day);
    const bool changed = next != phase_;
    phase_ = next;
    return changed;
  }

  static bool contiguous(
    const strategy::BarEvent& previous,
    const strategy::BarEvent& event
  ) {
    const auto duration = interval_duration(event.interval_);
    if (!duration || previous.interval_ != event.interval_) {
      // Undecidable for intervals with no fixed length; reported as contiguous.
      return true;
    }
    return event.period_end_ - previous.period_end_ <= *duration;
  }
 
private:
  strategy::SessionWindow session_;
  std::chrono::system_clock::time_point now_{};
  strategy::MarketPhase phase_{strategy::MarketPhase::UNKNOWN};
};
 
} // namespace backtest
} // namespace algotradelib