fix: use single precision for dtoa with f32

Author: mattjohnsonpint

std/assembly/number.ts

@@ -1,4 +1,4 @@
-import { itoa32, utoa32, itoa64, utoa64, dtoa } from "./util/number";
+import { itoa32, utoa32, itoa64, utoa64, dtoa32, dtoa64 } from "./util/number";
 import { strtol, strtod } from "./util/string";
 
 // @ts-ignore: decorator
@@ -315,7 +315,7 @@ export abstract class F32 {
   }
 
   toString(this: f32, radix: i32 = 0): String {
-    return dtoa(this);
+    return dtoa32(this);
   }
 }
 
@@ -381,7 +381,7 @@ export abstract class F64 {
   }
 
   toString(this: f64, radix: i32 = 0): String {
-    return dtoa(this);
+    return dtoa64(this);
   }
 }
 

std/assembly/util/number.ts

@@ -474,7 +474,7 @@ export function itoa64(value: i64, radix: i32): String {
 @lazy let _frc_minus: u64 = 0;
 
 // @ts-ignore: decorator
-@lazy let _frc_plus:  u64 = 0;
+@lazy let _frc_plus: u64 = 0;
 
 // @ts-ignore: decorator
 @lazy let _frc_pow: u64 = 0;
@@ -511,14 +511,14 @@ function umul64e(e1: i32, e2: i32): i32 {
 
 // @ts-ignore: decorator
 @inline
-function normalizedBoundaries(f: u64, e: i32): void {
+function normalizedBoundaries(f: u64, e: i32, isSinglePrecision: bool): void {
   let frc = (f << 1) + 1;
   let exp = e - 1;
   let off = <i32>clz<u64>(frc);
   frc <<= off;
   exp  -= off;
 
-  let m = 1 + i32(f == 0x0010000000000000);
+  let m = 1 + i32(f == (isSinglePrecision ? 0x00800000 : 0x0010000000000000));
 
   _frc_plus  = frc;
   _frc_minus = ((f << m) - 1) << e - m - exp;
@@ -559,16 +559,26 @@ function getCachedPower(minExp: i32): void {
 
 // @ts-ignore: decorator
 @inline
-function grisu2(value: f64, buffer: usize, sign: i32): i32 {
+function grisu2(value: f64, buffer: usize, sign: i32, isSinglePrecision: bool): i32 {
+  let frc: u64;
+  let exp: i32;
 
   // frexp routine
-  let uv  = reinterpret<u64>(value);
-  let exp = i32((uv & 0x7FF0000000000000) >>> 52);
-  let sid = uv & 0x000FFFFFFFFFFFFF;
-  let frc = (u64(exp != 0) << 52) + sid;
-  exp = select<i32>(exp, 1, exp) - (0x3FF + 52);
+  if (isSinglePrecision) {
+    let uv  = reinterpret<u32>(<f32>value);
+    exp = (uv & 0x7F800000) >>> 23;
+    let sid = uv & 0x007FFFFF;
+    frc = (u64(exp != 0) << 23) + sid;
+    exp = select<i32>(exp, 1, exp) - (0x7F + 23);
+  } else {
+    let uv  = reinterpret<u64>(value);
+    exp = i32((uv & 0x7FF0000000000000) >>> 52);
+    let sid = uv & 0x000FFFFFFFFFFFFF;
+    frc = (u64(exp != 0) << 52) + sid;
+    exp = select<i32>(exp, 1, exp) - (0x3FF + 52);
+  }
 
-  normalizedBoundaries(frc, exp);
+  normalizedBoundaries(frc, exp, isSinglePrecision);
   getCachedPower(_exp);
 
   // normalize
@@ -716,28 +726,47 @@ function prettify(buffer: usize, length: i32, k: i32): i32 {
   }
 }
 
-function dtoa_core(buffer: usize, value: f64): i32 {
+function dtoa_core(buffer: usize, value: f64, isSinglePrecision: bool): i32 {
   let sign = i32(value < 0);
   if (sign) {
     value = -value;
     store<u16>(buffer, CharCode.MINUS);
   }
-  // assert(value > 0 && value <= 1.7976931348623157e308);
-  let len = grisu2(value, buffer, sign);
+  // assert(value > 0 && value <= (isSinglePrecision ? f32.MAX_VALUE : f64.MAX_VALUE));
+  let len = grisu2(value, buffer, sign, isSinglePrecision);
   len = prettify(buffer + (sign << 1), len - sign, _K);
   return len + sign;
 }
 
 // @ts-ignore: decorator
 @lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);
 
-export function dtoa(value: f64): String {
+export function dtoa<T extends number>(value: T): String {
+  // assert(isFloat<T>());
+  if (sizeof<T>() == 4) {
+    return dtoa_impl(<f32>value, true);
+  } else {
+    return dtoa_impl(<f64>value, false);
+  }
+}
+
+export function dtoa32(value: f32): String {
+  return dtoa_impl(value, true);
+}
+
+export function dtoa64(value: f64): String {
+  return dtoa_impl(value, false);
+}
+
+// @ts-ignore: decorator
+@inline
+function dtoa_impl(value: f64, isSinglePrecision: bool): String {
   if (value == 0) return "0.0";
   if (!isFinite(value)) {
     if (isNaN(value)) return "NaN";
     return select<String>("-Infinity", "Infinity", value < 0);
   }
-  let size = dtoa_core(dtoa_buf, value) << 1;
+  let size = dtoa_core(dtoa_buf, value, isSinglePrecision) << 1;
   let result = changetype<String>(__new(size, idof<String>()));
   memory.copy(changetype<usize>(result), dtoa_buf, size);
   return result;
@@ -821,7 +850,18 @@ export function itoa_buffered<T extends number>(buffer: usize, value: T): u32 {
   return sign + decimals;
 }
 
-export function dtoa_buffered(buffer: usize, value: f64): u32 {
+export function dtoa_buffered<T extends number>(buffer: usize, value: T): u32 {
+  // assert(isFloat<T>());
+  if (sizeof<T>() == 4) {
+    return dtoa_buffered_impl(buffer, <f32>value, true);
+  } else {
+    return dtoa_buffered_impl(buffer, <f64>value, false);
+  }
+}
+
+// @ts-ignore: decorator
+@inline
+function dtoa_buffered_impl(buffer: usize, value: f64, isSinglePrecision: bool): u32 {
   if (value == 0) {
     store<u16>(buffer, CharCode._0);
     store<u16>(buffer, CharCode.DOT, 2);
@@ -845,5 +885,5 @@ export function dtoa_buffered(buffer: usize, value: f64): u32 {
       return 8 + u32(sign);
     }
   }
-  return dtoa_core(buffer, value);
+  return dtoa_core(buffer, value, isSinglePrecision);
 }