scalar.hpp

#pragma once
 
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <limits>
 
namespace algotradelib {
namespace math {

using Scalar = double;

inline Scalar missing() { return std::numeric_limits<Scalar>::quiet_NaN(); }

inline bool observed(Scalar value) { return !std::isnan(value); }

inline Scalar undefined() {
  // A quiet NaN with a distinguishing payload: exponent all ones, quiet bit set, and a
  // payload no library produces by accident.
  static_assert(sizeof(Scalar) == sizeof(std::uint64_t), "undefined() assumes a 64-bit Scalar");
  const std::uint64_t bits = 0x7FF80000000F1A7EULL;
  Scalar value;
  std::memcpy(&value, &bits, sizeof(value));
  return value;
}

inline bool is_undefined(Scalar value) {
  if (!std::isnan(value)) {
    return false;
  }
  std::uint64_t bits{0};
  std::memcpy(&bits, &value, sizeof(bits));
  // Compares the payload only, masking off the sign, the exponent, and the quiet bit, so a
  // negated or re-quieted copy still reads as the same marker.
  return (bits & 0x0007FFFFFFFFFFFFULL) == 0x000F1A7EULL;
}
 
} // namespace math
} // namespace algotradelib