1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
/*
* Copyright (c) 2022, Jelle Raaijmakers <jelle@gmta.nl>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/BitCast.h>
#include <AK/Concepts.h>
#include <AK/Types.h>
namespace AK {
template<size_t S, size_t E, size_t M>
requires(S <= 1 && E >= 1 && M >= 1 && (S + E + M) <= 64) class FloatingPointBits final {
public:
static const size_t signbit = S;
static const size_t exponentbits = E;
static const size_t mantissabits = M;
template<typename T>
requires(IsIntegral<T>&& IsUnsigned<T> && sizeof(T) <= 8) constexpr FloatingPointBits(T bits)
: m_bits(bits)
{
}
constexpr FloatingPointBits(double value)
: m_bits(bit_cast<u64>(value))
{
}
constexpr FloatingPointBits(float value)
: m_bits(bit_cast<u32>(value))
{
}
double as_double() const requires(S == 1 && E == 11 && M == 52) { return bit_cast<double>(m_bits); }
float as_float() const requires(S == 1 && E == 8 && M == 23) { return bit_cast<float>(static_cast<u32>(m_bits)); }
u64 bits() const { return m_bits; }
private:
u64 m_bits;
};
typedef FloatingPointBits<1, 8, 23> SingleFloatingPointBits;
typedef FloatingPointBits<1, 11, 52> DoubleFloatingPointBits;
/**
* Convert between two IEEE 754 floating point types in any arrangement of sign, exponent and mantissa bits.
*/
template<typename To, typename From>
constexpr To float_to_float(From const input)
{
constexpr u64 from_exponent_nonnumber = (1ull << From::exponentbits) - 1;
constexpr u64 from_exponent_bias = (1ull << (From::exponentbits - 1)) - 1;
constexpr u64 to_exponent_nonnumber = (1ull << To::exponentbits) - 1;
constexpr u64 to_exponent_bias = (1ull << (To::exponentbits - 1)) - 1;
constexpr u64 to_exponent_max = (1ull << To::exponentbits) - 2;
// Deconstruct input bits to float components
u64 from_sign = (input.bits() >> (From::exponentbits + From::mantissabits)) & From::signbit;
u64 from_exponent = (input.bits() >> From::mantissabits) & ((1ull << From::exponentbits) - 1);
u64 from_mantissa = input.bits() & ((1ull << From::mantissabits) - 1);
u64 to_sign = from_sign & To::signbit;
u64 to_exponent;
u64 to_mantissa;
auto target_value = [&to_sign, &to_exponent, &to_mantissa]() {
return To((to_sign << (To::exponentbits + To::mantissabits)) | (to_exponent << To::mantissabits) | to_mantissa);
};
auto shift_mantissa = [](u64 mantissa) -> u64 {
if constexpr (From::mantissabits < To::mantissabits)
return mantissa << (To::mantissabits - From::mantissabits);
else
return mantissa >> (From::mantissabits - To::mantissabits);
};
// If target is unsigned and source is negative, clamp to 0 or keep NaN
if constexpr (To::signbit == 0) {
if (from_sign == 1) {
if (from_exponent == from_exponent_nonnumber && from_mantissa > 0) {
to_exponent = to_exponent_nonnumber;
to_mantissa = 1;
} else {
to_exponent = 0;
to_mantissa = 0;
}
return target_value();
}
}
// If the source floating point is denormalized;
if (from_exponent == 0) {
// If the source mantissa is 0, the value is +/-0
if (from_mantissa == 0) {
to_exponent = 0;
to_mantissa = 0;
return target_value();
}
// If the source has more exponent bits than the target, then the largest possible
// source mantissa still cannot be represented in the target denormalized value.
if constexpr (From::exponentbits > To::exponentbits) {
to_exponent = 0;
to_mantissa = 0;
return target_value();
}
// If the source and target have the same number of exponent bits, we only need to
// shift the mantissa.
if constexpr (From::exponentbits == To::exponentbits) {
to_exponent = 0;
to_mantissa = shift_mantissa(from_mantissa);
return target_value();
}
// The target has more exponent bits, so our denormalized value can be represented
// as a normalized value in the target floating point. Normalized values have an
// implicit leading 1, so we shift the mantissa left until we find our explicit
// leading 1 which is then dropped.
int adjust_exponent = -1;
to_mantissa = from_mantissa;
do {
++adjust_exponent;
to_mantissa <<= 1;
} while ((to_mantissa & (1ull << From::mantissabits)) == 0);
to_exponent = to_exponent_bias - from_exponent_bias - adjust_exponent;
// Drop the most significant bit from the mantissa
to_mantissa &= (1ull << From::mantissabits) - 1;
to_mantissa = shift_mantissa(to_mantissa);
return target_value();
}
// If the source is NaN or +/-Inf, keep it that way
if (from_exponent == from_exponent_nonnumber) {
to_exponent = to_exponent_nonnumber;
to_mantissa = (from_mantissa == 0) ? 0 : 1;
return target_value();
}
// Determine the target exponent
to_exponent = to_exponent_bias - from_exponent_bias + from_exponent;
// If the calculated exponent exceeds the target's capacity, clamp both the exponent and the
// mantissa to their maximum values.
if (to_exponent > to_exponent_max) {
to_exponent = to_exponent_max;
to_mantissa = (1ull << To::mantissabits) - 1;
return target_value();
}
// If the new exponent is less than 1, we can only represent this value as a denormalized number
if (to_exponent < 1) {
to_exponent = 0;
// Add a leading 1 and shift the mantissa right
int adjust_exponent = 1 - to_exponent_bias - from_exponent + from_exponent_bias;
to_mantissa = ((1ull << From::mantissabits) | from_mantissa) >> adjust_exponent;
to_mantissa = shift_mantissa(to_mantissa);
return target_value();
}
// New exponent fits; shift the mantissa to fit as well
to_mantissa = shift_mantissa(from_mantissa);
return target_value();
}
template<typename O>
constexpr O convert_from_native_double(double input) { return float_to_float<O>(DoubleFloatingPointBits(input)); }
template<typename O>
constexpr O convert_from_native_float(float input) { return float_to_float<O>(SingleFloatingPointBits(input)); }
template<typename I>
constexpr double convert_to_native_double(I input) { return float_to_float<DoubleFloatingPointBits>(input).as_double(); }
template<typename I>
constexpr float convert_to_native_float(I input) { return float_to_float<SingleFloatingPointBits>(input).as_float(); }
}
using AK::DoubleFloatingPointBits;
using AK::FloatingPointBits;
using AK::SingleFloatingPointBits;
using AK::convert_from_native_double;
using AK::convert_from_native_float;
using AK::convert_to_native_double;
using AK::convert_to_native_float;
using AK::float_to_float;
|
