panel.hpp

#pragma once
 
#include "./frame.hpp"
#include "./time_index.hpp"
 
#include "../math/matrix.hpp"
 
#include <algorithm>
#include <cstddef>
#include <iterator>
#include <optional>
#include <stdexcept>
#include <string_view>
#include <utility>
#include <vector>
 
namespace algotradelib {
namespace analytics {

enum class Alignment {
  UNION_UNOBSERVED,
  INTERSECTION,
  FORWARD_FILL,
};

inline constexpr std::string_view alignment_name(Alignment alignment) noexcept {
  switch (alignment) {
    case Alignment::UNION_UNOBSERVED:
      return "union_unobserved";
    case Alignment::INTERSECTION:
      return "intersection";
    case Alignment::FORWARD_FILL:
      return "forward_fill";
  }
  return "unknown";
}

class Panel {
public:
  Panel() = default;

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

  std::size_t columns() const noexcept { return instruments_.size(); }

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

  const std::vector<InstrumentId>& instruments() const noexcept { return instruments_; }

  BarField field() const noexcept { return field_; }

  Alignment alignment() const noexcept { return alignment_; }

  std::optional<std::size_t> find(const InstrumentId& instrument) const {
    for (std::size_t column = 0; column < instruments_.size(); ++column) {
      if (instruments_[column] == instrument) {
        return column;
      }
    }
    return std::nullopt;
  }

  math::SeriesView column(std::size_t position) const {
    if (position >= instruments_.size()) {
      throw std::out_of_range("panel column is past the end");
    }
    return values_.col(static_cast<math::Index>(position));
  }

  Scalar at(std::size_t row, std::size_t column) const {
    if (row >= rows() || column >= columns()) {
      throw std::out_of_range("panel position is past the end");
    }
    return values_(static_cast<math::Index>(row), static_cast<math::Index>(column));
  }

  math::MatrixView values() const { return values_; }

  static Panel from_bars(
    const std::vector<BarSeries>& series,
    BarField field,
    Alignment alignment
  ) {
    Panel panel;
    panel.field_ = field;
    panel.alignment_ = alignment;
    if (series.empty()) {
      return panel;
    }
 
    std::vector<SeriesFrame> frames;
    frames.reserve(series.size());
    for (const auto& one : series) {
      frames.push_back(analytics::from_bars(one));
      panel.instruments_.push_back(one.instrument_);
    }
 
    auto stamps = alignment == Alignment::INTERSECTION ?
      shared_instants(frames) :
      combined_instants(frames);
    panel.index_ = TimeIndex(std::move(stamps));
 
    panel.values_ = math::Matrix::Constant(
      static_cast<math::Index>(panel.index_.size()),
      static_cast<math::Index>(frames.size()),
      missing()
    );
 
    for (std::size_t column = 0; column < frames.size(); ++column) {
      fill_column(panel, column, frames[column], field, alignment);
    }
    return panel;
  }
 
private:
  // Every instant any frame reported, ascending and deduplicated.
  static std::vector<TimeIndex::Instant> combined_instants(const std::vector<SeriesFrame>& frames) {
    std::size_t total = 0;
    for (const auto& frame : frames) {
      total += frame.time().size();
    }
    std::vector<TimeIndex::Instant> all;
    all.reserve(total);
    for (const auto& frame : frames) {
      const auto& stamps = frame.time().stamps();
      all.insert(all.end(), stamps.begin(), stamps.end());
    }
    std::sort(all.begin(), all.end());
    all.erase(std::unique(all.begin(), all.end()), all.end());
    return all;
  }
 
  // Only the instants every frame reported.
  static std::vector<TimeIndex::Instant> shared_instants(const std::vector<SeriesFrame>& frames) {
    std::vector<TimeIndex::Instant> shared = frames.front().time().stamps();
    std::vector<TimeIndex::Instant> narrowed;
    narrowed.reserve(shared.size());
    for (std::size_t position = 1; position < frames.size(); ++position) {
      const auto& other = frames[position].time().stamps();
      narrowed.clear();
      std::set_intersection(
        shared.begin(), shared.end(), other.begin(), other.end(), std::back_inserter(narrowed)
      );
      shared.swap(narrowed);
    }
    return shared;
  }
 
  // Writes one instrument's column under the chosen alignment, walking both ascending indices
  // together in one pass.
  static void fill_column(
    Panel& panel,
    std::size_t column,
    const SeriesFrame& frame,
    BarField field,
    Alignment alignment
  ) {
    const auto& target = panel.index_.stamps();
    const auto& source = frame.time().stamps();
    if (target.empty() || source.empty()) {
      return;
    }
    const auto series = frame.column(field);
    const bool carry = alignment == Alignment::FORWARD_FILL;
 
    std::size_t at = 0;
    for (std::size_t row = 0; row < target.size(); ++row) {
      const auto& when = target[row];
      while (at + 1 < source.size() && !(when < source[at + 1])) {
        ++at;
      }
      // `source[at]` is now the latest instant at or before `when`, unless the source
      // begins after it — in which case there is nothing observed yet, and carrying
      // backwards would be inventing a price the instrument never had.
      if (when < source[at]) {
        continue;
      }
      if (!carry && source[at] != when) {
        continue;
      }
      panel.values_(static_cast<math::Index>(row), static_cast<math::Index>(column)) =
        series(static_cast<math::Index>(at));
    }
  }
 
  std::vector<InstrumentId> instruments_;
  TimeIndex index_;
  math::Matrix values_;
  BarField field_{BarField::CLOSE};
  Alignment alignment_{Alignment::UNION_UNOBSERVED};
};
 
} // namespace analytics
} // namespace algotradelib