Use more native math functions

Author: zbynek

user/super/com/google/gwt/emul/java/lang/Math.java

@@ -26,12 +26,6 @@
  * Math utility methods and constants.
  */
 public final class Math {
-  // The following methods are not implemented because JS doesn't provide the
-  // necessary pieces:
-  //   public static double ulp (double x)
-  //   public static float ulp (float x)
-  //   public static int getExponent (double d)
-  //   public static int getExponent (float f)
 
   public static final double E = 2.7182818284590452354;
   public static final double PI = 3.14159265358979323846;
@@ -87,9 +81,8 @@ public static long addExact(long x, long y) {
   @JsMethod(namespace = JsPackage.GLOBAL, name = "Math.atan2")
   public static native double atan2(double y, double x);
 
-  public static double cbrt(double x) {
-    return x == 0 || !Double.isFinite(x) ? x : pow(x, 1.0 / 3.0);
-  }
+  @JsMethod(namespace = JsPackage.GLOBAL, name = "Math.cbrt")
+  public static native double cbrt(double x);
 
   @JsMethod(namespace = JsPackage.GLOBAL, name = "Math.ceil")
   public static native double ceil(double x);
@@ -109,9 +102,8 @@ public static float copySign(float magnitude, float sign) {
   @JsMethod(namespace = JsPackage.GLOBAL, name = "Math.cos")
   public static native double cos(double x);
 
-  public static double cosh(double x) {
-    return (exp(x) + exp(-x)) / 2;
-  }
+  @JsMethod(namespace = JsPackage.GLOBAL, name = "Math.cosh")
+  public static native double cosh(double x);
 
   public static int decrementExact(int x) {
     checkCriticalArithmetic(x != Integer.MIN_VALUE);
@@ -144,6 +136,10 @@ public static long floorDiv(long dividend, long divisor) {
     return ((dividend ^ divisor) >= 0 ? dividend / divisor : ((dividend + 1) / divisor) - 1);
   }
 
+  public static long floorDiv(long dividend, int divisor) {
+    return floorDiv(dividend, (long) divisor);
+  }
+
   public static int floorMod(int dividend, int divisor) {
     checkCriticalArithmetic(divisor != 0);
     return ((dividend % divisor) + divisor) % divisor;
@@ -154,6 +150,10 @@ public static long floorMod(long dividend, long divisor) {
     return ((dividend % divisor) + divisor) % divisor;
   }
 
+  public static long floorMod(long dividend, int divisor) {
+    return floorMod(dividend, (long) divisor);
+  }
+
   @SuppressWarnings("CheckStyle.MethodName")
   public static double IEEEremainder(double v, double m) {
     double ratio = v / m;
@@ -175,6 +175,25 @@ public static int getExponent(float v) {
     return ((JsUtils.floatToRawIntBits(v) >> 23) & 255) - Float.MAX_EXPONENT;
   }
 
+  public static double ulp(double v) {
+    if (!Double.isFinite(v)) {
+      return Math.abs(v);
+    }
+    int exponent = Math.getExponent(v);
+    if (exponent == -1023) {
+      return Double.MIN_VALUE;
+    }
+    return Math.pow(2, exponent - 52);
+  }
+
+  public static float ulp(float v) {
+    int exponent = Math.getExponent(v);
+    if (exponent == -Float.MAX_EXPONENT) {
+      return Float.MIN_VALUE;
+    }
+    return (float) Math.pow(2, exponent - 23);
+  }
+
   @JsMethod(namespace = JsPackage.GLOBAL, name = "Math.hypot")
   public static native double hypot(double x, double y);
 
@@ -191,9 +210,8 @@ public static long incrementExact(long x) {
   @JsMethod(namespace = JsPackage.GLOBAL, name = "Math.log")
   public static native double log(double x);
 
-  public static double log10(double x) {
-    return log(x) * NativeMath.LOG10E;
-  }
+  @JsMethod(namespace = JsPackage.GLOBAL, name = "Math.log10")
+  public static native double log10(double x);
 
   @JsMethod(namespace = JsPackage.GLOBAL, name = "Math.log1p")
   public static native double log1p(double x);
@@ -224,12 +242,28 @@ public static long min(long x, long y) {
     return x < y ? x : y;
   }
 
+  public static long multiplyFull(int x, int y) {
+    return (long) x * (long) y;
+  }
+
   public static int multiplyExact(int x, int y) {
     double r = (double) x * (double) y;
     checkCriticalArithmetic(isSafeIntegerRange(r));
     return (int) r;
   }
 
+  public static long multiplyExact(long x, int y) {
+    if (y == -1) {
+      return negateExact(x);
+    }
+    if (y == 0) {
+      return 0;
+    }
+    long r = x * y;
+    checkCriticalArithmetic(r / y == x);
+    return r;
+  }
+
   public static long multiplyExact(long x, long y) {
     if (y == -1) {
       return negateExact(x);
@@ -311,13 +345,8 @@ public static float scalb(float f, int scaleFactor) {
     return (float) scalb((double) f, scaleFactor);
   }
 
-  public static double signum(double d) {
-    if (d == 0 || Double.isNaN(d)) {
-      return d;
-    } else {
-      return d < 0 ? -1 : 1;
-    }
-  }
+  @JsMethod(namespace = JsPackage.GLOBAL, name = "Math.sign")
+  public static native double signum(double d);
 
   public static float signum(float f) {
     return (float) signum((double) f);
@@ -326,28 +355,17 @@ public static float signum(float f) {
   @JsMethod(namespace = JsPackage.GLOBAL, name = "Math.sin")
   public static native double sin(double x);
 
-  public static double sinh(double x) {
-    return x == 0.0 ? x : (exp(x) - exp(-x)) / 2;
-  }
+  @JsMethod(namespace = JsPackage.GLOBAL, name = "Math.sinh")
+  public static native double sinh(double x);
 
   @JsMethod(namespace = JsPackage.GLOBAL, name = "Math.sqrt")
   public static native double sqrt(double x);
 
   @JsMethod(namespace = JsPackage.GLOBAL, name = "Math.tan")
   public static native double tan(double x);
 
-  public static double tanh(double x) {
-    if (x == 0.0) {
-      // -0.0 should return -0.0.
-      return x;
-    }
-
-    double e2x = exp(2 * x);
-    if (Double.isInfinite(e2x)) {
-      return 1;
-    }
-    return (e2x - 1) / (e2x + 1);
-  }
+  @JsMethod(namespace = JsPackage.GLOBAL, name = "Math.tanh")
+  public static native double tanh(double x);
 
   public static double toDegrees(double x) {
     return x * PI_UNDER_180;
@@ -438,7 +456,6 @@ private static boolean isSafeIntegerRange(double value) {
 
   @JsType(isNative = true, name = "Math", namespace = JsPackage.GLOBAL)
   private static class NativeMath {
-    public static double LOG10E;
     public static native double round(double x);
   }
 }

user/test-super/com/google/gwt/emultest/super/com/google/gwt/emultest/java17/lang/MathTest.java

@@ -44,14 +44,6 @@ public void testAbsExactWithFolding() {
     assertThrowsArithmetic(() -> Math.absExact(Long.MIN_VALUE));
   }
 
-  private <T> T hideFromCompiler(T value) {
-    if (Math.random() < -1) {
-      // Can never happen, but fools the compiler enough not to optimize this call.
-      fail();
-    }
-    return value;
-  }
-
   private void assertThrowsArithmetic(Runnable check) {
     try {
       check.run();

user/test/com/google/gwt/emultest/java/lang/DoubleTest.java

@@ -161,10 +161,8 @@ public void testDoubleConstants() {
     assertTrue(Double.MIN_VALUE < Double.MAX_VALUE);
     assertFalse(Double.NaN == Double.NaN);
     assertEquals(64, Double.SIZE);
-    // jdk1.6 assertEquals(Math.getExponent(Double.MAX_VALUE),
-    // Double.MAX_EXPONENT);
-    // jdk1.6 assertEquals(Math.getExponent(Double.MIN_NORMAL),
-    // Double.MIN_EXPONENT);
+    assertEquals(Math.getExponent(Double.MAX_VALUE), Double.MAX_EXPONENT);
+    assertEquals(Math.getExponent(Double.MIN_NORMAL), Double.MIN_EXPONENT);
     // issue 8073 - used to fail in prod mode
     assertFalse(Double.isInfinite(Double.NaN));
   }