1/*---------------------------------------------------------------------------
2 *
3 * Common routines for Ryu floating-point output.
4 *
5 * Portions Copyright (c) 2018-2019, PostgreSQL Global Development Group
6 *
7 * IDENTIFICATION
8 * src/common/ryu_common.h
9 *
10 * This is a modification of code taken from github.com/ulfjack/ryu under the
11 * terms of the Boost license (not the Apache license). The original copyright
12 * notice follows:
13 *
14 * Copyright 2018 Ulf Adams
15 *
16 * The contents of this file may be used under the terms of the Apache
17 * License, Version 2.0.
18 *
19 * (See accompanying file LICENSE-Apache or copy at
20 * http://www.apache.org/licenses/LICENSE-2.0)
21 *
22 * Alternatively, the contents of this file may be used under the terms of the
23 * Boost Software License, Version 1.0.
24 *
25 * (See accompanying file LICENSE-Boost or copy at
26 * https://www.boost.org/LICENSE_1_0.txt)
27 *
28 * Unless required by applicable law or agreed to in writing, this software is
29 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
30 * KIND, either express or implied.
31 *
32 *---------------------------------------------------------------------------
33 */
34#ifndef RYU_COMMON_H
35#define RYU_COMMON_H
36
37/*
38 * Upstream Ryu's output is always the shortest possible. But we adjust that
39 * slightly to improve portability: we avoid outputting the exact midpoint
40 * value between two representable floats, since that relies on the reader
41 * getting the round-to-even rule correct, which seems to be the common
42 * failure mode.
43 *
44 * Defining this to 1 would restore the upstream behavior.
45 */
46#define STRICTLY_SHORTEST 0
47
48#if SIZEOF_SIZE_T < 8
49#define RYU_32_BIT_PLATFORM
50#endif
51
52/* Returns e == 0 ? 1 : ceil(log_2(5^e)). */
53static inline uint32
54pow5bits(const int32 e)
55{
56 /*
57 * This approximation works up to the point that the multiplication
58 * overflows at e = 3529.
59 *
60 * If the multiplication were done in 64 bits, it would fail at 5^4004
61 * which is just greater than 2^9297.
62 */
63 Assert(e >= 0);
64 Assert(e <= 3528);
65 return ((((uint32) e) * 1217359) >> 19) + 1;
66}
67
68/* Returns floor(log_10(2^e)). */
69static inline int32
70log10Pow2(const int32 e)
71{
72 /*
73 * The first value this approximation fails for is 2^1651 which is just
74 * greater than 10^297.
75 */
76 Assert(e >= 0);
77 Assert(e <= 1650);
78 return (int32) ((((uint32) e) * 78913) >> 18);
79}
80
81/* Returns floor(log_10(5^e)). */
82static inline int32
83log10Pow5(const int32 e)
84{
85 /*
86 * The first value this approximation fails for is 5^2621 which is just
87 * greater than 10^1832.
88 */
89 Assert(e >= 0);
90 Assert(e <= 2620);
91 return (int32) ((((uint32) e) * 732923) >> 20);
92}
93
94static inline int
95copy_special_str(char *const result, const bool sign, const bool exponent, const bool mantissa)
96{
97 if (mantissa)
98 {
99 memcpy(result, "NaN", 3);
100 return 3;
101 }
102 if (sign)
103 {
104 result[0] = '-';
105 }
106 if (exponent)
107 {
108 memcpy(result + sign, "Infinity", 8);
109 return sign + 8;
110 }
111 result[sign] = '0';
112 return sign + 1;
113}
114
115static inline uint32
116float_to_bits(const float f)
117{
118 uint32 bits = 0;
119
120 memcpy(&bits, &f, sizeof(float));
121 return bits;
122}
123
124static inline uint64
125double_to_bits(const double d)
126{
127 uint64 bits = 0;
128
129 memcpy(&bits, &d, sizeof(double));
130 return bits;
131}
132
133#endif /* RYU_COMMON_H */
134