Use more native math functions

Author: zbynek

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

@@ -87,9 +87,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 +108,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);
@@ -191,9 +189,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 +221,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 +324,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 +334,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 +435,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/java8/lang/MathTest.java

@@ -225,6 +225,45 @@ public void testMultiplyExactLongs() {
     }
   }
 
+  public void testMultiplyExactLongInt() {
+    for (long a : ALL_LONG_CANDIDATES) {
+      for (int b : ALL_INTEGER_CANDIDATES) {
+        BigInteger expectedResult = BigInteger.valueOf(a).multiply(BigInteger.valueOf(b));
+        boolean expectedSuccess = fitsInLong(expectedResult);
+        try {
+          assertEquals(a * b, Math.multiplyExact(a, b));
+          assertTrue(expectedSuccess);
+        } catch (ArithmeticException e) {
+          assertFalse(expectedSuccess);
+        }
+      }
+    }
+  }
+
+  public void testMultiplyFull() {
+    assertEquals(1L, Long.MAX_VALUE
+        - Math.multiplyFull(Integer.MAX_VALUE, Integer.MAX_VALUE) * 2 - 4L * Integer.MAX_VALUE);
+    assertEquals(-1L, Long.MAX_VALUE
+        - 2 * Math.multiplyFull(Integer.MIN_VALUE, Integer.MIN_VALUE));
+
+    assertEquals(1L, hideFromCompiler(Long.MAX_VALUE)
+        - Math.multiplyFull(Integer.MAX_VALUE, Integer.MAX_VALUE) * 2 - 4L * Integer.MAX_VALUE);
+    assertEquals(-1L, hideFromCompiler(Long.MAX_VALUE)
+        - 2 * Math.multiplyFull(Integer.MIN_VALUE, Integer.MIN_VALUE));
+  }
+
+  public void testCbrt() {
+    assertEquals(-2, Math.cbrt(-8), EPS);
+    assertEquals(Double.POSITIVE_INFINITY, Math.cbrt(Double.POSITIVE_INFINITY), EPS);
+    assertEquals(Double.NEGATIVE_INFINITY, Math.cbrt(Double.NEGATIVE_INFINITY), EPS);
+
+    assertEquals(-2, Math.cbrt(hideFromCompiler(-8)), EPS);
+    assertEquals(Double.POSITIVE_INFINITY,
+        Math.cbrt(hideFromCompiler(Double.POSITIVE_INFINITY)), EPS);
+    assertEquals(Double.NEGATIVE_INFINITY,
+        Math.cbrt(hideFromCompiler(Double.NEGATIVE_INFINITY)), EPS);
+  }
+
   public void testNegateExact() {
     for (int a : ALL_INTEGER_CANDIDATES) {
       BigInteger expectedResult = BigInteger.valueOf(a).negate();