214 lines
6.5 KiB
C++
214 lines
6.5 KiB
C++
/*
|
|
* The code is adopted from original (half) c implementation:
|
|
* https://github.com/ulfjack/ryu.git with some more comments and tidying. License is
|
|
* attached below.
|
|
*
|
|
* Copyright 2018 Ulf Adams
|
|
*
|
|
* The contents of this file may be used under the terms of the Apache License,
|
|
* Version 2.0.
|
|
*
|
|
* (See accompanying file LICENSE-Apache or copy at
|
|
* http: *www.apache.org/licenses/LICENSE-2.0)
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* the Boost Software License, Version 1.0.
|
|
* (See accompanying file LICENSE-Boost or copy at
|
|
* https://www.boost.org/LICENSE_1_0.txt)
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, this software
|
|
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
* KIND, either express or implied.
|
|
*/
|
|
#include <cstddef>
|
|
#include <gtest/gtest.h>
|
|
#include <limits>
|
|
#include "../../../src/common/charconv.h"
|
|
|
|
namespace xgboost {
|
|
namespace {
|
|
void TestInteger(char const* res, int64_t i) {
|
|
char result[xgboost::NumericLimits<int64_t>::kToCharsSize];
|
|
auto ret = to_chars(result, result + sizeof(result), i);
|
|
*ret.ptr = '\0';
|
|
EXPECT_STREQ(res, result);
|
|
}
|
|
|
|
static float Int32Bits2Float(uint32_t bits) {
|
|
float f;
|
|
memcpy(&f, &bits, sizeof(float));
|
|
return f;
|
|
}
|
|
|
|
void TestRyu(char const *res, float v) {
|
|
char result[xgboost::NumericLimits<float>::kToCharsSize];
|
|
auto ret = to_chars(result, result + sizeof(result), v);
|
|
*ret.ptr = '\0';
|
|
EXPECT_STREQ(res, result);
|
|
}
|
|
} // anonymous namespace
|
|
|
|
TEST(Ryu, Subnormal) {
|
|
TestRyu("0E0", 0.0f);
|
|
TestRyu("-0E0", -0.0f);
|
|
TestRyu("1E0", 1.0f);
|
|
TestRyu("-1E0", -1.0f);
|
|
TestRyu("NaN", NAN);
|
|
TestRyu("Infinity", INFINITY);
|
|
TestRyu("-Infinity", -INFINITY);
|
|
|
|
TestRyu("1E-45", std::numeric_limits<float>::denorm_min());
|
|
}
|
|
|
|
TEST(Ryu, Denormal) {
|
|
TestRyu("1E-45", std::numeric_limits<float>::denorm_min());
|
|
}
|
|
|
|
TEST(Ryu, SwitchToSubnormal) {
|
|
TestRyu("1.1754944E-38", 1.1754944E-38f);
|
|
}
|
|
|
|
TEST(Ryu, MinAndMax) {
|
|
TestRyu("3.4028235E38", Int32Bits2Float(0x7f7fffff));
|
|
TestRyu("1E-45", Int32Bits2Float(1));
|
|
}
|
|
|
|
// Check that we return the exact boundary if it is the shortest
|
|
// representation, but only if the original floating point number is even.
|
|
TEST(Ryu, BoundaryRoundEven) {
|
|
TestRyu("3.355445E7", 3.355445E7f);
|
|
TestRyu("9E9", 8.999999E9f);
|
|
TestRyu("3.436672E10", 3.4366717E10f);
|
|
}
|
|
|
|
// If the exact value is exactly halfway between two shortest representations,
|
|
// then we round to even. It seems like this only makes a difference if the
|
|
// last two digits are ...2|5 or ...7|5, and we cut off the 5.
|
|
TEST(Ryu, ExactValueRoundEven) {
|
|
TestRyu("3.0540412E5", 3.0540412E5f);
|
|
TestRyu("8.0990312E3", 8.0990312E3f);
|
|
}
|
|
|
|
TEST(Ryu, LotsOfTrailingZeros) {
|
|
// Pattern for the first test: 00111001100000000000000000000000
|
|
TestRyu("2.4414062E-4", 2.4414062E-4f);
|
|
TestRyu("2.4414062E-3", 2.4414062E-3f);
|
|
TestRyu("4.3945312E-3", 4.3945312E-3f);
|
|
TestRyu("6.3476562E-3", 6.3476562E-3f);
|
|
}
|
|
|
|
TEST(Ryu, Regression) {
|
|
TestRyu("4.7223665E21", 4.7223665E21f);
|
|
TestRyu("8.388608E6", 8388608.0f);
|
|
TestRyu("1.6777216E7", 1.6777216E7f);
|
|
TestRyu("3.3554436E7", 3.3554436E7f);
|
|
TestRyu("6.7131496E7", 6.7131496E7f);
|
|
TestRyu("1.9310392E-38", 1.9310392E-38f);
|
|
TestRyu("-2.47E-43", -2.47E-43f);
|
|
TestRyu("1.993244E-38", 1.993244E-38f);
|
|
TestRyu("4.1039004E3", 4103.9003f);
|
|
TestRyu("5.3399997E9", 5.3399997E9f);
|
|
TestRyu("6.0898E-39", 6.0898E-39f);
|
|
TestRyu("1.0310042E-3", 0.0010310042f);
|
|
TestRyu("2.882326E17", 2.8823261E17f);
|
|
TestRyu("7.038531E-26", 7.0385309E-26f);
|
|
TestRyu("9.223404E17", 9.2234038E17f);
|
|
TestRyu("6.710887E7", 6.7108872E7f);
|
|
TestRyu("1E-44", 1.0E-44f);
|
|
TestRyu("2.816025E14", 2.816025E14f);
|
|
TestRyu("9.223372E18", 9.223372E18f);
|
|
TestRyu("1.5846086E29", 1.5846085E29f);
|
|
TestRyu("1.1811161E19", 1.1811161E19f);
|
|
TestRyu("5.368709E18", 5.368709E18f);
|
|
TestRyu("4.6143166E18", 4.6143165E18f);
|
|
TestRyu("7.812537E-3", 0.007812537f);
|
|
TestRyu("1E-45", 1.4E-45f);
|
|
TestRyu("1.18697725E20", 1.18697724E20f);
|
|
TestRyu("1.00014165E-36", 1.00014165E-36f);
|
|
TestRyu("2E2", 200.0f);
|
|
TestRyu("3.3554432E7", 3.3554432E7f);
|
|
|
|
static_assert(1.1920929E-7f == std::numeric_limits<float>::epsilon());
|
|
TestRyu("1.1920929E-7", std::numeric_limits<float>::epsilon());
|
|
}
|
|
|
|
TEST(Ryu, RoundTrip) {
|
|
float f = -1.1493590134238582e-40;
|
|
char result[NumericLimits<float>::kToCharsSize] { 0 };
|
|
auto ret = to_chars(result, result + sizeof(result), f);
|
|
size_t dis = std::distance(result, ret.ptr);
|
|
float back;
|
|
auto from_ret = from_chars(result, result + dis, back);
|
|
ASSERT_EQ(from_ret.ec, std::errc());
|
|
std::string str;
|
|
for (size_t i = 0; i < dis; ++i) {
|
|
str.push_back(result[i]);
|
|
}
|
|
ASSERT_EQ(f, back);
|
|
}
|
|
|
|
TEST(Ryu, LooksLikePow5) {
|
|
// These numbers have a mantissa that is the largest power of 5 that fits,
|
|
// and an exponent that causes the computation for q to result in 10, which is a corner
|
|
// case for Ryu.
|
|
TestRyu("6.7108864E17", Int32Bits2Float(0x5D1502F9));
|
|
TestRyu("1.3421773E18", Int32Bits2Float(0x5D9502F9));
|
|
TestRyu("2.6843546E18", Int32Bits2Float(0x5E1502F9));
|
|
}
|
|
|
|
TEST(Ryu, OutputLength) {
|
|
TestRyu("1E0", 1.0f); // already tested in Basic
|
|
TestRyu("1.2E0", 1.2f);
|
|
TestRyu("1.23E0", 1.23f);
|
|
TestRyu("1.234E0", 1.234f);
|
|
TestRyu("1.2345E0", 1.2345f);
|
|
TestRyu("1.23456E0", 1.23456f);
|
|
TestRyu("1.234567E0", 1.234567f);
|
|
TestRyu("1.2345678E0", 1.2345678f);
|
|
TestRyu("1.23456735E-36", 1.23456735E-36f);
|
|
}
|
|
|
|
TEST(IntegerPrinting, Basic) {
|
|
TestInteger("0", 0);
|
|
auto str = std::to_string(std::numeric_limits<int64_t>::min());
|
|
TestInteger(str.c_str(), std::numeric_limits<int64_t>::min());
|
|
str = std::to_string(std::numeric_limits<int64_t>::max());
|
|
TestInteger(str.c_str(), std::numeric_limits<int64_t>::max());
|
|
}
|
|
|
|
void TestRyuParse(float f, std::string in) {
|
|
float res;
|
|
auto ret = from_chars(in.c_str(), in.c_str() + in.size(), res);
|
|
ASSERT_EQ(ret.ec, std::errc());
|
|
ASSERT_EQ(f, res);
|
|
}
|
|
|
|
TEST(Ryu, Basic) {
|
|
TestRyuParse(0.0f, "0");
|
|
TestRyuParse(-0.0f, "-0");
|
|
TestRyuParse(1.0f, "1");
|
|
TestRyuParse(-1.0f, "-1");
|
|
TestRyuParse(123456792.0f, "123456789");
|
|
TestRyuParse(299792448.0f, "299792458");
|
|
}
|
|
|
|
TEST(Ryu, MinMax) {
|
|
TestRyuParse(1e-45f, "1e-45");
|
|
TestRyuParse(FLT_MIN, "1.1754944e-38");
|
|
TestRyuParse(FLT_MAX, "3.4028235e+38");
|
|
}
|
|
|
|
TEST(Ryu, MantissaRoundingOverflow) {
|
|
TestRyuParse(1.0f, "0.999999999");
|
|
TestRyuParse(INFINITY, "3.4028236e+38");
|
|
TestRyuParse(1.1754944e-38f, "1.17549430e-38"); // FLT_MIN
|
|
}
|
|
|
|
TEST(Ryu, TrailingZeros) {
|
|
TestRyuParse(26843550.0f, "26843549.5");
|
|
TestRyuParse(50000004.0f, "50000002.5");
|
|
TestRyuParse(99999992.0f, "99999989.5");
|
|
}
|
|
|
|
} // namespace xgboost
|