Parse float in pure Wasm #106

tanishiking · 2025-09-09T12:32:53Z

Implement bellerophon algorithm from "How to Read Floating Point Numbers Accurately" by William D. Clinger

TODO:

corner cases
- overflow
- underflow (subnormal / negative infinity)
Parse double
Parse hex (should be in another PR)
- Math.pow and Long.parseLong are required
more test cases
- maybe we wanna copy test cases from somewhere

sjrd · 2025-09-09T12:56:29Z

javalib/src/main/scala/java/lang/Float.scala


-  def parseFloat(s: String): scala.Float = {
-    import Utils._
+  private[this] val parseFloatImpl = linkTimeIf[ParseFloatRegExpImpl](isWebAssembly) {


This will be needed elsewhere. Perhaps define it once and for all in an object in java.util.regex.*?

sjrd · 2025-09-09T12:59:39Z

javalib/src/main/scala/java/math/BigInteger.scala

  override def toString(): String =
-    Conversion.toDecimalScaledString(this)
+    linkTimeIf(targetPureWasm) {
+      "" // TODO: Integer.toUnsignedString


If all you need is Integer.toUnsignedString(i: Int), you can trivially implement that one as Long.toString(Integer.toUnsignedLong(i)). Those two methods are already implemented.

sjrd · 2025-09-09T13:10:53Z

javalib/src/main/scala/java/lang/dec2flt/Tables.scala

+   *  5^e < 2^64 <=> e < log5(2^64) <=> e < 27.563299716697156...
+   */
+  val smallPowerOfTens = Array[FloatingPoint](
+    FloatingPoint.normalized(new BigInteger("8000000000000000", 16), -63), // 0


It seems all the constants here are unsigned Long values. Store them as such, and convert them to BigInteger without having to parse a string?

This can be done with a small helper like

def ulongToBigInt(x: Long): BigInteger = if (x >= 0L) BigInteger.valueOf(x) else BigInteger.valueOf(x & ~Long.MinValue).setBit(63)

sjrd · 2025-09-09T13:19:26Z

javalib/src/main/scala/java/lang/dec2flt/Constants.scala

+private[lang] object Constants {
+
+  final val ExtendedSigBits = 64
+  final val ExtendedMaxSig = BigInteger.TWO.pow(ExtendedSigBits)


Suggested change

final val ExtendedMaxSig = BigInteger.TWO.pow(ExtendedSigBits)

final val ExtendedMaxSig = BigInteger.ONE.shiftLeft(ExtendedSigBits)

or even

Suggested change

final val ExtendedMaxSig = BigInteger.TWO.pow(ExtendedSigBits)

final val ExtendedMaxSig = BigInteger.ZERO.setBit(ExtendedSigBits)

?

sjrd · 2025-09-09T13:21:45Z

javalib/src/main/scala/java/lang/dec2flt/FloatingPoint.scala

+/** DIY floating point number with 64-bit significand bits */
+private[dec2flt] class FloatingPoint private (val f: BigInteger, val e: Int) {


Does it always stay within 64 significant bits? If yes, why not use a Long (interpreted as unsigned) instead of a BigInteger?

You're right. When multiplying these 64-bit floating-point numbers, an intermediate integer is up to 128 bits, but this could be represented by two Longs, and the result is immediately normalized back into the 64-bit range. So, it seems we can avoid using BigInteger here 👍

sjrd · 2025-10-21T15:30:03Z

javalib/src/main/scala/java/lang/Double.scala

+      linkTimeIf(targetPureWasm) {
+        // java.lang.Long.parseLong may fail with NumberFormatException
+        // for a large input.
+        new BigInteger(s, radix).doubleValue()


When parsing truncatedMantissaStr, you should be able to use parseUnsignedLong. The largest possible string for truncatedMantissaStr is "f" * 15 + "1", which correctly (though barely) parses to -15L.

When parsing binaryExpStr, if the string has more than 11 chars (10 digits and 1 sign), you can saturate it to Int.MinValue/Int.MaxValue (depending on the sign) without parsing it. If it has at most 11 chars, you can correctly parse it with parseLong (and then convert to Int with saturation; not wrapping).

Ah, right, since maxPrecisionChars = 15 it always fit in unsigned 64 bit integer 👍

sjrd · 2025-10-21T15:35:09Z

javalib/src/main/scala/java/lang/Double.scala

+        js.Dynamic.global.parseInt(s, radix).asInstanceOf[scala.Double]
+      }

    val mantissa = nativeParseInt(truncatedMantissaStr, 16)


So, concretely, I would leave nativeParseInt as being nativeJSParseInt and do

Suggested change

val mantissa = nativeParseInt(truncatedMantissaStr, 16)

val mantissa = linkTimeIf(targetPureWasm) {

val mantissaLong = Long.parseUnsignedLong(truncatedMantissaStr, 16)

// convert unsigned long to double

(mantissaLong >>> 32).toDouble * (1L << 32) + (mantissaLong & 0xffffffffL).toDouble

} {

nativeJSParseInt(truncatedMantissaStr, 16)

}

and below, for the computation of binaryExp (which does not show up in the diff so I can't comment on it directly):

val binaryExp = linkTimeIf(targetPureWasm) { if (binaryExpStr.length() > 11) { if (binaryExpStr.charAt(0) = '-') Int.MinValue else Int.MaxValue } else { val binaryExpLong = Long.parseLong(binaryExpStr) if (binaryExpLong > Int.MaxValue.toLong) Int.MaxValue else if (binaryExpLong < Int.MinValue.toLong) Int.MinValue else binaryExpLong.toInt } } { val binaryExpDouble = nativeParseInt(binaryExpStr, 10) binaryExpDouble.toInt // caps to [MinValue, MaxValue] }

sjrd · 2025-10-21T15:39:59Z

javalib/src/main/scala/java/lang/Double.scala

 package java.lang

 import java.lang.constant.{Constable, ConstantDesc}
+import java.math.BigInteger


Consider importing that only in the relevant methods, since it is a large dependency that we shouldn't use lightly.

The input mantissa for Bellerophon still needs to be parsed as a BigInteger.
Other dependencies should be eliminated once Math.scalb implementation is merged.

sjrd · 2025-10-21T15:52:30Z

javalib/src/main/scala/java/math/Conversion.scala

-      val absStr = Integer.toUnsignedString(digits(0))
+      // TODO: Integer.toUnsignedString hasn't yet implemented in Wasm
+      val absStr = linkTimeIf(targetPureWasm) {
+          java.lang.Long.toString(Integer.toUnsignedLong(digits(0)))


You could push that one step further into Integer.toUnsignedString.

sjrd · 2025-10-21T15:53:11Z

test-suite/shared/src/test/scala/org/scalajs/testsuite/javalib/lang/DoubleTest.scala

      testFull("-87654.321", -87654.321)
      testFull("+.3f", 0.3)

-      // Hex notation, with exactly the output of toHexString()


Lost comment here :)

tanishiking · 2025-10-24T16:43:50Z

@sjrd Thank you for comments! Once scala-js#5251 is merged, I'm planning to rebase on it.
Could you take a quick look especially on hex parsing? (we might want to do a serious code review on Bellorophon implementation when we upstream it?)

sjrd reviewed Sep 9, 2025

View reviewed changes

tanishiking force-pushed the parse-float-pure-wasm branch from 623ce2e to 9b443e5 Compare September 22, 2025 06:53

tanishiking changed the title ~~WIP: Parse float in pure Wasm~~ Parse float in pure Wasm Oct 1, 2025

tanishiking marked this pull request as ready for review October 1, 2025 08:58

sjrd mentioned this pull request Oct 1, 2025

Wasm-friendly implementation of parse{Unsigned,}Long. scala-js/scala-js#5242

Merged

tanishiking added 11 commits October 18, 2025 16:53

Use Java Regex in Float for pure Wasm

7facc1d

Bellerophon

ef9a062

Fix overflow

bcdebb2

Support subnormal numbers

c2d4219

Implement BigInteger.toString

21ea24d

Add RegExpImpl to switch regex implementation across different platforms

ed30657

Make Bellerophon generic to both Float and Double

7f0e547

Use (unsigned) Long for DIY FloatingPoint's significand

98a118b

Use BigInteger.ZERO.setBit for power of 2

e55f70c

Use parse(Float|Double)Wasm only when targeting pure Wasm

462cf4c

Support parseFloat and Double for hex input

422379d

tanishiking force-pushed the parse-float-pure-wasm branch from 5f4f0b5 to 422379d Compare October 18, 2025 17:39

sjrd mentioned this pull request Oct 21, 2025

Implement jl.Math.scalb. scala-js/scala-js#5251

Open

sjrd reviewed Oct 21, 2025

View reviewed changes

parseUnsignedLong for hex mantissa and exponent

a551be5

	final val ExtendedMaxSig = BigInteger.TWO.pow(ExtendedSigBits)
	final val ExtendedMaxSig = BigInteger.ONE.shiftLeft(ExtendedSigBits)

	final val ExtendedMaxSig = BigInteger.TWO.pow(ExtendedSigBits)
	final val ExtendedMaxSig = BigInteger.ZERO.setBit(ExtendedSigBits)

		/** DIY floating point number with 64-bit significand bits */
		private[dec2flt] class FloatingPoint private (val f: BigInteger, val e: Int) {

-    val mantissa = nativeParseInt(truncatedMantissaStr, 16)
+    val mantissa = linkTimeIf(targetPureWasm) {
+      val mantissaLong = Long.parseUnsignedLong(truncatedMantissaStr, 16)
+      // convert unsigned long to double
+      (mantissaLong >>> 32).toDouble * (1L << 32) + (mantissaLong & 0xffffffffL).toDouble
+    } {
+      nativeJSParseInt(truncatedMantissaStr, 16)
+    }

Parse float in pure Wasm #106

Are you sure you want to change the base?

Parse float in pure Wasm #106

Conversation

tanishiking commented Sep 9, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

sjrd Oct 21, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

tanishiking commented Oct 24, 2025

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

tanishiking commented Sep 9, 2025 •

edited

Loading

sjrd Oct 21, 2025 •

edited

Loading