1// Copyright 2018 Ulf Adams 2// 3// The contents of this file may be used under the terms of the Apache License, 4// Version 2.0. 5// 6// (See accompanying file LICENSE-Apache or copy at 7// http://www.apache.org/licenses/LICENSE-2.0) 8// 9// Alternatively, the contents of this file may be used under the terms of 10// the Boost Software License, Version 1.0. 11// (See accompanying file LICENSE-Boost or copy at 12// https://www.boost.org/LICENSE_1_0.txt) 13// 14// Unless required by applicable law or agreed to in writing, this software 15// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16// KIND, either express or implied. 17#ifndef RYU_COMMON_H 18#define RYU_COMMON_H 19 20 21#if defined(_M_IX86) || defined(_M_ARM) 22#define RYU_32_BIT_PLATFORM 23#endif 24 25// Returns the number of decimal digits in v, which must not contain more than 9 digits. 26static inline uint32_t decimalLength9(const uint32_t v) { 27 // Function precondition: v is not a 10-digit number. 28 // (f2s: 9 digits are sufficient for round-tripping.) 29 // (d2fixed: We print 9-digit blocks.) 30 assert(v < 1000000000); 31 if (v >= 100000000) { return 9; } 32 if (v >= 10000000) { return 8; } 33 if (v >= 1000000) { return 7; } 34 if (v >= 100000) { return 6; } 35 if (v >= 10000) { return 5; } 36 if (v >= 1000) { return 4; } 37 if (v >= 100) { return 3; } 38 if (v >= 10) { return 2; } 39 return 1; 40} 41 42// Returns e == 0 ? 1 : [log_2(5^e)]; requires 0 <= e <= 3528. 43static inline int32_t log2pow5(const int32_t e) { 44 // This approximation works up to the point that the multiplication overflows at e = 3529. 45 // If the multiplication were done in 64 bits, it would fail at 5^4004 which is just greater 46 // than 2^9297. 47 assert(e >= 0); 48 assert(e <= 3528); 49 return (int32_t) ((((uint32_t) e) * 1217359) >> 19); 50} 51 52// Returns e == 0 ? 1 : ceil(log_2(5^e)); requires 0 <= e <= 3528. 53static inline int32_t pow5bits(const int32_t e) { 54 // This approximation works up to the point that the multiplication overflows at e = 3529. 55 // If the multiplication were done in 64 bits, it would fail at 5^4004 which is just greater 56 // than 2^9297. 57 assert(e >= 0); 58 assert(e <= 3528); 59 return (int32_t) (((((uint32_t) e) * 1217359) >> 19) + 1); 60} 61 62// Returns e == 0 ? 1 : ceil(log_2(5^e)); requires 0 <= e <= 3528. 63static inline int32_t ceil_log2pow5(const int32_t e) { 64 return log2pow5(e) + 1; 65} 66 67// Returns floor(log_10(2^e)); requires 0 <= e <= 1650. 68static inline uint32_t log10Pow2(const int32_t e) { 69 // The first value this approximation fails for is 2^1651 which is just greater than 10^297. 70 assert(e >= 0); 71 assert(e <= 1650); 72 return (((uint32_t) e) * 78913) >> 18; 73} 74 75// Returns floor(log_10(5^e)); requires 0 <= e <= 2620. 76static inline uint32_t log10Pow5(const int32_t e) { 77 // The first value this approximation fails for is 5^2621 which is just greater than 10^1832. 78 assert(e >= 0); 79 assert(e <= 2620); 80 return (((uint32_t) e) * 732923) >> 20; 81} 82 83static inline uint32_t float_to_bits(const float f) { 84 uint32_t bits = 0; 85 memcpy(&bits, &f, sizeof(float)); 86 return bits; 87} 88 89static inline uint64_t double_to_bits(const double d) { 90 uint64_t bits = 0; 91 memcpy(&bits, &d, sizeof(double)); 92 return bits; 93} 94 95#endif // RYU_COMMON_H 96