blob: 87b9f1e20ab6d5c575b284c498fa4700032d2849 (
plain)
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
|
/*
* Copyright 2021 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <limits>
#include <type_traits>
namespace android::ftl::details {
// Exponent whose power of 2 is the (exclusive) upper bound of T.
template <typename T, typename L = std::numeric_limits<T>>
constexpr int max_exponent = std::is_floating_point_v<T> ? L::max_exponent : L::digits;
// Extension of std::numeric_limits<T> that reduces the maximum for integral types T such that it
// has an exact representation for floating-point types F. For example, the maximum int32_t value
// is 2'147'483'647, but casting it to float commonly rounds up to 2'147'483'650.f, which cannot
// be safely converted back lest the signed overflow invokes undefined behavior. This pitfall is
// avoided by clearing the lower (31 - 24 =) 7 bits of precision to 2'147'483'520. Note that the
// minimum is representable.
template <typename T, typename F>
struct safe_limits : std::numeric_limits<T> {
static constexpr T max() {
using Base = std::numeric_limits<T>;
if constexpr (std::is_integral_v<T> && std::is_floating_point_v<F>) {
// Assume the mantissa is 24 bits for float, or 53 bits for double.
using Float = std::numeric_limits<F>;
static_assert(Float::is_iec559);
// If the integer is wider than the mantissa, clear the excess bits of precision.
constexpr int kShift = Base::digits - Float::digits;
if constexpr (kShift > 0) {
using U = std::make_unsigned_t<T>;
constexpr U kOne = static_cast<U>(1);
return static_cast<U>(Base::max()) & ~((kOne << kShift) - kOne);
}
}
return Base::max();
}
};
} // namespace android::ftl::details
|
