[Wasm][stdlib] Improve Float.toString()

Before this change Float.toString() was producing unnecessarily
long strings because it was implemented as Float.toDouble().toString()
For example, 0.3f.toString() was evaluated to "0.30000001192092896".

This change parametrizes the code with `isSinglePrecision: Boolean`,
 which calculates a wider range of values, rounded to the original
  Float value.
Wider range allows the algorithm to find shorter decimal strings.

^KT-69107 Fixed
^KT-68948 Fixed
^KT-59118 Fixed

Author: skuzmich

generators/builtins/primitives/WasmPrimitivesGenerator.kt

@@ -233,7 +233,7 @@ class WasmPrimitivesGenerator(writer: PrintWriter) : BasePrimitivesGenerator(wri
 
     override fun MethodBuilder.modifyGeneratedToString(thisKind: PrimitiveType) {
         when (thisKind) {
-            in PrimitiveType.floatingPoint -> "dtoa(this${thisKind.castToIfNecessary(PrimitiveType.DOUBLE)})"
+            in PrimitiveType.floatingPoint -> "dtoa(this${thisKind.castToIfNecessary(PrimitiveType.DOUBLE)}, isSinglePrecision = ${thisKind == PrimitiveType.FLOAT})"
             PrimitiveType.INT, PrimitiveType.LONG -> "itoa${thisKind.bitSize}(this)"
             else -> "this.toInt().toString()"
         }.setAsExpressionBody()

libraries/stdlib/test/text/StringNumberConversionTest.kt

@@ -8,6 +8,8 @@ package test.text
 import test.TestPlatform
 import test.testExceptOn
 import test.testOn
+import kotlin.math.pow
+import kotlin.math.round
 import kotlin.test.*
 
 private fun testOnNativeAndJvm(action: () -> Unit) {
@@ -802,4 +804,36 @@ class FpNumberToStringTest {
         assertEquals(Float.POSITIVE_INFINITY.toString(), "Infinity")
         assertEquals(Float.NEGATIVE_INFINITY.toString(), "-Infinity")
     }
+
+    @Test
+    fun kt69107() {
+        val a = identity(0.30000001192092F)
+        assertEquals("0.3", (round(a * 10f) / 10f).toString())
+        assertEquals("0.3", (0.3f as Any).toString())
+    }
+
+    @Test
+    fun kt68948() {
+        val inlineTemplate = "${identity(3.4f)}"
+        assertEquals("3.4", inlineTemplate)
+
+        val floatVariable = identity(3.4f)
+        val variableTemplate = "$floatVariable"
+        assertEquals("3.4", variableTemplate)
+    }
+
+    @Test
+    fun kt59118() {
+        fun Float.roundDecimalPlaces(places: Int): Float {
+            if (places < 0) return this
+            val placesFactor: Float = 10f.pow(places.toFloat())
+            return round(this * placesFactor) / placesFactor
+        }
+
+        assertEquals("0.031398475", "" + identity(0.031398475f))
+        assertEquals("0.03", "" + 0.031398475f.roundDecimalPlaces(2))
+    }
+
+    // Prevent compiler constant folding
+    private fun <T> identity(x: T): T = x
 }

libraries/stdlib/wasm/builtins/kotlin/Primitives.kt

@@ -2265,7 +2265,7 @@ public actual class Float private constructor(private val value: Float) : Number
 
     @kotlin.internal.IntrinsicConstEvaluation
     public actual override fun toString(): String =
-        dtoa(this.toDouble())
+        dtoa(this.toDouble(), isSinglePrecision = true)
 
     @kotlin.internal.IntrinsicConstEvaluation
     public actual override fun equals(other: Any?): Boolean =
@@ -2667,7 +2667,7 @@ public actual class Double private constructor(private val value: Double) : Numb
 
     @kotlin.internal.IntrinsicConstEvaluation
     public actual override fun toString(): String =
-        dtoa(this)
+        dtoa(this, isSinglePrecision = false)
 
     @kotlin.internal.IntrinsicConstEvaluation
     public actual override fun equals(other: Any?): Boolean =

libraries/stdlib/wasm/internal/kotlin/wasm/internal/Number2String.kt

@@ -158,7 +158,7 @@ private fun decimalCount64High(value: ULong): Int {
 
 private const val MAX_DOUBLE_LENGTH = 28
 
-internal fun dtoa(value: Double): String {
+internal fun dtoa(value: Double, isSinglePrecision: Boolean): String {
     if (value == 0.0) {
         return if (value.toRawBits() == 0L) "0.0" else "-0.0"
     }
@@ -169,21 +169,21 @@ internal fun dtoa(value: Double): String {
     }
 
     val buf = WasmCharArray(MAX_DOUBLE_LENGTH)
-    val size = dtoaCore(buf, value)
+    val size = dtoaCore(buf, value, isSinglePrecision)
     val ret = WasmCharArray(size)
     buf.copyInto(ret, 0, 0, size)
     return ret.createString()
 }
 
-private fun dtoaCore(buffer: WasmCharArray, valueInp: Double): Int {
+private fun dtoaCore(buffer: WasmCharArray, valueInp: Double, isSinglePrecision: Boolean): Int {
     var value = valueInp
 
     val sign = (value < 0).toInt()
     if (sign == 1) {
         value = -value
         buffer.set(0, CharCodes.MINUS.code.toChar())
     }
-    var len = grisu2(value, buffer, sign)
+    var len = grisu2(value, buffer, sign, isSinglePrecision)
     len = prettify(BufferWithOffset(buffer, sign), len - sign, _K)
     return len + sign
 }
@@ -235,15 +235,36 @@ private val FRC_POWERS = longArrayOf(
     0x9E19DB92B4E31BA9UL.toLong(), 0xEB96BF6EBADF77D9UL.toLong(), 0xAF87023B9BF0EE6BUL.toLong()
 )
 
-private fun grisu2(value: Double, buffer: WasmCharArray, sign: Int): Int {
+private const val SINGLE_SIGNIFICANT_MASK = 0x007FFFFF
+private const val SINGLE_EXPONENT_MASK = 0x7F800000
+private const val SINGLE_SIGNIFICANT_SIZE = 23  // Excluding hidden bit
+private const val SINGLE_EXPONENT_BIAS = 0x7F + SINGLE_SIGNIFICANT_SIZE
+
+private const val DOUBLE_SIGNIFICANT_MASK = 0x000FFFFFFFFFFFFFL
+private const val DOUBLE_EXPONENT_MASK = 0x7FF0000000000000L
+private const val DOUBLE_SIGNIFICANT_SIZE = 52  // Excluding hidden bit
+private const val DOUBLE_EXPONENT_BIAS = 0x3FF + DOUBLE_SIGNIFICANT_SIZE
+
+private fun grisu2(value: Double, buffer: WasmCharArray, sign: Int, isSinglePrecision: Boolean): Int {
+    var frc: Long
+    var exp: Int
+
     // frexp routine
-    val uv = value.toBits()
-    var exp = ((uv and 0x7FF0000000000000) ushr 52).toInt()
-    val sid = uv and 0x000FFFFFFFFFFFFF
-    var frc = ((exp != 0).toLong() shl 52) + sid
-    exp = (if (exp != 0) exp else 1) - (0x3FF + 52)
+    if (isSinglePrecision) {
+        val uv = value.toFloat().toBits()
+        exp = (uv and SINGLE_EXPONENT_MASK) ushr SINGLE_SIGNIFICANT_SIZE
+        val sid = uv and SINGLE_SIGNIFICANT_MASK
+        frc = ((exp != 0).toLong() shl SINGLE_SIGNIFICANT_SIZE) + sid
+        exp = (if (exp != 0) exp else 1) - SINGLE_EXPONENT_BIAS
+    } else {
+        val uv = value.toBits()
+        exp = ((uv and DOUBLE_EXPONENT_MASK) ushr DOUBLE_SIGNIFICANT_SIZE).toInt()
+        val sid = uv and DOUBLE_SIGNIFICANT_MASK
+        frc = ((exp != 0).toLong() shl DOUBLE_SIGNIFICANT_SIZE) + sid
+        exp = (if (exp != 0) exp else 1) - DOUBLE_EXPONENT_BIAS
+    }
 
-    normalizedBoundaries(frc, exp)
+    normalizedBoundaries(frc, exp, isSinglePrecision)
     getCachedPower(_exp)
 
     // normalize
@@ -288,14 +309,15 @@ private fun umul64e(e1: Int, e2: Int): Int {
     return e1 + e2 + 64 // where 64 is significand size
 }
 
-private fun normalizedBoundaries(f: Long, e: Int) {
+private fun normalizedBoundaries(f: Long, e: Int, isSinglePrecision: Boolean) {
     var frc = (f shl 1) + 1
     var exp = e - 1
     val off = frc.countLeadingZeroBits()
     frc = frc shl off
     exp -= off
 
-    val m = 1 + (f == 0x0010000000000000).toInt()
+    val smallestNormalizedSignificand: Long = if (isSinglePrecision) 0x00800000 else 0x0010000000000000
+    val m = 1 + (f == smallestNormalizedSignificand).toInt()
 
     _frc_plus = frc
     _frc_minus = ((f shl m) - 1) shl e - m - exp