frame.hpp

#pragma once
 
#include "./conversion.hpp"
#include "./time_index.hpp"
 
#include "../math/matrix.hpp"
 
#include <algotradelib/core>
 
#include <array>
#include <cstddef>
#include <stdexcept>
#include <string_view>
#include <utility>
#include <vector>
 
namespace algotradelib {
namespace analytics {

enum class BarField {
  OPEN,
  HIGH,
  LOW,
  CLOSE,
  VOLUME,
  TRADED_VALUE,
};

inline constexpr std::array<BarField, 6> all_bar_fields{
  BarField::OPEN,
  BarField::HIGH,
  BarField::LOW,
  BarField::CLOSE,
  BarField::VOLUME,
  BarField::TRADED_VALUE,
};

inline constexpr std::size_t bar_field_count = all_bar_fields.size();

inline constexpr std::size_t bar_field_index(BarField field) noexcept {
  return static_cast<std::size_t>(field);
}

inline constexpr std::string_view bar_field_name(BarField field) noexcept {
  switch (field) {
    case BarField::OPEN:
      return "open";
    case BarField::HIGH:
      return "high";
    case BarField::LOW:
      return "low";
    case BarField::CLOSE:
      return "close";
    case BarField::VOLUME:
      return "volume";
    case BarField::TRADED_VALUE:
      return "traded_value";
  }
  return "";
}
 
static_assert(
  lists_every_value(all_bar_fields, [](BarField field) { return !bar_field_name(field).empty(); }),
  "all_bar_fields must list every BarField"
);

class SeriesFrame {
public:
  SeriesFrame() = default;

  explicit SeriesFrame(TimeIndex index, InstrumentId instrument = {})
  : instrument_(std::move(instrument)), index_(std::move(index)) {
    values_ = math::Matrix::Constant(
      static_cast<math::Index>(index_.size()),
      static_cast<math::Index>(bar_field_count),
      missing()
    );
  }

  std::size_t rows() const noexcept { return index_.size(); }

  std::size_t columns() const noexcept { return bar_field_count; }

  const TimeIndex& time() const noexcept { return index_; }

  const InstrumentId& instrument() const noexcept { return instrument_; }

  math::SeriesView column(BarField field) const {
    return values_.col(static_cast<math::Index>(bar_field_index(field)));
  }

  math::SeriesView close() const { return column(BarField::CLOSE); }

  math::SeriesView open() const { return column(BarField::OPEN); }

  math::SeriesView high() const { return column(BarField::HIGH); }

  math::SeriesView low() const { return column(BarField::LOW); }

  math::SeriesView volume() const { return column(BarField::VOLUME); }

  Scalar at(std::size_t row, BarField field) const {
    if (row >= rows()) {
      throw std::out_of_range("frame row is past the end");
    }
    return values_(
      static_cast<math::Index>(row), static_cast<math::Index>(bar_field_index(field))
    );
  }

  void set(std::size_t row, BarField field, Scalar value) {
    if (row >= rows()) {
      throw std::out_of_range("frame row is past the end");
    }
    values_(
      static_cast<math::Index>(row), static_cast<math::Index>(bar_field_index(field))
    ) = value;
  }

  math::MatrixView values() const { return values_; }
 
private:
  InstrumentId instrument_;
  TimeIndex index_;
  math::Matrix values_;
};

inline SeriesFrame from_bars(const BarSeries& series) {
  std::vector<TimeIndex::Instant> stamps;
  stamps.reserve(series.bars_.size());
  for (const auto& bar : series.bars_) {
    stamps.push_back(bar.timestamp_);
  }
 
  SeriesFrame frame(TimeIndex(std::move(stamps)), series.instrument_);
  for (std::size_t row = 0; row < series.bars_.size(); ++row) {
    const auto& bar = series.bars_[row];
    // An absent open is a trading day on which nothing traded. It stays unobserved
    // rather than becoming zero or the previous close.
    if (bar.open_) {
      frame.set(row, BarField::OPEN, to_scalar(*bar.open_));
    }
    frame.set(row, BarField::HIGH, to_scalar(bar.high_));
    frame.set(row, BarField::LOW, to_scalar(bar.low_));
    frame.set(row, BarField::CLOSE, to_scalar(bar.close_));
    frame.set(row, BarField::VOLUME, to_scalar(bar.volume_));
    if (bar.traded_value_) {
      frame.set(row, BarField::TRADED_VALUE, to_scalar(*bar.traded_value_));
    }
  }
  return frame;
}
 
} // namespace analytics
} // namespace algotradelib