conversion.hpp

Go to the documentation of this file.

#pragma once
 
#include "./numeric.hpp"
 
#include <algotradelib/core>
 
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <limits>
#include <optional>
 
namespace algotradelib {
namespace analytics {


inline Scalar to_scalar(const Decimal64& value) {
  // Every power of ten up to 10^22 is a double, so this product is exact over that range.
  Scalar divisor{1};
  for (std::uint8_t step = 0; step < value.scale(); ++step) {
    divisor *= Scalar(10);
  }
  return static_cast<Scalar>(value.coefficient()) / divisor;
}

inline std::optional<Decimal64> to_decimal(Scalar value, std::uint8_t scale) {
  if (!std::isfinite(value)) {
    return std::nullopt;
  }
  Scalar scaled = value;
  for (std::uint8_t step = 0; step < scale; ++step) {
    scaled *= Scalar(10);
  }
  // `std::round` is half away from zero by definition. Adding 0.5 first rounds the sum: 0.49999999999999994
  // became 1, and an odd integer near 2^52 moved up by one.
  const Scalar rounded = std::round(scaled);
  // `INT64_MAX` is not a double: it converts to 2^63, which does not fit, so that bound is exclusive.
  if (
    rounded >= static_cast<Scalar>(std::numeric_limits<std::int64_t>::max()) ||
    rounded < static_cast<Scalar>(std::numeric_limits<std::int64_t>::min())
  ) {
    return std::nullopt;
  }
  return Decimal64(static_cast<std::int64_t>(rounded), scale);
}

inline std::optional<Decimal64> round_scalar_to_tick(
  Scalar value,
  const PriceRule& rule,
  OrderSide side,
  std::uint8_t scale = 0
) {
  const auto nearest = to_decimal(value, scale);
  if (!nearest) {
    return std::nullopt;
  }
  // `to_decimal` rounds to nearest, which can cross the computed value against the order. Step one
  // unit back when it did by more than floating-point noise (a few units in the last place).
  Scalar scaled = value;
  for (std::uint8_t step = 0; step < scale; ++step) {
    scaled *= Scalar(10);
  }
  // Each of the `scale` multiplications here can add half a unit in the last place, and a value that
  // came through `to_scalar` within its bounds carries one more half unit from its division. The
  // tolerance is wider than that sum: it also absorbs values computed from such inputs.
  const Scalar noise = std::max(
    Scalar(1e-9),
    std::abs(scaled) * Scalar(2 * scale + 4) * std::numeric_limits<Scalar>::epsilon()
  );
  const auto coefficient = nearest->coefficient();
  const Scalar crossed = static_cast<Scalar>(coefficient) - scaled;
  auto exact = *nearest;
  if (side == OrderSide::BUY && crossed > noise) {
    if (coefficient == std::numeric_limits<std::int64_t>::min()) {
      return std::nullopt;
    }
    exact = Decimal64(coefficient - 1, scale);
  } else if (side == OrderSide::SELL && -crossed > noise) {
    if (coefficient == std::numeric_limits<std::int64_t>::max()) {
      return std::nullopt;
    }
    exact = Decimal64(coefficient + 1, scale);
  }
  return rule.round_to_tick(exact, side);
}
 
} // namespace analytics
} // namespace algotradelib