Add strings::LegacyPrecision to TSL.

This is a copy of `absl::LegacyPrecision` which is not available in OSS. This allows users to write `absl::StrCat(absl::LegacyPrecision(value))` and preserve the legacy `strings::StrCat(value)` behavior. This is necessary to migrate away from deprecated `strings::StrCat` and `strings::StrAppend`.

PiperOrigin-RevId: 755993912

Author: allanrenucci

tsl/platform/numbers.cc

@@ -243,6 +243,18 @@ size_t FloatToBuffer(float value, char* buffer) {
   return snprintf_result;
 }
 
+strings_internal::AlphaNumBuffer LegacyPrecision(double d) {
+  strings_internal::AlphaNumBuffer result;
+  result.size = DoubleToBuffer(d, result.data.data());
+  return result;
+}
+
+strings_internal::AlphaNumBuffer LegacyPrecision(float f) {
+  strings_internal::AlphaNumBuffer result;
+  result.size = FloatToBuffer(f, result.data.data());
+  return result;
+}
+
 std::string FpToString(Fprint fp) {
   return absl::StrCat(absl::Hex(fp, absl::kZeroPad16));
 }

tsl/platform/numbers.h

@@ -16,12 +16,14 @@ limitations under the License.
 #ifndef TENSORFLOW_TSL_PLATFORM_NUMBERS_H_
 #define TENSORFLOW_TSL_PLATFORM_NUMBERS_H_
 
+#include <array>
 #include <cstddef>
 #include <cstdint>
 #include <string>
 
 #include "absl/base/macros.h"
 #include "absl/strings/numbers.h"
+#include "absl/strings/string_view.h"
 #include "xla/tsl/platform/types.h"
 #include "tsl/platform/stringpiece.h"
 
@@ -77,6 +79,43 @@ size_t FastUInt64ToBufferLeft(uint64_t i, char* buffer);  // at least 22 bytes
 size_t DoubleToBuffer(double value, char* buffer);
 size_t FloatToBuffer(float value, char* buffer);
 
+namespace strings_internal {
+// AlphaNumBuffer allows a way to pass a string to absl::StrCat without having
+// to do memory allocation. It is simply a pair of a fixed-size character
+// array, and a size.  Please don't use outside of the "strings" package.
+struct AlphaNumBuffer {
+  std::array<char, kFastToBufferSize> data;
+  size_t size;
+
+  // Support for absl::StrCat() etc.
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const AlphaNumBuffer& buffer) {
+    absl::Format(&sink, "%s",
+                 absl::string_view(buffer.data.data(), buffer.size));
+  }
+};
+}  // namespace strings_internal
+
+// Helper function for legacy google formatting.
+template <typename T>
+const T& LegacyPrecision(const T& t) {
+  return t;
+}
+
+// Have to use overloads rather than specialization because specialization can't
+// change the function return type.
+
+// Helper function for the old strings::StrCat default "float" format, which was
+// either %.6g, %.7g, %.8g, or %.9g, basically the smallest string that would
+// round-trip back to the original float. This is fast.
+strings_internal::AlphaNumBuffer LegacyPrecision(float f);
+
+// Helper function for the old strings::StrCat default "double" format, which
+// was either %.15g or %.17g, depending on whether the %.15g format would
+// round-trip back to the original double.  This is approx. 20-30x slower than
+// the others.
+strings_internal::AlphaNumBuffer LegacyPrecision(double d);
+
 // Convert a 64-bit fingerprint value to an ASCII representation.
 std::string FpToString(Fprint fp);
 

tsl/platform/numbers_test.cc

@@ -16,6 +16,8 @@ limitations under the License.
 #include "tsl/platform/numbers.h"
 
 #include <cmath>
+#include <cstdlib>
+#include <limits>
 #include <string>
 
 #include "absl/strings/str_cat.h"
@@ -381,5 +383,149 @@ TEST(safe_strtod, Double) {
   EXPECT_TRUE(std::isnan(result));
 }
 
+std::string DoubleToString(double d) {
+  return absl::StrCat(strings::LegacyPrecision(d));
+}
+
+TEST(LegacyPrecision, SimpleDoubleToString) {
+  // Make sure that nice, round decimal numbers are printed using few digits,
+  // even if they can't be represented exactly in binary.
+  EXPECT_EQ("0", DoubleToString(0.0));
+  EXPECT_EQ("1", DoubleToString(1.0));
+  EXPECT_EQ("-1", DoubleToString(-1.0));
+  EXPECT_EQ("0.2", DoubleToString(0.2));
+  EXPECT_EQ("1.1", DoubleToString(1.1));
+  EXPECT_EQ("1e+23", DoubleToString(1e23));
+  EXPECT_EQ("47.8", DoubleToString(47.8));
+  EXPECT_EQ("1000.2", DoubleToString(1000.2));
+}
+
+void TestDoubleRoundTrip(double value) {
+  std::string str = DoubleToString(value);
+  double rt = std::strtod(str.c_str(), nullptr);
+  if (std::isnan(value)) {
+    EXPECT_TRUE(std::isnan(rt));
+  } else {
+    EXPECT_EQ(value, rt);
+  }
+}
+
+TEST(LegacyPrecision, DoubleRoundTrip) {
+  // Make sure round-trips with strtod() work.  Note that even though we're
+  // dealing with floating points, we expect the results to be *exactly*
+  // equal, not approximately.
+  TestDoubleRoundTrip(1.2345678901234567);
+  TestDoubleRoundTrip(1.2345678901234565);
+  TestDoubleRoundTrip(1.2345678901234569);
+  TestDoubleRoundTrip(47.800000000000001);
+  TestDoubleRoundTrip(0.10000000000000005);
+  TestDoubleRoundTrip(0.010000000000000005);
+  TestDoubleRoundTrip(0.000000010000000000000005);
+  TestDoubleRoundTrip(1.0000000000000005);
+  TestDoubleRoundTrip(10.000000000000005);
+  TestDoubleRoundTrip(100.00000000000005);
+  TestDoubleRoundTrip(1000.0000000000005);
+  TestDoubleRoundTrip(100000000000000.05);
+
+  // IEEE-754 double finite values furthest from zero.
+  TestDoubleRoundTrip(1.7976931348623157e308);
+  TestDoubleRoundTrip(-1.7976931348623157e308);
+
+  // IEEE-754 double normalized values closest to zero.
+  TestDoubleRoundTrip(2.225073858507202e-308);
+  TestDoubleRoundTrip(-2.225073858507202e-308);
+
+  // IEEE-754 double denormalized values closest to zero.
+  TestDoubleRoundTrip(5e-324);
+  TestDoubleRoundTrip(-5e-324);
+
+  // Biggest and lowest valid numbers.
+  TestDoubleRoundTrip(std::numeric_limits<double>::max());
+  TestDoubleRoundTrip(std::numeric_limits<double>::lowest());
+
+  // Infinity and NaN.
+  TestDoubleRoundTrip(std::numeric_limits<double>::infinity());
+  TestDoubleRoundTrip(-std::numeric_limits<double>::infinity());
+  TestDoubleRoundTrip(std::numeric_limits<double>::quiet_NaN());
+}
+
+std::string FloatToString(float f) {
+  return absl::StrCat(strings::LegacyPrecision(f));
+}
+
+TEST(LegacyPrecision, SimpleFloatToString) {
+  // Make sure that nice, round decimal numbers are printed using few digits,
+  // even if they can't be represented exactly in binary.
+  EXPECT_EQ("0", FloatToString(0.0f));
+  EXPECT_EQ("-0", FloatToString(-0.0f));
+  EXPECT_EQ("1", FloatToString(1.0f));
+  EXPECT_EQ("-1", FloatToString(-1.0f));
+  EXPECT_EQ("0.2", FloatToString(0.2f));
+  EXPECT_EQ("1.1", FloatToString(1.1f));
+  EXPECT_EQ("1e+23", FloatToString(1e23f));
+  EXPECT_EQ("47.8", FloatToString(47.8f));
+  EXPECT_EQ("1000.2", FloatToString(1000.2f));
+  EXPECT_EQ("1.17549435e-38", FloatToString(1.17549435e-38f));
+}
+
+void TestFloatRoundTrip(float value) {
+  std::string str = FloatToString(value);
+  float rt = std::strtof(str.c_str(), nullptr);
+  if (std::isnan(value)) {
+    EXPECT_TRUE(std::isnan(rt));
+  } else {
+    EXPECT_EQ(value, rt);
+  }
+}
+
+TEST(LegacyPrecision, FloatRoundTrip) {
+  // Make sure round-trips with strtod() work.  Note that even though we're
+  // dealing with floating points, we expect the results to be *exactly*
+  // equal, not approximately.
+  FloatToString(1.2345678901234567);
+  FloatToString(1.2345678901234565);
+  FloatToString(1.2345678901234569);
+  FloatToString(47.800005);
+  FloatToString(0.10000005);
+  FloatToString(0.010000005);
+  FloatToString(0.000000010000005);
+  FloatToString(1.0000005);
+  FloatToString(10.000005);
+  FloatToString(100.00005);
+  FloatToString(1000.0005);
+  FloatToString(100000.05);
+  FloatToString(10.0000095);
+  FloatToString(10.0000100);
+  FloatToString(10.0000105);
+  FloatToString(10.0000110);
+  FloatToString(10.0000115);
+
+  // IEEE-754 float finite values furthest from zero.
+  FloatToString(+3.4028234e38f);
+  FloatToString(-3.4028234e38f);
+
+  // IEEE-754 float normalized values closest to zero.
+  FloatToString(+1.175494351e-38);
+  FloatToString(-1.175494351e-38);
+
+  // IEEE-754 double denormalized values closest to zero.
+  FloatToString(+1.4e-45);
+  FloatToString(-1.4e-45);
+
+  // Biggest and lowest valid numbers.
+  FloatToString(std::numeric_limits<float>::max());
+  FloatToString(std::numeric_limits<float>::lowest());
+
+  // Infinity and NaN.
+  FloatToString(std::numeric_limits<float>::infinity());
+  FloatToString(-std::numeric_limits<float>::infinity());
+  FloatToString(std::numeric_limits<float>::quiet_NaN());
+}
+
+TEST(LegacyPrecision, NoOpTypes) {
+  EXPECT_EQ(absl::StrCat(strings::LegacyPrecision(1)), "1");
+  EXPECT_EQ(absl::StrCat(strings::LegacyPrecision("foo")), "foo");
+}
+
 }  // namespace strings
 }  // namespace tsl