/*
* Copyright 2008 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package java.lang;
/**
* 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 double IEEEremainder(double f1, double f2)
// public static double nextAfter(double start, double direction)
// public static float nextAfter(float start, float direction)
// public static double nextUp(double start) {
// return nextAfter(start, 1.0d);
// }
// public static float nextUp(float start) {
// return nextAfter(start,1.0f);
// }
public static final double E = 2.7182818284590452354;
public static final double PI = 3.14159265358979323846;
private static final double PI_OVER_180 = PI / 180.0;
private static final double PI_UNDER_180 = 180.0 / PI;
public static double abs(double x) {
// This is implemented this way so that either positive or negative zeroes
// get converted to positive zeros.
// See http://www.concentric.net/~Ttwang/tech/javafloat.htm for details.
return x <= 0 ? 0.0 - x : x;
}
public static float abs(float x) {
return (float) abs((double) x);
}
public static int abs(int x) {
return x < 0 ? -x : x;
}
public static long abs(long x) {
return x < 0 ? -x : x;
}
public static native double acos(double x) /*-{
return Math.acos(x);
}-*/;
public static native double asin(double x) /*-{
return Math.asin(x);
}-*/;
public static native double atan(double x) /*-{
return Math.atan(x);
}-*/;
public static native double atan2(double y, double x) /*-{
return Math.atan2(y, x);
}-*/;
public static double cbrt(double x) {
return Math.pow(x, 1.0 / 3.0);
}
public static native double ceil(double x) /*-{
return Math.ceil(x);
}-*/;
public static double copySign(double magnitude, double sign) {
if (sign < 0) {
return (magnitude < 0) ? magnitude : -magnitude;
} else {
return (magnitude > 0) ? magnitude : -magnitude;
}
}
public static float copySign(float magnitude, float sign) {
return (float) (copySign((double) magnitude, (double) sign));
}
public static native double cos(double x) /*-{
return Math.cos(x);
}-*/;
public static native double cosh(double x) /*-{
return (Math.exp(x) + Math.exp(-x)) / 2.0;
}-*/;
public static native double exp(double x) /*-{
return Math.exp(x);
}-*/;
public static double expm1(double d) {
if (d == 0.0 || Double.isNaN(d)) {
return d; // "a zero with same sign as argument", arg is zero, so...
} else if (!Double.isInfinite(d)) {
if (d < 0.0d) {
return -1.0d;
} else {
return Double.POSITIVE_INFINITY;
}
}
return exp(d) + 1.0d;
}
public static native double floor(double x) /*-{
return Math.floor(x);
}-*/;
public static double hypot(double x, double y) {
return sqrt(x * x + y * y);
}
public static native double log(double x) /*-{
return Math.log(x);
}-*/;
public static native double log10(double x) /*-{
return Math.log(x) * Math.LOG10E;
}-*/;
public static double log1p(double x) {
return Math.log(x + 1.0d);
}
public static double max(double x, double y) {
return x > y ? x : y;
}
public static float max(float x, float y) {
return x > y ? x : y;
}
public static int max(int x, int y) {
return x > y ? x : y;
}
public static long max(long x, long y) {
return x > y ? x : y;
}
public static double min(double x, double y) {
return x < y ? x : y;
}
public static float min(float x, float y) {
return x < y ? x : y;
}
public static int min(int x, int y) {
return x < y ? x : y;
}
public static long min(long x, long y) {
return x < y ? x : y;
}
public static native double pow(double x, double exp) /*-{
return Math.pow(x, exp);
}-*/;
public static native double random() /*-{
return Math.random();
}-*/;
public static double rint(double d) {
if (Double.isNaN(d)) {
return d;
} else if (Double.isInfinite(d)) {
return d;
} else if (d == 0.0d) {
return d;
} else {
return round(d);
}
}
public static long round(double x) {
return (long) round0(x);
}
public static native int round(float x) /*-{
return Math.round(x);
}-*/;
public static double scalb(double d, int scaleFactor) {
if (scaleFactor > 0) {
return d * (1 << scaleFactor);
} else if (scaleFactor == 0) {
return d;
} else {
return d * 1.0d / (1 << -scaleFactor);
}
}
public static float scalb(float f, int scaleFactor) {
if (scaleFactor > 0) {
return f * (1 << scaleFactor);
} else if (scaleFactor == 0) {
return f;
} else {
return f * 1.0f / (1 << -scaleFactor);
}
}
public static double signum(double d) {
if (d > 0.0d) {
return 1.0d;
} else if (d < 0.0d) {
return -1.0d;
} else {
return 0.0d;
}
}
public static float signum(float f) {
if (f > 0.0f) {
return 1.0f;
} else if (f < 0.0f) {
return -1.0f;
} else {
return 0.0f;
}
}
public static native double sin(double x) /*-{
return Math.sin(x);
}-*/;
public static native double sinh(double x) /*-{
return (Math.exp(x) - Math.exp(-x)) / 2.0;
}-*/;
public static native double sqrt(double x) /*-{
return Math.sqrt(x);
}-*/;
public static native double tan(double x) /*-{
return Math.tan(x);
}-*/;
public static native double tanh(double x) /*-{
if (x == Infinity) {
return 1.0;
}
var e2x = Math.exp(2.0 * x);
return (e2x - 1) / (e2x + 1);
}-*/;
public static double toDegrees(double x) {
return x * PI_UNDER_180;
}
public static double toRadians(double x) {
return x * PI_OVER_180;
}
private static native double round0(double x) /*-{
return Math.round(x);
}-*/;
}