MayaFlux 1.0.0
Digital-First Multimedia Processing Framework
Loading...
Searching...
No Matches
SmallFloat.cpp
Go to the documentation of this file.
1#include "SmallFloat.hpp"
2
3namespace MayaFlux::Kakshya {
4
5float half_to_float(uint16_t bits) noexcept
6{
7 const uint32_t sign = static_cast<uint32_t>(bits & 0x8000U) << 16;
8 const uint32_t exponent = (bits >> 10) & 0x1FU;
9 const uint32_t mantissa = bits & 0x3FFU;
10
11 uint32_t pattern {};
12 if (exponent == 0) {
13 if (mantissa == 0) {
14 pattern = sign;
15 } else {
16 uint32_t shifts = 0;
17 uint32_t normalised = mantissa;
18 while ((normalised & 0x400U) == 0) {
19 normalised <<= 1;
20 ++shifts;
21 }
22 normalised &= 0x3FFU;
23 pattern = sign | ((113U - shifts) << 23) | (normalised << 13);
24 }
25 } else if (exponent == 0x1FU) {
26 pattern = sign | 0x7F800000U | (mantissa << 13);
27 } else {
28 pattern = sign | ((exponent - 15U + 127U) << 23) | (mantissa << 13);
29 }
30
31 float value {};
32 std::memcpy(&value, &pattern, sizeof(value));
33 return value;
34}
35
36uint16_t float_to_half(float value) noexcept
37{
38 uint32_t pattern {};
39 std::memcpy(&pattern, &value, sizeof(pattern));
40
41 const uint32_t sign = (pattern >> 16) & 0x8000U;
42 const auto field = static_cast<int32_t>((pattern >> 23) & 0xFFU);
43 uint32_t mantissa = pattern & 0x7FFFFFU;
44
45 if (field == 0xFF) {
46 if (mantissa == 0)
47 return static_cast<uint16_t>(sign | 0x7C00U);
48 return static_cast<uint16_t>(sign | 0x7C00U | 0x200U | (mantissa >> 13));
49 }
50
51 const int32_t exponent = field - 127 + 15;
52 if (exponent >= 0x1F)
53 return static_cast<uint16_t>(sign | 0x7C00U);
54
55 if (exponent <= 0) {
56 if (exponent < -10)
57 return static_cast<uint16_t>(sign);
58 mantissa |= 0x800000U;
59 const auto shift = static_cast<uint32_t>(14 - exponent);
60 uint32_t half = mantissa >> shift;
61 const uint32_t round_bit = 1U << (shift - 1U);
62 if ((mantissa & round_bit) != 0U && ((mantissa & (round_bit - 1U)) != 0U || (half & 1U) != 0U))
63 ++half;
64 return static_cast<uint16_t>(sign | half);
65 }
66
67 uint32_t half = (static_cast<uint32_t>(exponent) << 10) | (mantissa >> 13);
68 const uint32_t remainder = mantissa & 0x1FFFU;
69 if (remainder > 0x1000U || (remainder == 0x1000U && (half & 1U) != 0U))
70 ++half;
71 return static_cast<uint16_t>(sign | half);
72}
73
74double decode_small_float(uint32_t bits, int exponent_bits, int mantissa_bits) noexcept
75{
76 const int bias = (1 << (exponent_bits - 1)) - 1;
77 const uint32_t exponent_all = (1U << exponent_bits) - 1U;
78 const bool negative = ((bits >> (exponent_bits + mantissa_bits)) & 1U) != 0U;
79 const uint32_t exponent = (bits >> mantissa_bits) & exponent_all;
80 const uint32_t mantissa = bits & ((1U << mantissa_bits) - 1U);
81
82 double value {};
83 if (exponent == exponent_all) {
84 value = mantissa != 0U ? std::numeric_limits<double>::quiet_NaN() : std::numeric_limits<double>::infinity();
85 } else if (exponent == 0U) {
86 value = std::ldexp(static_cast<double>(mantissa), 1 - bias - mantissa_bits);
87 } else {
88 value = std::ldexp(static_cast<double>(mantissa | (1U << mantissa_bits)),
89 static_cast<int>(exponent) - bias - mantissa_bits);
90 }
91 return negative ? -value : value;
92}
93
94uint32_t encode_small_float(double value, int exponent_bits, int mantissa_bits) noexcept
95{
96 const int bias = (1 << (exponent_bits - 1)) - 1;
97 const uint32_t exponent_all = (1U << exponent_bits) - 1U;
98 const uint32_t sign = std::signbit(value) ? (1U << (exponent_bits + mantissa_bits)) : 0U;
99
100 if (std::isnan(value))
101 return sign | (exponent_all << mantissa_bits) | (1U << (mantissa_bits - 1));
102
103 value = std::fabs(value);
104 if (std::isinf(value))
105 return sign | (exponent_all << mantissa_bits);
106 if (value == 0.0)
107 return sign;
108
109 int exponent = 0;
110 std::frexp(value, &exponent);
111 const int unbiased = exponent - 1;
112 const int min_exponent = 1 - bias;
113
114 if (unbiased < min_exponent) {
115 const auto steps = static_cast<uint32_t>(std::nearbyint(std::ldexp(value, mantissa_bits - min_exponent)));
116 return sign | steps;
117 }
118
119 auto steps = static_cast<uint32_t>(std::nearbyint(std::ldexp(value, mantissa_bits - unbiased)));
120 int biased = unbiased + bias;
121 if (steps == (2U << mantissa_bits)) {
122 steps = 1U << mantissa_bits;
123 ++biased;
124 }
125 if (std::cmp_greater_equal(biased, exponent_all))
126 return sign | (exponent_all << mantissa_bits);
127
128 return sign | (static_cast<uint32_t>(biased) << mantissa_bits) | (steps - (1U << mantissa_bits));
129}
130
131}
uint32_t encode_small_float(double value, int exponent_bits, int mantissa_bits) noexcept
Encode a double as a binary floating point pattern with the given field widths.
float half_to_float(uint16_t bits) noexcept
IEEE 754 binary16 to binary32.
Definition SmallFloat.cpp:5
double decode_small_float(uint32_t bits, int exponent_bits, int mantissa_bits) noexcept
Decode a binary floating point pattern with the given field widths.
uint16_t float_to_half(float value) noexcept
IEEE 754 binary32 to binary16, rounding to nearest with ties to even.