float.h

Go to the documentation of this file.

#pragma once
#include "ftz/config.h"
#include "native/attributes.h"
#ifdef __cplusplus
#include <bit>
#include <cmath>
#include <native/detail/constexpr_float.h>
#endif
 
namespace ftz { namespace detail { namespace math {
  [[nodiscard]] native_constexpr native_inline native_const float fp32_decode(unsigned int bits) {
#ifdef __cplusplus
    return std::bit_cast<float>(bits);
#else
    return asfloat(bits);
#endif
  }
  [[nodiscard]] native_constexpr native_inline native_const unsigned int fp32_encode(float value) {
#ifdef __cplusplus
    return std::bit_cast<unsigned int>(value);
#else
    return asuint(value);
#endif
  }
  // The hardware policy applies to the whole graph. It skips explicit flushing
  // only after the caller qualifies the FP environment; it sets no FP controls.
  template <bool Hardware = FTZ_FP32_HARDWARE_FTZ != 0>
  native_constexpr inline float fp32_ftz(float value) {
#ifdef __cplusplus
    if !consteval { if (Hardware) return value; }
#else
    if (Hardware) return value;
#endif
    unsigned int bits = fp32_encode(value);
    return fp32_decode((bits & 0x7f800000u) == 0u ? bits & 0x80000000u : bits);
  }
  // Flush=false is for graphs that already bound their intermediates, or
  // perform their own final repair. It must not add per-operation FTZ work.
  template <bool Flush = true, bool Hardware = FTZ_FP32_HARDWARE_FTZ != 0>
  [[nodiscard]] native_constexpr native_inline float fp32_add(float a, float b) {
#ifdef __cplusplus
    if consteval {
      namespace fp = ::native::detail::constexpr_float;
      auto const bits = fp::add_bits<fp::binary32>(fp32_encode(a), fp32_encode(b));
      float result = fp32_decode(bits);
      return Flush ? fp32_ftz<false>(result) : result;
    }
    float result = a + b;
#else
    precise float result = a + b;
#endif
    return Flush ? fp32_ftz<Hardware>(result) : result;
  }
  template <bool Flush = true, bool Hardware = FTZ_FP32_HARDWARE_FTZ != 0>
  [[nodiscard]] native_constexpr native_inline float fp32_mul(float a, float b) {
#ifdef __cplusplus
    if consteval {
      namespace fp = ::native::detail::constexpr_float;
      auto const bits = fp::mul_bits<fp::binary32>(fp32_encode(a), fp32_encode(b));
      float result = fp32_decode(bits);
      return Flush ? fp32_ftz<false>(result) : result;
    }
    float result = a * b;
#else
    precise float result = a * b;
#endif
    return Flush ? fp32_ftz<Hardware>(result) : result;
  }
  template <bool Flush = true, bool Hardware = FTZ_FP32_HARDWARE_FTZ != 0>
  [[nodiscard]] native_constexpr native_inline float fp32_fma(float a, float b, float c) {
#ifdef __cplusplus
    if consteval {
      namespace fp = ::native::detail::constexpr_float;
      auto const bits = fp::fma_bits<fp::binary32>(fp32_encode(a), fp32_encode(b), fp32_encode(c));
      float result = fp32_decode(bits);
      return Flush ? fp32_ftz<false>(result) : result;
    }
    float result = std::fma(a, b, c);
#else
    precise float result = mad(a, b, c);
#endif
    return Flush ? fp32_ftz<Hardware>(result) : result;
  }
#ifndef __cplusplus
  native_constexpr inline float2 fp32_ftz(float2 value) {
#if FTZ_FP32_HARDWARE_FTZ
    return value;
#else
    uint2 bits = asuint(value);
    uint2 nonzero = uint2((bits & 0x7f800000u) != 0u);
    return asfloat(bits & ((0u - nonzero) | 0x80000000u));
#endif
  }
  native_constexpr inline float3 fp32_ftz(float3 value) {
#if FTZ_FP32_HARDWARE_FTZ
    return value;
#else
    uint3 bits = asuint(value);
    uint3 nonzero = uint3((bits & 0x7f800000u) != 0u);
    return asfloat(bits & ((0u - nonzero) | 0x80000000u));
#endif
  }
  native_constexpr inline float4 fp32_ftz(float4 value) {
#if FTZ_FP32_HARDWARE_FTZ
    return value;
#else
    uint4 bits = asuint(value);
    uint4 nonzero = uint4((bits & 0x7f800000u) != 0u);
    return asfloat(bits & ((0u - nonzero) | 0x80000000u));
#endif
  }
#endif
}}}