native.numerics.ccm

// SPDX-FileCopyrightText: 2024 Edward Kmett <ekmett@gmail.com>
// SPDX-License-Identifier: BSD-2-Clause OR Apache-2.0
module;
#include "native/isa_import.h"
#include <bit>
#include <cmath>
#include <compare>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <type_traits>
#include <utility>
#include "native/attributes.h"
#include "native/simd/common.h"
 
#if !defined(NATIVE_HAS_NATIVE_FP16) || !defined(NATIVE_HAS_NATIVE_BF16)
#error Configure native half capabilities before compiling native.numerics.
#endif
 
export module native.numerics;
export import native.types;
 
export namespace native {

struct fp16 {
private:
  // Round binary32 to binary16, ties to even, independently of the FP controls.
  // Raw native-half projections below remain representation copies.
  static constexpr uint16_t encode(float value) noexcept {
    auto word = std::bit_cast<uint32_t>(value);
    auto sign = (word >> 16) & 0x8000u;
    auto a = word & 0x7fffffffu;
    if (a >= 0x7f800000u)
      return uint16_t(sign | 0x7c00u | (a == 0x7f800000u ? 0u : 0x200u | ((a >> 13) & 0x3ffu)));
    if (a >= 0x47800000u) return uint16_t(sign | 0x7c00u);
    if (a >= 0x38800000u)
      return uint16_t(sign | (((a + 0xfffu + ((a >> 13) & 1u)) >> 13) - 0x1c000u));
    if (a < 0x33000000u) return uint16_t(sign);
    auto shift = 126u - (a >> 23);
    auto significand = (a & 0x7fffffu) | 0x800000u;
    auto result = significand >> shift;
    auto remainder = significand & ((1u << shift) - 1u);
    auto half = 1u << (shift - 1u);
    result += remainder > half || (remainder == half && (result & 1u));
    return uint16_t(sign | result);
  }
  static constexpr float decode(uint16_t word) noexcept {
    auto sign = uint32_t(word & 0x8000u) << 16;
    auto exponent = (word >> 10) & 31u;
    auto fraction = uint32_t(word & 0x3ffu);
    uint32_t result;
    if (exponent == 0) {
      if (fraction == 0) return std::bit_cast<float>(sign);
      auto shift = unsigned(std::countl_zero(fraction)) - 21u;
      result = ((113u - shift) << 23) | (((fraction << shift) & 0x3ffu) << 13);
    } else if (exponent == 31) {
      result = 0x7f800000u | (fraction << 13) | (fraction ? 0x400000u : 0u);
    } else result = ((exponent + 112u) << 23) | (fraction << 13);
    return std::bit_cast<float>(sign | result);
  }
public:
#if NATIVE_HAS_NATIVE_FP16
  using underlying_type = _Float16;
#else
  using underlying_type = uint16_t;
#endif

  underlying_type content;

  native_inline native_artificial
  constexpr fp16() noexcept = default;

  native_inline native_artificial
  constexpr fp16(native_noescape fp16 const &) noexcept = default;

  native_inline native_artificial
  constexpr fp16(native_noescape fp16 &&) noexcept = default;

  native_inline native_artificial
  constexpr fp16(float value) noexcept : content(std::bit_cast<underlying_type>(encode(value))) {}
 
#if NATIVE_HAS_NATIVE_FP16
  native_inline native_artificial
  constexpr fp16(_Float16 content) noexcept : content(content) {}
#endif

  native_nodiscard native_inline native_artificial
  constexpr operator float (this fp16 self) noexcept { return decode(self.to_bits()); }
 
#if NATIVE_HAS_NATIVE_FP16
  native_nodiscard native_inline native_artificial
  constexpr operator _Float16 (this fp16 self) noexcept { return self.content; }
#endif

  native_reinitializes native_inline native_artificial
  constexpr fp16 & operator = (native_noescape fp16 const &) noexcept
  native_lifetimebound = default;

  native_reinitializes native_inline native_artificial
  constexpr fp16 & operator = (native_noescape fp16 &&) noexcept
  native_lifetimebound = default;

  native_nodiscard native_inline native_artificial native_const
  friend constexpr bool operator == (fp16 x, fp16 y) noexcept {
    return static_cast<float>(x) == static_cast<float>(y);
  }

  native_nodiscard native_inline native_artificial native_const
  friend constexpr bool operator != (fp16 x, fp16 y) noexcept {
    return static_cast<float>(x) != static_cast<float>(y);
  }

  native_nodiscard native_inline native_artificial native_const
  friend constexpr std::partial_ordering operator <=> (fp16 x, fp16 y) noexcept {
    return static_cast<float>(x) <=> static_cast<float>(y);
  }

  native_nodiscard native_inline native_artificial native_const
  friend constexpr bool operator < (fp16 x, fp16 y) noexcept {
    return static_cast<float>(x) < static_cast<float>(y);
  }

  native_nodiscard native_inline native_artificial native_const
  friend constexpr bool operator <= (fp16 x, fp16 y) noexcept {
    return static_cast<float>(x) <= static_cast<float>(y);
  }

  native_nodiscard native_inline native_artificial native_const
  friend constexpr bool operator > (fp16 x, fp16 y) noexcept {
    return static_cast<float>(x) > static_cast<float>(y);
  }

  native_nodiscard native_inline native_artificial native_const
  friend constexpr bool operator >= (fp16 x, fp16 y) noexcept {
    return static_cast<float>(x) >= static_cast<float>(y);
  }

  native_inline native_artificial
  friend constexpr void swap(
    native_noescape fp16 & x,
    native_noescape fp16 & y
  ) noexcept {
    using std::swap;
    swap(x.content,y.content);
  }

  native_inline native_artificial native_const
  static constexpr fp16 from_bits(uint16_t data) noexcept {
    return std::bit_cast<fp16>(data);
  }

  native_nodiscard native_inline native_const
  constexpr uint16_t to_bits(this fp16 self) noexcept {
    return std::bit_cast<uint16_t>(self.content);
  }
 
};

template<> struct mask_traits<fp16> { using type = bool; };

native_nodiscard native_inline native_artificial native_const
constexpr fp16 operator""_fp16(long double v) noexcept {
  return fp16(static_cast<float>(v));
}
 
} // namespace native

export namespace std {
  using ::std::numeric_limits;
  native_nodiscard native_artificial native_inline native_const
  constexpr bool isnan(::native::fp16 x) noexcept {
    // Sign doesn't matter, frac not zero (infinity)
    return (x.to_bits() & 0x7FFF) > 0x7c00;
  }

  template <>
  class numeric_limits<::native::fp16> {
  public:
    static constexpr bool is_specialized = true;
    native_inline native_artificial native_const
    static constexpr ::native::fp16 min() noexcept {
      return ::native::fp16::from_bits(0x0400);
    }

    native_inline native_artificial native_const
    static constexpr ::native::fp16 max() noexcept {
      return ::native::fp16::from_bits(0x7BFF);
    }

    native_inline native_artificial native_const
    static constexpr ::native::fp16 lowest() noexcept {
      return ::native::fp16::from_bits(0xFBFF);
    }
    static constexpr int digits = 11;
    static constexpr int digits10 = 3;
    static constexpr int max_digits10 = 5;
    static constexpr bool is_signed = true;
    static constexpr bool is_integer = false;
    static constexpr bool is_exact = false;
    static constexpr int radix = 2;
    native_inline native_artificial native_const
    static constexpr ::native::fp16 epsilon() noexcept {
      return ::native::fp16::from_bits(0x1400);
    }

    native_inline native_artificial native_const
    static constexpr ::native::fp16 round_error() noexcept {
      return ::native::fp16::from_bits(0x3800);
    }
    static constexpr int min_exponent = -13;
    static constexpr int min_exponent10 = -4;
    static constexpr int max_exponent = 16;
    static constexpr int max_exponent10 = 4;
    static constexpr bool has_infinity = true;
    static constexpr bool has_quiet_NaN = true;
    static constexpr bool has_signaling_NaN = true;
    [[deprecated("std::float_denorm_style is deprecated since C++23")]]
    static constexpr float_denorm_style has_denorm = denorm_present;
    [[deprecated("numeric_limits::has_denorm_loss is deprecated since C++23")]]
    static constexpr bool has_denorm_loss = false;
    native_inline native_artificial native_const
    static constexpr ::native::fp16 infinity() noexcept {
      return ::native::fp16::from_bits(0x7C00);
    }

    native_inline native_artificial native_const
    static constexpr ::native::fp16 quiet_NaN() noexcept {
      return ::native::fp16::from_bits(0x7FFF);
    }

    native_inline native_artificial native_const
    static constexpr ::native::fp16 signaling_NaN() noexcept {
      return ::native::fp16::from_bits(0x7DFF);
    }

    native_inline native_artificial native_const
    static constexpr ::native::fp16 denorm_min() noexcept {
      return ::native::fp16::from_bits(1);
    }
    static constexpr bool is_iec559 = false;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo = false;
    static constexpr bool traps = false;
    static constexpr bool tinyness_before = false;
    static constexpr float_round_style round_style = round_to_nearest;
  };
 
 
 
} // namespace std
 
 
export namespace native {

struct bf16 {
private:
  // Conversion is integer RNE, including subnormals, under every FP environment.
  static constexpr uint16_t encode(float value) noexcept {
    auto word = std::bit_cast<uint32_t>(value);
    if ((word & 0x7fffffffu) > 0x7f800000u)
      return uint16_t((word >> 16) | 0x40u);
    return uint16_t((word + 0x7fffu + ((word >> 16) & 1u)) >> 16);
  }
  static constexpr float decode(uint16_t word) noexcept {
    auto result = uint32_t(word) << 16;
    if ((word & 0x7fffu) > 0x7f80u) result |= 0x400000u;
    return std::bit_cast<float>(result);
  }
public:
#if NATIVE_HAS_NATIVE_BF16
  using underlying_type = __bf16;
#else
  using underlying_type = uint16_t;
#endif

  underlying_type content;

  native_inline native_artificial constexpr
  bf16() noexcept = default;

  native_inline native_artificial constexpr
  bf16(float f) noexcept : content(std::bit_cast<underlying_type>(encode(f))) {}
 
#if NATIVE_HAS_NATIVE_BF16
  native_inline native_artificial constexpr
  bf16(__bf16 f) noexcept : content(f) {}
#endif

  native_inline native_artificial constexpr
  bf16(native_noescape bf16 const &) noexcept = default;

  native_inline native_artificial constexpr
  bf16(native_noescape bf16 &&) noexcept = default;
 
#if NATIVE_HAS_NATIVE_BF16
  native_nodiscard native_inline native_artificial native_const constexpr
  operator __bf16 (this bf16 self) noexcept { return self.content; }
#endif

  native_nodiscard native_inline native_artificial native_const constexpr
  operator float (this bf16 self) noexcept { return decode(self.to_bits()); }

  native_reinitializes native_inline native_artificial constexpr
  bf16 & operator = (native_noescape bf16 const &) noexcept
  native_lifetimebound = default;

  native_reinitializes native_inline native_artificial constexpr
  bf16 & operator = (native_noescape bf16 &&) noexcept
  native_lifetimebound = default;

  native_nodiscard native_inline native_artificial native_const
  friend constexpr bool operator == (bf16 x, bf16 y) noexcept {
    return static_cast<float>(x) == static_cast<float>(y);
  }

  native_nodiscard native_inline native_artificial native_const
  friend constexpr std::partial_ordering operator <=> (bf16 x, bf16 y) noexcept {
    return static_cast<float>(x) <=> static_cast<float>(y);
  }

  native_nodiscard native_inline native_artificial native_const
  friend constexpr bool operator != (bf16 x, bf16 y) noexcept {
    return static_cast<float>(x) != static_cast<float>(y);
  }

  native_nodiscard native_inline native_artificial native_const
  friend constexpr bool operator < (bf16 x, bf16 y) noexcept {
    return static_cast<float>(x) < static_cast<float>(y);
  }

  native_nodiscard native_inline native_artificial native_const
  friend constexpr bool operator > (bf16 x, bf16 y) noexcept {
    return static_cast<float>(x) > static_cast<float>(y);
  }

  native_nodiscard native_inline native_artificial native_const
  friend constexpr bool operator <= (bf16 x, bf16 y) noexcept {
    return static_cast<float>(x) <= static_cast<float>(y);
  }

  native_nodiscard native_inline native_artificial native_const
  friend constexpr bool operator >= (bf16 x, bf16 y) noexcept {
    return static_cast<float>(x) >= static_cast<float>(y);
  }

  native_inline native_artificial
  friend constexpr void swap(
    native_noescape bf16 & x,
    native_noescape bf16 & y
  ) noexcept {
    using std::swap;
    swap(x.content,y.content);
  }

  native_nodiscard native_inline native_artificial native_const
  static constexpr bf16 from_bits(uint16_t data) noexcept {
    return std::bit_cast<bf16>(data);
  }

  native_nodiscard native_inline native_const
  constexpr uint16_t to_bits(this bf16 self) noexcept {
    return std::bit_cast<uint16_t>(self.content);
  }
};

template<> struct mask_traits<bf16> { using type = bool; };

native_nodiscard native_inline native_artificial
constexpr bf16 operator""_bf16(long double v) noexcept {
  return bf16(static_cast<float>(v));
}

native_nodiscard native_inline native_artificial native_const
constexpr bf16 fast_to_bf16(float f) noexcept {
  if consteval {
    return f;
  } else {
    return std::bit_cast<bf16>(static_cast<uint16_t>(std::bit_cast<uint32_t>(f)>>16));
  }
}

native_nodiscard native_inline native_artificial native_const
constexpr bf16 fast_to_bf16(bf16 f) noexcept {
  return f;
}
 
} // namespace native
 
export namespace std {
  using ::std::numeric_limits;
  native_nodiscard native_artificial native_inline native_const
  constexpr bool isnan(::native::bf16 x) noexcept {
    // Exponent maxed out and fraction non-zero indicates NaN
    return (x.to_bits() & 0x7FFF) > 0x7F80;
  }

  template <> class numeric_limits<::native::bf16> {
  public:
    static constexpr bool is_specialized = true;
    native_nodiscard native_inline native_artificial native_const
    static constexpr ::native::bf16 min() noexcept {
      return ::native::bf16::from_bits(0x0080);
    }

    native_nodiscard native_inline native_artificial native_const
    static constexpr ::native::bf16 max() noexcept {
      return ::native::bf16::from_bits(0x7F7F);
    }

    native_nodiscard native_inline native_artificial native_const
    static constexpr ::native::bf16 lowest() noexcept {
      return ::native::bf16::from_bits(0xFF7F);
    }
    static constexpr int digits = 8;
    static constexpr int digits10 = 2;
    static constexpr int max_digits10 = 4;
    static constexpr bool is_signed = true;
    static constexpr bool is_integer = false;
    static constexpr bool is_exact = false;
    static constexpr int radix = 2;
    native_nodiscard native_inline native_artificial native_const
    static constexpr ::native::bf16 epsilon() noexcept {
      return ::native::bf16::from_bits(0x3C00);
    }

    native_nodiscard native_inline native_artificial native_const
    static constexpr ::native::bf16 round_error() noexcept {
      return ::native::bf16::from_bits(0x3F00);
    }
    static constexpr int min_exponent = -125;
    static constexpr int min_exponent10 = -37;
    static constexpr int max_exponent = 128;
    static constexpr int max_exponent10 = 38;
    static constexpr bool has_infinity = true;
    static constexpr bool has_quiet_NaN = true;
    static constexpr bool has_signaling_NaN = true;
    [[deprecated("std::float_denorm_style is deprecated since C++23")]]
    static constexpr float_denorm_style has_denorm = denorm_present;
    [[deprecated("numeric_limits::has_denorm_loss is deprecated since C++23")]]
    static constexpr bool has_denorm_loss = false;
    native_nodiscard native_inline native_artificial native_const
    static constexpr ::native::bf16 infinity() noexcept {
      return ::native::bf16::from_bits(0x7F80);
    }

    native_nodiscard native_inline native_artificial native_const
    static constexpr ::native::bf16 quiet_NaN() noexcept {
      return ::native::bf16::from_bits(0x7FC0);
    }

    native_nodiscard native_inline native_artificial native_const
    static constexpr ::native::bf16 signaling_NaN() noexcept {
      return ::native::bf16::from_bits(0x7F81);
    }

    native_nodiscard native_inline native_artificial native_const
    static constexpr ::native::bf16 denorm_min() noexcept {
      return ::native::bf16::from_bits(1);
    }
    static constexpr bool is_iec559 = false;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo = false;
    static constexpr bool traps = false;
    static constexpr bool tinyness_before = false;
    static constexpr float_round_style round_style = round_to_nearest;
  };
 
 
 
} // namespace std
 
 
namespace native { using std::isnan; }
 
export namespace native {
  using ::native::imm_t;
  using ::native::imm;

template <auto N, auto ... candidates>
concept one_of = ((N==candidates) || ... || false);

template <auto N, auto ... candidates>
concept not_one_of = (!one_of<N,candidates...>);

template <std::size_t N> struct integer_traits {};
template <> struct integer_traits<8>  { using signed_t = int8_t;  using unsigned_t = uint8_t; };
template <> struct integer_traits<16> { using signed_t = int16_t; using unsigned_t = uint16_t; };
template <> struct integer_traits<32> { using signed_t = int32_t; using unsigned_t = uint32_t; };
template <> struct integer_traits<64> { using signed_t = int64_t; using unsigned_t = uint64_t; };

template <typename T>
requires one_of<sizeof(T),1,2,4,8>
using int_t = typename integer_traits<sizeof(T)*8>::signed_t;

template <typename T>
requires one_of<sizeof(T),1,2,4,8>
using uint_t = typename integer_traits<sizeof(T)*8>::unsigned_t;
 
// The shared immediate tag is defined by native/common.h.

template <typename T>
native_nodiscard native_inline
constexpr bool cmp_unord(T a, T b) noexcept(noexcept(isnan(a) || isnan(b))) {
  return isnan(a) || isnan(b);
}

 


template <typename T>
native_nodiscard native_inline
constexpr bool cmp_ord(T a, T b) noexcept(noexcept(!isnan(a) && !isnan(b))) {
  return !isnan(a) && !isnan(b);
}

 


template <one_of_t<float, double> T>
native_nodiscard native_inline native_pure
constexpr T scalef(T x, T y) noexcept {
  if consteval {
    using U = uint_t<T>;
    constexpr int fraction_bits = std::numeric_limits<T>::digits - 1;
    constexpr int bias = std::numeric_limits<T>::max_exponent - 1;
    constexpr U hidden = U(1) << fraction_bits;
    constexpr U sign_mask = U(1) << (sizeof(T) * 8 - 1);
    constexpr U exponent_mask = U(2 * bias + 1) << fraction_bits;
    auto const word = std::bit_cast<U>(x);
    auto const sign = word & sign_mask;
    auto const field = (word & exponent_mask) >> fraction_bits;
    auto significand = word & (hidden - 1);
    if (field == U(2 * bias + 1) || (field == 0 && significand == 0)) return x;
    int const scale = static_cast<int>(y);
 
    // Probe behavior, not just a library version: some constexpr math facilities
    // reject range errors during constant evaluation, including signed underflow.
    if constexpr (requires {
      typename std::enable_if_t<
        std::scalbn(T(1), 1 - bias) == std::numeric_limits<T>::min() &&
        std::scalbn(T(1), 1 - bias - fraction_bits) == std::numeric_limits<T>::denorm_min() &&
        std::scalbn(T(-1), bias + 1) == -std::numeric_limits<T>::infinity() &&
        std::bit_cast<U>(std::scalbn(T(-1), -bias - fraction_bits)) == sign_mask &&
        std::scalbn(T(1), std::numeric_limits<int>::min()) == T(0) &&
        std::scalbn(T(1), std::numeric_limits<int>::max()) == std::numeric_limits<T>::infinity()>;
    }) {
      return std::scalbn(x, scale);
    } else {
      // Normalize even the smallest subnormal before changing its exponent.
      std::int64_t exponent = field ? std::int64_t(field) - bias : 1 - bias;
      if (field) significand |= hidden;
      else while (significand < hidden) { significand <<= 1; --exponent; }
      exponent += scale; // The full int exponent cannot overflow this wider sum.
      if (exponent > bias) return std::bit_cast<T>(sign | exponent_mask);
      if (exponent >= 1 - bias) {
        return std::bit_cast<T>(sign | (U(exponent + bias) << fraction_bits) |
          (significand & (hidden - 1)));
      }
      auto const shift = (1 - bias) - exponent;
      if (shift > fraction_bits + 1) return std::bit_cast<T>(sign);
      U const remainder = significand & ((U(1) << shift) - 1);
      U const halfway = U(1) << (shift - 1);
      U rounded = significand >> shift;
      rounded += remainder > halfway || (remainder == halfway && (rounded & 1));
      // Rounding can carry into the minimum normal; its encoding is hidden.
      return std::bit_cast<T>(sign | rounded);
    }
  } else {
    return std::scalbn(x, static_cast<int>(y));
  }
}

enum class native_nodiscard CMPINT : std::size_t {
  EQ    = 0x0uz 
, LT    = 0x1uz 
, LE    = 0x2uz 
, FALSE = 0x3uz 
, NE    = 0x4uz 
, NLT   = 0x5uz 
, NLE   = 0x6uz 
, TRUE  = 0x7uz 
};

template <CMPINT imm8, typename T>
requires (one_of_t<T, uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t, uint64_t, int64_t> && (std::size_t(imm8) < 8uz))
native_nodiscard native_inline native_const
constexpr bool cmpint(T a, T b) noexcept {
  using enum CMPINT;
  if      constexpr (imm8 == TRUE)  return -1;
  else if constexpr (imm8 == FALSE) return 0;
  else if constexpr (imm8 == LT)    return a < b;
  else if constexpr (imm8 == NLT)   return a >= b;
  else if constexpr (imm8 == LE)    return a <= b;
  else if constexpr (imm8 == NLE)   return a > b;
  else if constexpr (imm8 == EQ)    return a == b;
  else if constexpr (imm8 == NE)    return a != b;
  else static_assert(false);
}

inline constexpr std::size_t max_fp_comparison_predicate = [] {
#ifdef __AVX512F__
  return 32uz;
#else
  return 8uz;
#endif
}();

enum class native_nodiscard CMP : std::size_t {
  EQ_OQ     = 0x00uz  
, LT_OS     = 0x01uz  
, LE_OS     = 0x02uz  
, UNORD_Q   = 0x03uz  
, NEQ_UQ    = 0x04uz  
, NLT_US    = 0x05uz  
, NLE_US    = 0x06uz  
, ORD_Q     = 0x07uz  
, EQ_UQ     = 0x08uz  
, NGE_US    = 0x09uz  
, NGT_US    = 0x0Auz  
, FALSE_OQ  = 0x0Buz  
, NEQ_OQ    = 0x0Cuz  
, GE_OS     = 0x0Duz  
, GT_OS     = 0x0Euz  
, TRUE_UQ   = 0x0Fuz  
, EQ_OS     = 0x10uz  
, LT_OQ     = 0x11uz  
, LE_OQ     = 0x12uz  
, UNORD_S   = 0x13uz  
, NEQ_US    = 0x14uz  
, NLT_UQ    = 0x15uz  
, NLE_UQ    = 0x16uz  
, ORD_S     = 0x17uz  
, EQ_US     = 0x18uz  
, NGE_UQ    = 0x19uz  
, NGT_UQ    = 0x1Auz  
, FALSE_OS  = 0x1Buz  
, NEQ_OS    = 0x1Cuz  
, GE_OQ     = 0x1Duz  
, GT_OQ     = 0x1Euz  
, TRUE_US   = 0x1Fuz  
};

template <CMP imm8, typename T>
requires (one_of_t<T, float, double> && (std::size_t(imm8) < 32uz))
native_nodiscard native_inline native_pure
constexpr bool cmp(T a, T b) noexcept {
  using enum CMP;
  if      constexpr (imm8 == EQ_OQ)    return cmp_ord(a, b) && (a == b);
  else if constexpr (imm8 == LT_OS)    return cmp_ord(a, b) && (a < b);
  else if constexpr (imm8 == LE_OS)    return cmp_ord(a, b) && (a <= b);
  else if constexpr (imm8 == UNORD_Q)  return cmp_unord(a, b);
  else if constexpr (imm8 == NEQ_UQ)   return cmp_unord(a, b) || (a != b);
  else if constexpr (imm8 == NLT_US)   return cmp_unord(a, b) || !(a < b);
  else if constexpr (imm8 == NLE_US)   return cmp_unord(a, b) || !(a <= b);
  else if constexpr (imm8 == ORD_Q)    return cmp_ord(a, b);
  else if constexpr (imm8 == EQ_UQ)    return cmp_unord(a, b) || (a == b);
  else if constexpr (imm8 == NGE_US)   return cmp_unord(a, b) || !(a >= b);
  else if constexpr (imm8 == NGT_US)   return cmp_unord(a, b) || !(a > b);
  else if constexpr (imm8 == FALSE_OQ) return 0;
  else if constexpr (imm8 == NEQ_OQ)   return cmp_ord(a, b) && (a != b);
  else if constexpr (imm8 == GE_OS)    return cmp_ord(a, b) && (a >= b);
  else if constexpr (imm8 == GT_OS)    return cmp_ord(a, b) && (a > b);
  else if constexpr (imm8 == TRUE_UQ)  return -1;
  else if constexpr (imm8 == EQ_OS)    return cmp_ord(a, b) && (a == b);
  else if constexpr (imm8 == LT_OQ)    return cmp_ord(a, b) && (a < b);
  else if constexpr (imm8 == LE_OQ)    return cmp_ord(a, b) && (a <= b);
  else if constexpr (imm8 == UNORD_S)  return cmp_unord(a, b);
  else if constexpr (imm8 == NEQ_US)   return cmp_unord(a, b) || (a != b);
  else if constexpr (imm8 == NLT_UQ)   return cmp_unord(a, b) || !(a < b);
  else if constexpr (imm8 == NLE_UQ)   return cmp_unord(a, b) || !(a <= b);
  else if constexpr (imm8 == ORD_S)    return cmp_ord(a, b);
  else if constexpr (imm8 == EQ_US)    return cmp_unord(a, b) || (a == b);
  else if constexpr (imm8 == NGE_UQ)   return cmp_unord(a, b) || !(a >= b);
  else if constexpr (imm8 == NGT_UQ)   return cmp_unord(a, b) || !(a > b);
  else if constexpr (imm8 == FALSE_OS) return 0;
  else if constexpr (imm8 == NEQ_OS)   return cmp_ord(a, b) && (a != b);
  else if constexpr (imm8 == GE_OQ)    return cmp_ord(a, b) && (a >= b);
  else if constexpr (imm8 == GT_OQ)    return cmp_ord(a, b) && (a > b);
  else if constexpr (imm8 == TRUE_US)  return -1;
  else static_assert(false);
}
 
 
 

}
 
 
namespace native {
  template bool cmp_unord(float, float);
  template bool cmp_unord(double, double);
  template bool cmp_ord(float, float);
  template bool cmp_ord(double, double);
  template float scalef(float, float) noexcept;
  template double scalef(double, double) noexcept;
}