signal.hpp

Go to the documentation of this file.

#pragma once
 
#include <algotradelib/analytics>
 
#include <cstddef>
#include <optional>
#include <stdexcept>
 
namespace algotradelib {
namespace strategy {
namespace vanilla {


struct Crossing {
  math::Scalar previous_{0};
  math::Scalar current_{0};

  bool rose_above(const Crossing& other) const {
    return previous_ <= other.previous_ && other.current_ < current_;
  }

  bool fell_below(const Crossing& other) const {
    return other.previous_ <= previous_ && current_ < other.current_;
  }
};

inline std::optional<Crossing> last_two(const math::Vector& line) {
  if (line.size() < 2) {
    return std::nullopt;
  }
  const Crossing pair{line[line.size() - 2], line[line.size() - 1]};
  if (!math::observed(pair.previous_) || !math::observed(pair.current_)) {
    return std::nullopt;
  }
  return pair;
}

inline math::Vector adjusted_ema(math::SeriesView values, math::Scalar alpha, std::size_t min_observed = 1) {
  if (!(math::Scalar{0} < alpha && alpha <= math::Scalar{1})) {
    throw std::invalid_argument("an ema smoothing factor must be in (0, 1]");
  }
  if (min_observed == 0) {
    throw std::invalid_argument("ema must require at least one observation");
  }
  math::Vector result = math::unobserved(static_cast<std::size_t>(values.size()));
  const math::Scalar keep = math::Scalar{1} - alpha;
  math::Scalar mean{0};
  math::Scalar total{0};
  std::size_t count = 0;
  for (math::Index row = 0; row < values.size(); ++row) {
    const math::Scalar value = values[row];
    if (!math::observed(value)) {
      continue;
    }
    total = math::Scalar{1} + keep * total;
    // `alpha = 1` keeps only the newest value, exactly: `mean + (value - mean)` need not round back to it.
    mean = count == 0 || keep == math::Scalar{0} ? value : mean + (value - mean) / total;
    ++count;
    if (count >= min_observed) {
      result[row] = mean;
    }
  }
  return result;
}

inline math::Vector exponential_line(math::SeriesView closes, std::size_t span) {
  const auto alpha = analytics::alpha_from_span(span);
  std::size_t observations = 0;
  for (math::Index row = 0; row < closes.size(); ++row) {
    observations += math::observed(closes[row]) ? 1 : 0;
  }
  if (observations < 3 * span) {
    return adjusted_ema(closes, alpha, span);
  }
  return analytics::ema(closes, alpha, span);
}

inline std::optional<math::SeriesView> trailing(math::SeriesView values, std::size_t count) {
  const auto needed = static_cast<math::Index>(count) + 1;
  if (values.size() < needed) {
    return std::nullopt;
  }
  return values.tail(needed);
}
 
} // namespace vanilla
} // namespace strategy
} // namespace algotradelib