Age         Owner                  TLA  Line data    Source code

                                  1                 : /*---------------------------------------------------------------------------
                                  2                 :  *
                                  3                 :  * Common routines for Ryu floating-point output.
                                  4                 :  *
                                  5                 :  * Portions Copyright (c) 2018-2023, 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)). */
                                 53                 : static inline uint32
 1516 rhodiumtoad                54 CBC      803562 : pow5bits(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          803562 :     Assert(e >= 0);
                                 64          803562 :     Assert(e <= 3528);
                                 65          803562 :     return ((((uint32) e) * 1217359) >> 19) + 1;
                                 66                 : }
                                 67                 : 
                                 68                 : /*  Returns floor(log_10(2^e)). */
                                 69                 : static inline int32
                                 70            1602 : log10Pow2(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            1602 :     Assert(e >= 0);
                                 77            1602 :     Assert(e <= 1650);
                                 78            1602 :     return (int32) ((((uint32) e) * 78913) >> 18);
                                 79                 : }
                                 80                 : 
                                 81                 : /*  Returns floor(log_10(5^e)). */
                                 82                 : static inline int32
                                 83          800891 : log10Pow5(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          800891 :     Assert(e >= 0);
                                 90          800891 :     Assert(e <= 2620);
                                 91          800891 :     return (int32) ((((uint32) e) * 732923) >> 20);
                                 92                 : }
                                 93                 : 
                                 94                 : static inline int
                                 95            5807 : copy_special_str(char *const result, const bool sign, const bool exponent, const bool mantissa)
                                 96                 : {
                                 97            5807 :     if (mantissa)
                                 98                 :     {
                                 99             242 :         memcpy(result, "NaN", 3);
                                100             242 :         return 3;
                                101                 :     }
                                102            5565 :     if (sign)
                                103                 :     {
                                104             182 :         result[0] = '-';
                                105                 :     }
                                106            5565 :     if (exponent)
                                107                 :     {
                                108             443 :         memcpy(result + sign, "Infinity", 8);
                                109             443 :         return sign + 8;
                                110                 :     }
                                111            5122 :     result[sign] = '0';
                                112            5122 :     return sign + 1;
                                113                 : }
                                114                 : 
                                115                 : static inline uint32
                                116           11992 : float_to_bits(const float f)
                                117                 : {
                                118           11992 :     uint32      bits = 0;
                                119                 : 
                                120           11992 :     memcpy(&bits, &f, sizeof(float));
                                121           11992 :     return bits;
                                122                 : }
                                123                 : 
                                124                 : static inline uint64
                                125         1984142 : double_to_bits(const double d)
                                126                 : {
                                127         1984142 :     uint64      bits = 0;
                                128                 : 
                                129         1984142 :     memcpy(&bits, &d, sizeof(double));
                                130         1984142 :     return bits;
                                131                 : }
                                132                 : 
                                133                 : #endif                          /* RYU_COMMON_H */