Merge pull request #29774 from vespa-engine/balder/strtod-2-from_chars

Use std::from_chars instead of strtod. Also improve handling of float…

1 files changed, 50 insertions, 41 deletions

diff --git a/searchlib/src/tests/query/streaming_query_test.cpp b/searchlib/src/tests/query/streaming_query_test.cpp
index 0a751e96222..f5370785167 100644
--- a/searchlib/src/tests/query/streaming_query_test.cpp
+++ b/searchlib/src/tests/query/streaming_query_test.cpp
@@ -38,7 +38,7 @@ TEST(StreamingQueryTest, test_query_language)
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
         EXPECT_EQ(ia, 7);
         EXPECT_EQ(ib, 7);
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
         EXPECT_EQ(da, 7);
         EXPECT_EQ(db, 7);
     }
@@ -48,15 +48,24 @@ TEST(StreamingQueryTest, test_query_language)
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
         EXPECT_EQ(ia, -7);
         EXPECT_EQ(ib, -7);
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
         EXPECT_EQ(da, -7);
         EXPECT_EQ(db, -7);
     }
+    {
+        QueryTerm q(factory.create(), "+7", "index", TermType::WORD);
+        EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
+        EXPECT_EQ(ia, 7);
+        EXPECT_EQ(ib, 7);
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
+        EXPECT_EQ(da, 7);
+        EXPECT_EQ(db, 7);
+    }
 
     {
         QueryTerm q(factory.create(), "7.5", "index", TermType::WORD);
         EXPECT_TRUE(!q.getAsIntegerTerm(ia, ib));
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
         EXPECT_EQ(da, 7.5);
         EXPECT_EQ(db, 7.5);
     }
@@ -64,7 +73,7 @@ TEST(StreamingQueryTest, test_query_language)
     {
         QueryTerm q(factory.create(), "-7.5", "index", TermType::WORD);
         EXPECT_TRUE(!q.getAsIntegerTerm(ia, ib));
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
         EXPECT_EQ(da, -7.5);
         EXPECT_EQ(db, -7.5);
     }
@@ -74,8 +83,8 @@ TEST(StreamingQueryTest, test_query_language)
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
         EXPECT_EQ(ia, std::numeric_limits<int64_t>::min());
         EXPECT_EQ(ib, 6);
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQ(da, -std::numeric_limits<double>::max());
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
+        EXPECT_EQ(da, -std::numeric_limits<double>::infinity());
         EXPECT_LT(db, 7);
         EXPECT_GT(db, 6.99);
     }
@@ -85,8 +94,8 @@ TEST(StreamingQueryTest, test_query_language)
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
         EXPECT_EQ(ia, std::numeric_limits<int64_t>::min());
         EXPECT_EQ(ib, 7);
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQ(da, -std::numeric_limits<double>::max());
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
+        EXPECT_EQ(da, -std::numeric_limits<double>::infinity());
         EXPECT_EQ(db, 7);
     }
 
@@ -95,10 +104,10 @@ TEST(StreamingQueryTest, test_query_language)
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
         EXPECT_EQ(ia, 8);
         EXPECT_EQ(ib, std::numeric_limits<int64_t>::max());
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
         EXPECT_GT(da, 7);
         EXPECT_LT(da, 7.01);
-        EXPECT_EQ(db, std::numeric_limits<double>::max());
+        EXPECT_EQ(db, std::numeric_limits<double>::infinity());
     }
 
     {
@@ -106,9 +115,9 @@ TEST(StreamingQueryTest, test_query_language)
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
         EXPECT_EQ(ia, 7);
         EXPECT_EQ(ib, std::numeric_limits<int64_t>::max());
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
         EXPECT_EQ(da, 7);
-        EXPECT_EQ(db, std::numeric_limits<double>::max());
+        EXPECT_EQ(db, std::numeric_limits<double>::infinity());
     }
 
     {
@@ -116,7 +125,7 @@ TEST(StreamingQueryTest, test_query_language)
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
         EXPECT_EQ(ia, -7);
         EXPECT_EQ(ib, 7);
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
         EXPECT_EQ(da, -7);
         EXPECT_EQ(db, 7);
     }
@@ -126,7 +135,7 @@ TEST(StreamingQueryTest, test_query_language)
         EXPECT_FALSE(q.getAsIntegerTerm(ia, ib)); // This is dubious and perhaps a regression.
         EXPECT_EQ(ia, std::numeric_limits<int64_t>::min());
         EXPECT_EQ(ib, std::numeric_limits<int64_t>::max());
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
         EXPECT_EQ(da, -7.1);
         EXPECT_EQ(db, 7.1);
     }
@@ -136,7 +145,7 @@ TEST(StreamingQueryTest, test_query_language)
         EXPECT_FALSE(q.getAsIntegerTerm(ia, ib)); // This is dubious and perhaps a regression.
         EXPECT_EQ(ia, std::numeric_limits<int64_t>::min());
         EXPECT_EQ(ib, std::numeric_limits<int64_t>::max());
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
         EXPECT_EQ(da, 500.0);
         EXPECT_EQ(db, std::numeric_limits<double>::max());
     }
@@ -147,8 +156,8 @@ TEST(StreamingQueryTest, test_query_language)
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
         EXPECT_EQ(ia, -6);
         EXPECT_EQ(ib, 7);
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQ(da, std::nextafterf(minusSeven, seven));
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
+        EXPECT_EQ(da, std::nextafter(minusSeven, seven));
         EXPECT_EQ(db, seven);
     }
 
@@ -157,9 +166,9 @@ TEST(StreamingQueryTest, test_query_language)
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
         EXPECT_EQ(ia, -6);
         EXPECT_EQ(ib, 6);
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQ(da, std::nextafterf(minusSeven, seven));
-        EXPECT_EQ(db, std::nextafterf(seven, minusSeven));
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
+        EXPECT_EQ(da, std::nextafter(minusSeven, seven));
+        EXPECT_EQ(db, std::nextafter(seven, minusSeven));
     }
 
     {
@@ -174,9 +183,9 @@ TEST(StreamingQueryTest, test_query_language)
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
         EXPECT_EQ(ia, -7);
         EXPECT_EQ(ib, 6);
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
         EXPECT_EQ(da, minusSeven);
-        EXPECT_EQ(db, std::nextafterf(seven, minusSeven));
+        EXPECT_EQ(db, std::nextafter(seven, minusSeven));
     }
 
     {
@@ -184,8 +193,8 @@ TEST(StreamingQueryTest, test_query_language)
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
         EXPECT_EQ(ia, std::numeric_limits<int64_t>::min());
         EXPECT_EQ(ib, -8);
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQ(da, -std::numeric_limits<double>::max());
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
+        EXPECT_EQ(da, -std::numeric_limits<double>::infinity());
         EXPECT_LT(db, -7);
         EXPECT_GT(db, -7.01);
     }
@@ -195,8 +204,8 @@ TEST(StreamingQueryTest, test_query_language)
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
         EXPECT_EQ(ia, std::numeric_limits<int64_t>::min());
         EXPECT_EQ(ib, -7);
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQ(da, -std::numeric_limits<double>::max());
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
+        EXPECT_EQ(da, -std::numeric_limits<double>::infinity());
         EXPECT_EQ(db, -7);
     }
 
@@ -205,8 +214,8 @@ TEST(StreamingQueryTest, test_query_language)
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
         EXPECT_EQ(ia, std::numeric_limits<int64_t>::min());
         EXPECT_EQ(ib, -7);
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-        EXPECT_EQ(da, -std::numeric_limits<double>::max());
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
+        EXPECT_EQ(da, -std::numeric_limits<double>::infinity());
         EXPECT_EQ(db, -7);
     }
 
@@ -215,10 +224,10 @@ TEST(StreamingQueryTest, test_query_language)
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
         EXPECT_EQ(ia, -6);
         EXPECT_EQ(ib, std::numeric_limits<int64_t>::max());
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
         EXPECT_GT(da, -7);
         EXPECT_LT(da, -6.99);
-        EXPECT_EQ(db, std::numeric_limits<double>::max());
+        EXPECT_EQ(db, std::numeric_limits<double>::infinity());
     }
 
     {
@@ -226,9 +235,9 @@ TEST(StreamingQueryTest, test_query_language)
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
         EXPECT_EQ(ia, -7);
         EXPECT_EQ(ib, std::numeric_limits<int64_t>::max());
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
         EXPECT_EQ(da, -7);
-        EXPECT_EQ(db, std::numeric_limits<double>::max());
+        EXPECT_EQ(db, std::numeric_limits<double>::infinity());
     }
 
     {
@@ -236,15 +245,15 @@ TEST(StreamingQueryTest, test_query_language)
         EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
         EXPECT_EQ(ia, -7);
         EXPECT_EQ(ib, std::numeric_limits<int64_t>::max());
-        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_TRUE(q.getAsFloatTerm(da, db));
         EXPECT_EQ(da, -7);
-        EXPECT_EQ(db, std::numeric_limits<double>::max());
+        EXPECT_EQ(db, std::numeric_limits<double>::infinity());
     }
 
     {
         QueryTerm q(factory.create(), "a", "index", TermType::WORD);
         EXPECT_TRUE(!q.getAsIntegerTerm(ia, ib));
-        EXPECT_TRUE(!q.getAsDoubleTerm(da, db));
+        EXPECT_TRUE(!q.getAsFloatTerm(da, db));
     }
 
     {
@@ -645,11 +654,11 @@ TEST(StreamingQueryTest, require_that_ascending_range_can_be_specified_with_limi
     QueryTerm ascending_query(eqnr.create(), "[;;500]", "index", TermType::WORD);
 
     EXPECT_TRUE(ascending_query.getAsIntegerTerm(low_integer, high_integer));
-    EXPECT_TRUE(ascending_query.getAsDoubleTerm(low_double, high_double));
+    EXPECT_TRUE(ascending_query.getAsFloatTerm(low_double, high_double));
     EXPECT_EQ(std::numeric_limits<int64_t>::min(), low_integer);
     EXPECT_EQ(std::numeric_limits<int64_t>::max(), high_integer);
-    EXPECT_EQ(-std::numeric_limits<double>::max(), low_double);
-    EXPECT_EQ(std::numeric_limits<double>::max(), high_double);
+    EXPECT_EQ(-std::numeric_limits<double>::infinity(), low_double);
+    EXPECT_EQ(std::numeric_limits<double>::infinity(), high_double);
     EXPECT_EQ(500, ascending_query.getRangeLimit());
 }
 
@@ -664,11 +673,11 @@ TEST(StreamingQueryTest, require_that_descending_range_can_be_specified_with_lim
     QueryTerm descending_query(eqnr.create(), "[;;-500]", "index", TermType::WORD);
 
     EXPECT_TRUE(descending_query.getAsIntegerTerm(low_integer, high_integer));
-    EXPECT_TRUE(descending_query.getAsDoubleTerm(low_double, high_double));
+    EXPECT_TRUE(descending_query.getAsFloatTerm(low_double, high_double));
     EXPECT_EQ(std::numeric_limits<int64_t>::min(), low_integer);
     EXPECT_EQ(std::numeric_limits<int64_t>::max(), high_integer);
-    EXPECT_EQ(-std::numeric_limits<double>::max(), low_double);
-    EXPECT_EQ(std::numeric_limits<double>::max(), high_double);
+    EXPECT_EQ(-std::numeric_limits<double>::infinity(), low_double);
+    EXPECT_EQ(std::numeric_limits<double>::infinity(), high_double);
     EXPECT_EQ(-500, descending_query.getRangeLimit());
 }