Replace the NumberToString implementation

Replace the NumberToString implementation with the Schubfach algorithm.
This is a relatively new algorithm used in many standard libraries including Java. We use
code by Rafaello Guilietti that has also been adapted for Jackson
and for the JDK.

Author: gbrail

NOTICE.txt

@@ -32,4 +32,29 @@ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----
+
+Portions of the number-to-string code are subject to the following:
+
+ Copyright 2018-2020 Raffaello Giulietti
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ 

benchmarks/src/jmh/java/org/mozilla/javascript/benchmarks/NumberFormatBenchmark.java

@@ -0,0 +1,37 @@
+package org.mozilla.javascript.benchmarks;
+
+import java.util.concurrent.TimeUnit;
+import org.mozilla.javascript.ScriptRuntime;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+public class NumberFormatBenchmark {
+
+    private static final double DENORMAL = 4.47118444E-314;
+
+    @Benchmark
+    public Object scriptRuntimePi() {
+        return ScriptRuntime.toString(Math.PI);
+    }
+
+    @Benchmark
+    public Object scriptRuntimeOne() {
+        return ScriptRuntime.toString(1.0);
+    }
+
+    @Benchmark
+    public Object scriptRuntimeDenormal() {
+        return ScriptRuntime.toString(DENORMAL);
+    }
+
+    @Benchmark
+    public Object scriptRuntimeSmall() {
+        return ScriptRuntime.toString(0.00001);
+    }
+
+    @Benchmark
+    public Object scriptRuntimeBig() {
+        return ScriptRuntime.toString(314000000000000000000.0);
+    }
+}

it-android/src/main/assets/tests/numbers.js

@@ -0,0 +1,5 @@
+assertEquals('1', (1).toString());
+assertEquals('3.141592653589793', (Math.PI).toString());
+assertEquals('3.1416', (Math.PI).toFixed(4));
+assertEquals('3.142', (Math.PI).toPrecision(4));
+'success';

rhino/src/main/java/org/mozilla/javascript/ScriptRuntime.java

@@ -23,6 +23,7 @@
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 import org.mozilla.javascript.ast.FunctionNode;
+import org.mozilla.javascript.dtoa.DoubleFormatter;
 import org.mozilla.javascript.lc.type.TypeInfo;
 import org.mozilla.javascript.lc.type.impl.factory.ConcurrentFactory;
 import org.mozilla.javascript.typedarrays.NativeArrayBuffer;
@@ -39,7 +40,6 @@
 import org.mozilla.javascript.typedarrays.NativeUint8Array;
 import org.mozilla.javascript.typedarrays.NativeUint8ClampedArray;
 import org.mozilla.javascript.v8dtoa.DoubleConversion;
-import org.mozilla.javascript.v8dtoa.FastDtoa;
 import org.mozilla.javascript.xml.XMLLib;
 import org.mozilla.javascript.xml.XMLLoader;
 import org.mozilla.javascript.xml.XMLObject;
@@ -1051,27 +1051,20 @@ public static String toString(double val) {
     }
 
     public static String numberToString(double d, int base) {
+        if (base == 10) {
+            // Common case: DoubleFormatter efficiently identifies non-finite
+            // numbers. Do this before other checks.
+            return DoubleFormatter.toString(d);
+        }
+
         if ((base < 2) || (base > 36)) {
             throw ScriptRuntime.rangeErrorById("msg.bad.radix", Integer.toString(base));
         }
-
         if (Double.isNaN(d)) return "NaN";
         if (d == Double.POSITIVE_INFINITY) return "Infinity";
         if (d == Double.NEGATIVE_INFINITY) return "-Infinity";
         if (d == 0.0) return "0";
-
-        if (base != 10) {
-            return DToA.JS_dtobasestr(base, d);
-        }
-        // V8 FastDtoa can't convert all numbers, so try it first but
-        // fall back to old DToA in case it fails
-        String result = FastDtoa.numberToString(d);
-        if (result != null) {
-            return result;
-        }
-        StringBuilder buffer = new StringBuilder();
-        DToA.JS_dtostr(buffer, DToA.DTOSTR_STANDARD, 0, d);
-        return buffer.toString();
+        return DToA.JS_dtobasestr(base, d);
     }
 
     public static String bigIntToString(BigInteger n, int base) {