mirror of
git://gcc.gnu.org/git/gcc.git
synced 2025-02-21 10:59:30 +08:00
javaprims.h (java::lang): Add java::lang::StrictMath.
2002-02-14 Eric Blake <ebb9@email.byu.edu> * gcj/javaprims.h (java::lang): Add java::lang::StrictMath. * Makefile.am (core_java_source_files): Add java/lang/StrictMath.java. * java/lang/Math.java: Merge with Classpath. * java/lang/StrictMath.java: New file - merge with Classpath. From-SVN: r49781
This commit is contained in:
Eric Blake
Eric Blake
parent
37cea03434
commit
2f999d0fe7
@ -1,3 +1,11 @@
|
||||
2002-02-14 Eric Blake <ebb9@email.byu.edu>
|
||||
|
||||
* gcj/javaprims.h (java::lang): Add java::lang::StrictMath.
|
||||
* Makefile.am (core_java_source_files): Add
|
||||
java/lang/StrictMath.java.
|
||||
* java/lang/Math.java: Merge with Classpath.
|
||||
* java/lang/StrictMath.java: New file - merge with Classpath.
|
||||
|
||||
2002-02-14 Mark Wielaard <mark@klomp.org>
|
||||
|
||||
* java/math/BigInteger.java: import gnu.java.math.MPN not the whole
|
||||
|
||||
@ -1102,6 +1102,7 @@ java/lang/SecurityException.java \
|
||||
java/lang/SecurityManager.java \
|
||||
java/lang/Short.java \
|
||||
java/lang/StackOverflowError.java \
|
||||
java/lang/StrictMath.java \
|
||||
java/lang/String.java \
|
||||
java/lang/StringBuffer.java \
|
||||
java/lang/StringIndexOutOfBoundsException.java \
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// javaprims.h - Main external header file for libgcj. -*- c++ -*-
|
||||
|
||||
/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
|
||||
/* Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation
|
||||
|
||||
This file is part of libgcj.
|
||||
|
||||
@ -193,6 +193,7 @@ extern "Java"
|
||||
class SecurityManager;
|
||||
class Short;
|
||||
class StackOverflowError;
|
||||
class StrictMath;
|
||||
class String;
|
||||
class String$CaseInsensitiveComparator;
|
||||
class StringBuffer;
|
||||
|
||||
@ -1,128 +1,643 @@
|
||||
/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
|
||||
/* java.lang.Math -- common mathematical functions, native allowed
|
||||
Copyright (C) 1998, 2001, 2002 Free Software Foundation, Inc.
|
||||
|
||||
This file is part of GNU Classpath.
|
||||
|
||||
GNU Classpath is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2, or (at your option)
|
||||
any later version.
|
||||
|
||||
GNU Classpath is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with GNU Classpath; see the file COPYING. If not, write to the
|
||||
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA.
|
||||
|
||||
Linking this library statically or dynamically with other modules is
|
||||
making a combined work based on this library. Thus, the terms and
|
||||
conditions of the GNU General Public License cover the whole
|
||||
combination.
|
||||
|
||||
As a special exception, the copyright holders of this library give you
|
||||
permission to link this library with independent modules to produce an
|
||||
executable, regardless of the license terms of these independent
|
||||
modules, and to copy and distribute the resulting executable under
|
||||
terms of your choice, provided that you also meet, for each linked
|
||||
independent module, the terms and conditions of the license of that
|
||||
module. An independent module is a module which is not derived from
|
||||
or based on this library. If you modify this library, you may extend
|
||||
this exception to your version of the library, but you are not
|
||||
obligated to do so. If you do not wish to do so, delete this
|
||||
exception statement from your version. */
|
||||
|
||||
This file is part of libgcj.
|
||||
|
||||
This software is copyrighted work licensed under the terms of the
|
||||
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
|
||||
details. */
|
||||
|
||||
/**
|
||||
* @author Andrew Haley <aph@cygnus.com>
|
||||
* @date September 18, 1998.
|
||||
*/
|
||||
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
|
||||
* "The Java Language Specification", ISBN 0-201-63451-1
|
||||
* plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
|
||||
* Status: Believed complete and correct.
|
||||
*/
|
||||
|
||||
package java.lang;
|
||||
|
||||
import java.util.Random;
|
||||
import gnu.classpath.Configuration;
|
||||
|
||||
public final class Math
|
||||
/**
|
||||
* Helper class containing useful mathematical functions and constants.
|
||||
* <P>
|
||||
*
|
||||
* Note that angles are specified in radians. Conversion functions are
|
||||
* provided for your convenience.
|
||||
*
|
||||
* @author Paul Fisher
|
||||
* @author John Keiser
|
||||
* @author Eric Blake <ebb9@email.byu.edu>
|
||||
* @since 1.0
|
||||
*/
|
||||
public final class Math
|
||||
{
|
||||
private static Random random_;
|
||||
|
||||
public static final double E = 2.7182818284590452354;
|
||||
public static final double PI = 3.14159265358979323846;
|
||||
|
||||
public static native double sin (double x);
|
||||
|
||||
public static native double cos (double x);
|
||||
|
||||
public static native double tan (double x);
|
||||
|
||||
public static native double asin (double x);
|
||||
|
||||
public static native double acos (double x);
|
||||
|
||||
public static native double atan (double x);
|
||||
|
||||
public static native double atan2(double y, double x);
|
||||
|
||||
public static native double exp (double x);
|
||||
|
||||
public static native double log (double x);
|
||||
|
||||
public static native double sqrt (double x);
|
||||
|
||||
public static native double pow (double x, double y);
|
||||
|
||||
public static native double IEEEremainder (double x, double y);
|
||||
|
||||
public static native double ceil (double x);
|
||||
|
||||
public static native double floor (double x);
|
||||
|
||||
public static native double rint (double x);
|
||||
|
||||
public static native int round (float x);
|
||||
|
||||
public static native long round (double x);
|
||||
|
||||
public static synchronized double random ()
|
||||
/**
|
||||
* Math is non-instantiable
|
||||
*/
|
||||
private Math()
|
||||
{
|
||||
if (random_ == null)
|
||||
random_ = new Random ();
|
||||
return random_.nextDouble ();
|
||||
}
|
||||
|
||||
public static int abs (int n)
|
||||
static
|
||||
{
|
||||
return (n < 0 ? -n : n);
|
||||
if (Configuration.INIT_LOAD_LIBRARY)
|
||||
{
|
||||
System.loadLibrary("javalang");
|
||||
}
|
||||
}
|
||||
|
||||
public static long abs (long n)
|
||||
/**
|
||||
* A random number generator, initialized on first use.
|
||||
*/
|
||||
private static Random rand;
|
||||
|
||||
/**
|
||||
* The most accurate approximation to the mathematical constant <em>e</em>:
|
||||
* <code>2.718281828459045</code>. Used in natural log and exp.
|
||||
*
|
||||
* @see #log(double)
|
||||
* @see #exp(double)
|
||||
*/
|
||||
public static final double E = 2.718281828459045;
|
||||
|
||||
/**
|
||||
* The most accurate approximation to the mathematical constant <em>pi</em>:
|
||||
* <code>3.141592653589793</code>. This is the ratio of a circle's diameter
|
||||
* to its circumference.
|
||||
*/
|
||||
public static final double PI = 3.141592653589793;
|
||||
|
||||
/**
|
||||
* Take the absolute value of the argument.
|
||||
* (Absolute value means make it positive.)
|
||||
* <P>
|
||||
*
|
||||
* Note that the the largest negative value (Integer.MIN_VALUE) cannot
|
||||
* be made positive. In this case, because of the rules of negation in
|
||||
* a computer, MIN_VALUE is what will be returned.
|
||||
* This is a <em>negative</em> value. You have been warned.
|
||||
*
|
||||
* @param i the number to take the absolute value of
|
||||
* @return the absolute value
|
||||
* @see Integer#MIN_VALUE
|
||||
*/
|
||||
public static int abs(int i)
|
||||
{
|
||||
return (n < 0 ? -n : n);
|
||||
return (i < 0) ? -i : i;
|
||||
}
|
||||
|
||||
public static native float abs (float x);
|
||||
|
||||
public static native double abs (double x);
|
||||
|
||||
public static int min (int a, int b)
|
||||
/**
|
||||
* Take the absolute value of the argument.
|
||||
* (Absolute value means make it positive.)
|
||||
* <P>
|
||||
*
|
||||
* Note that the the largest negative value (Long.MIN_VALUE) cannot
|
||||
* be made positive. In this case, because of the rules of negation in
|
||||
* a computer, MIN_VALUE is what will be returned.
|
||||
* This is a <em>negative</em> value. You have been warned.
|
||||
*
|
||||
* @param l the number to take the absolute value of
|
||||
* @return the absolute value
|
||||
* @see Long#MIN_VALUE
|
||||
*/
|
||||
public static long abs(long l)
|
||||
{
|
||||
return (a < b ? a : b);
|
||||
return (l < 0) ? -l : l;
|
||||
}
|
||||
|
||||
public static long min (long a, long b)
|
||||
/**
|
||||
* Take the absolute value of the argument.
|
||||
* (Absolute value means make it positive.)
|
||||
* <P>
|
||||
*
|
||||
* This is equivalent, but faster than, calling
|
||||
* <code>Float.intBitsToFloat(0x7fffffff & Float.floatToIntBits(a))</code>.
|
||||
*
|
||||
* @param f the number to take the absolute value of
|
||||
* @return the absolute value
|
||||
*/
|
||||
public static float abs(float f)
|
||||
{
|
||||
return (a < b ? a : b);
|
||||
return (f <= 0) ? 0 - f : f;
|
||||
}
|
||||
|
||||
public static native float min (float a, float b);
|
||||
|
||||
public static native double min (double a, double b);
|
||||
|
||||
public static int max (int a, int b)
|
||||
/**
|
||||
* Take the absolute value of the argument.
|
||||
* (Absolute value means make it positive.)
|
||||
*
|
||||
* This is equivalent, but faster than, calling
|
||||
* <code>Double.longBitsToDouble(Double.doubleToLongBits(a)
|
||||
* << 1) >>> 1);</code>.
|
||||
*
|
||||
* @param d the number to take the absolute value of
|
||||
* @return the absolute value
|
||||
*/
|
||||
public static double abs(double d)
|
||||
{
|
||||
return (a < b ? b : a);
|
||||
return (d <= 0) ? 0 - d : d;
|
||||
}
|
||||
|
||||
public static long max (long a, long b)
|
||||
/**
|
||||
* Return whichever argument is smaller.
|
||||
*
|
||||
* @param a the first number
|
||||
* @param b a second number
|
||||
* @return the smaller of the two numbers
|
||||
*/
|
||||
public static int min(int a, int b)
|
||||
{
|
||||
return (a < b ? b : a);
|
||||
return (a < b) ? a : b;
|
||||
}
|
||||
|
||||
public static native float max (float a, float b);
|
||||
|
||||
public static native double max (double a, double b);
|
||||
|
||||
public static double toDegrees (double radians)
|
||||
/**
|
||||
* Return whichever argument is smaller.
|
||||
*
|
||||
* @param a the first number
|
||||
* @param b a second number
|
||||
* @return the smaller of the two numbers
|
||||
*/
|
||||
public static long min(long a, long b)
|
||||
{
|
||||
return radians * 180 / PI;
|
||||
return (a < b) ? a : b;
|
||||
}
|
||||
|
||||
public static double toRadians (double degrees)
|
||||
/**
|
||||
* Return whichever argument is smaller. If either argument is NaN, the
|
||||
* result is NaN, and when comparing 0 and -0, -0 is always smaller.
|
||||
*
|
||||
* @param a the first number
|
||||
* @param b a second number
|
||||
* @return the smaller of the two numbers
|
||||
*/
|
||||
public static float min(float a, float b)
|
||||
{
|
||||
return degrees * PI / 180;
|
||||
// this check for NaN, from JLS 15.21.1, saves a method call
|
||||
if (a != a)
|
||||
return a;
|
||||
// no need to check if b is NaN; < will work correctly
|
||||
// recall that -0.0 == 0.0, but [+-]0.0 - [+-]0.0 behaves special
|
||||
if (a == 0 && b == 0)
|
||||
return -(-a - b);
|
||||
return (a < b) ? a : b;
|
||||
}
|
||||
|
||||
// Don't allow objects to be made.
|
||||
private Math ()
|
||||
/**
|
||||
* Return whichever argument is smaller. If either argument is NaN, the
|
||||
* result is NaN, and when comparing 0 and -0, -0 is always smaller.
|
||||
*
|
||||
* @param a the first number
|
||||
* @param b a second number
|
||||
* @return the smaller of the two numbers
|
||||
*/
|
||||
public static double min(double a, double b)
|
||||
{
|
||||
// this check for NaN, from JLS 15.21.1, saves a method call
|
||||
if (a != a)
|
||||
return a;
|
||||
// no need to check if b is NaN; < will work correctly
|
||||
// recall that -0.0 == 0.0, but [+-]0.0 - [+-]0.0 behaves special
|
||||
if (a == 0 && b == 0)
|
||||
return -(-a - b);
|
||||
return (a < b) ? a : b;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return whichever argument is larger.
|
||||
*
|
||||
* @param a the first number
|
||||
* @param b a second number
|
||||
* @return the larger of the two numbers
|
||||
*/
|
||||
public static int max(int a, int b)
|
||||
{
|
||||
return (a > b) ? a : b;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return whichever argument is larger.
|
||||
*
|
||||
* @param a the first number
|
||||
* @param b a second number
|
||||
* @return the larger of the two numbers
|
||||
*/
|
||||
public static long max(long a, long b)
|
||||
{
|
||||
return (a > b) ? a : b;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return whichever argument is larger. If either argument is NaN, the
|
||||
* result is NaN, and when comparing 0 and -0, 0 is always larger.
|
||||
*
|
||||
* @param a the first number
|
||||
* @param b a second number
|
||||
* @return the larger of the two numbers
|
||||
*/
|
||||
public static float max(float a, float b)
|
||||
{
|
||||
// this check for NaN, from JLS 15.21.1, saves a method call
|
||||
if (a != a)
|
||||
return a;
|
||||
// no need to check if b is NaN; > will work correctly
|
||||
// recall that -0.0 == 0.0, but [+-]0.0 - [+-]0.0 behaves special
|
||||
if (a == 0 && b == 0)
|
||||
return a - -b;
|
||||
return (a > b) ? a : b;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return whichever argument is larger. If either argument is NaN, the
|
||||
* result is NaN, and when comparing 0 and -0, 0 is always larger.
|
||||
*
|
||||
* @param a the first number
|
||||
* @param b a second number
|
||||
* @return the larger of the two numbers
|
||||
*/
|
||||
public static double max(double a, double b)
|
||||
{
|
||||
// this check for NaN, from JLS 15.21.1, saves a method call
|
||||
if (a != a)
|
||||
return a;
|
||||
// no need to check if b is NaN; > will work correctly
|
||||
// recall that -0.0 == 0.0, but [+-]0.0 - [+-]0.0 behaves special
|
||||
if (a == 0 && b == 0)
|
||||
return a - -b;
|
||||
return (a > b) ? a : b;
|
||||
}
|
||||
|
||||
/**
|
||||
* The trigonometric function <em>sin</em>. The sine of NaN or infinity is
|
||||
* NaN, and the sine of 0 retains its sign. This is accurate within 1 ulp,
|
||||
* and is semi-monotonic.
|
||||
*
|
||||
* @param a the angle (in radians)
|
||||
* @return sin(a)
|
||||
*/
|
||||
public native static double sin(double a);
|
||||
|
||||
/**
|
||||
* The trigonometric function <em>cos</em>. The cosine of NaN or infinity is
|
||||
* NaN. This is accurate within 1 ulp, and is semi-monotonic.
|
||||
*
|
||||
* @param a the angle (in radians)
|
||||
* @return cos(a)
|
||||
*/
|
||||
public native static double cos(double a);
|
||||
|
||||
/**
|
||||
* The trigonometric function <em>tan</em>. The tangent of NaN or infinity
|
||||
* is NaN, and the tangent of 0 retains its sign. This is accurate within 1
|
||||
* ulp, and is semi-monotonic.
|
||||
*
|
||||
* @param a the angle (in radians)
|
||||
* @return tan(a)
|
||||
*/
|
||||
public native static double tan(double a);
|
||||
|
||||
/**
|
||||
* The trigonometric function <em>arcsin</em>. The range of angles returned
|
||||
* is -pi/2 to pi/2 radians (-90 to 90 degrees). If the argument is NaN or
|
||||
* its absolute value is beyond 1, the result is NaN; and the arcsine of
|
||||
* 0 retains its sign. This is accurate within 1 ulp, and is semi-monotonic.
|
||||
*
|
||||
* @param a the sin to turn back into an angle
|
||||
* @return arcsin(a)
|
||||
*/
|
||||
public native static double asin(double a);
|
||||
|
||||
/**
|
||||
* The trigonometric function <em>arccos</em>. The range of angles returned
|
||||
* is 0 to pi radians (0 to 180 degrees). If the argument is NaN or
|
||||
* its absolute value is beyond 1, the result is NaN. This is accurate
|
||||
* within 1 ulp, and is semi-monotonic.
|
||||
*
|
||||
* @param a the cos to turn back into an angle
|
||||
* @return arccos(a)
|
||||
*/
|
||||
public native static double acos(double a);
|
||||
|
||||
/**
|
||||
* The trigonometric function <em>arcsin</em>. The range of angles returned
|
||||
* is -pi/2 to pi/2 radians (-90 to 90 degrees). If the argument is NaN, the
|
||||
* result is NaN; and the arctangent of 0 retains its sign. This is accurate
|
||||
* within 1 ulp, and is semi-monotonic.
|
||||
*
|
||||
* @param a the tan to turn back into an angle
|
||||
* @return arcsin(a)
|
||||
* @see #atan2(double, double)
|
||||
*/
|
||||
public native static double atan(double a);
|
||||
|
||||
/**
|
||||
* A special version of the trigonometric function <em>arctan</em>, for
|
||||
* converting rectangular coordinates <em>(x, y)</em> to polar
|
||||
* <em>(r, theta)</em>. This computes the arctangent of x/y in the range
|
||||
* of -pi to pi radians (-180 to 180 degrees). Special cases:<ul>
|
||||
* <li>If either argument is NaN, the result is NaN.</li>
|
||||
* <li>If the first argument is positive zero and the second argument is
|
||||
* positive, or the first argument is positive and finite and the second
|
||||
* argument is positive infinity, then the result is positive zero.</li>
|
||||
* <li>If the first argument is negative zero and the second argument is
|
||||
* positive, or the first argument is negative and finite and the second
|
||||
* argument is positive infinity, then the result is negative zero.</li>
|
||||
* <li>If the first argument is positive zero and the second argument is
|
||||
* negative, or the first argument is positive and finite and the second
|
||||
* argument is negative infinity, then the result is the double value
|
||||
* closest to pi.</li>
|
||||
* <li>If the first argument is negative zero and the second argument is
|
||||
* negative, or the first argument is negative and finite and the second
|
||||
* argument is negative infinity, then the result is the double value
|
||||
* closest to -pi.</li>
|
||||
* <li>If the first argument is positive and the second argument is
|
||||
* positive zero or negative zero, or the first argument is positive
|
||||
* infinity and the second argument is finite, then the result is the
|
||||
* double value closest to pi/2.</li>
|
||||
* <li>If the first argument is negative and the second argument is
|
||||
* positive zero or negative zero, or the first argument is negative
|
||||
* infinity and the second argument is finite, then the result is the
|
||||
* double value closest to -pi/2.</li>
|
||||
* <li>If both arguments are positive infinity, then the result is the
|
||||
* double value closest to pi/4.</li>
|
||||
* <li>If the first argument is positive infinity and the second argument
|
||||
* is negative infinity, then the result is the double value closest to
|
||||
* 3*pi/4.</li>
|
||||
* <li>If the first argument is negative infinity and the second argument
|
||||
* is positive infinity, then the result is the double value closest to
|
||||
* -pi/4.</li>
|
||||
* <li>If both arguments are negative infinity, then the result is the
|
||||
* double value closest to -3*pi/4.</li>
|
||||
*
|
||||
* </ul><p>This is accurate within 2 ulps, and is semi-monotonic. To get r,
|
||||
* use sqrt(x*x+y*y).
|
||||
*
|
||||
* @param y the y position
|
||||
* @param x the x position
|
||||
* @return <em>theta</em> in the conversion of (x, y) to (r, theta)
|
||||
* @see #atan(double)
|
||||
*/
|
||||
public native static double atan2(double y, double x);
|
||||
|
||||
/**
|
||||
* Take <em>e</em><sup>a</sup>. The opposite of <code>log()</code>. If the
|
||||
* argument is NaN, the result is NaN; if the argument is positive infinity,
|
||||
* the result is positive infinity; and if the argument is negative
|
||||
* infinity, the result is positive zero. This is accurate within 1 ulp,
|
||||
* and is semi-monotonic.
|
||||
*
|
||||
* @param a the number to raise to the power
|
||||
* @return the number raised to the power of <em>e</em>
|
||||
* @see #log(double)
|
||||
* @see #pow(double, double)
|
||||
*/
|
||||
public native static double exp(double a);
|
||||
|
||||
/**
|
||||
* Take ln(a) (the natural log). The opposite of <code>exp()</code>. If the
|
||||
* argument is NaN or negative, the result is NaN; if the argument is
|
||||
* positive infinity, the result is positive infinity; and if the argument
|
||||
* is either zero, the result is negative infinity. This is accurate within
|
||||
* 1 ulp, and is semi-monotonic.
|
||||
*
|
||||
* <p>Note that the way to get log<sub>b</sub>(a) is to do this:
|
||||
* <code>ln(a) / ln(b)</code>.
|
||||
*
|
||||
* @param a the number to take the natural log of
|
||||
* @return the natural log of <code>a</code>
|
||||
* @see #exp(double)
|
||||
*/
|
||||
public native static double log(double a);
|
||||
|
||||
/**
|
||||
* Take a square root. If the argument is NaN or negative, the result is
|
||||
* NaN; if the argument is positive infinity, the result is positive
|
||||
* infinity; and if the result is either zero, the result is the same.
|
||||
* This is accurate within the limits of doubles.
|
||||
*
|
||||
* <p>For other roots, use pow(a, 1 / rootNumber).
|
||||
*
|
||||
* @param a the numeric argument
|
||||
* @return the square root of the argument
|
||||
* @see #pow(double, double)
|
||||
*/
|
||||
public native static double sqrt(double a);
|
||||
|
||||
/**
|
||||
* Raise a number to a power. Special cases:<ul>
|
||||
* <li>If the second argument is positive or negative zero, then the result
|
||||
* is 1.0.</li>
|
||||
* <li>If the second argument is 1.0, then the result is the same as the
|
||||
* first argument.</li>
|
||||
* <li>If the second argument is NaN, then the result is NaN.</li>
|
||||
* <li>If the first argument is NaN and the second argument is nonzero,
|
||||
* then the result is NaN.</li>
|
||||
* <li>If the absolute value of the first argument is greater than 1 and
|
||||
* the second argument is positive infinity, or the absolute value of the
|
||||
* first argument is less than 1 and the second argument is negative
|
||||
* infinity, then the result is positive infinity.</li>
|
||||
* <li>If the absolute value of the first argument is greater than 1 and
|
||||
* the second argument is negative infinity, or the absolute value of the
|
||||
* first argument is less than 1 and the second argument is positive
|
||||
* infinity, then the result is positive zero.</li>
|
||||
* <li>If the absolute value of the first argument equals 1 and the second
|
||||
* argument is infinite, then the result is NaN.</li>
|
||||
* <li>If the first argument is positive zero and the second argument is
|
||||
* greater than zero, or the first argument is positive infinity and the
|
||||
* second argument is less than zero, then the result is positive zero.</li>
|
||||
* <li>If the first argument is positive zero and the second argument is
|
||||
* less than zero, or the first argument is positive infinity and the
|
||||
* second argument is greater than zero, then the result is positive
|
||||
* infinity.</li>
|
||||
* <li>If the first argument is negative zero and the second argument is
|
||||
* greater than zero but not a finite odd integer, or the first argument is
|
||||
* negative infinity and the second argument is less than zero but not a
|
||||
* finite odd integer, then the result is positive zero.</li>
|
||||
* <li>If the first argument is negative zero and the second argument is a
|
||||
* positive finite odd integer, or the first argument is negative infinity
|
||||
* and the second argument is a negative finite odd integer, then the result
|
||||
* is negative zero.</li>
|
||||
* <li>If the first argument is negative zero and the second argument is
|
||||
* less than zero but not a finite odd integer, or the first argument is
|
||||
* negative infinity and the second argument is greater than zero but not a
|
||||
* finite odd integer, then the result is positive infinity.</li>
|
||||
* <li>If the first argument is negative zero and the second argument is a
|
||||
* negative finite odd integer, or the first argument is negative infinity
|
||||
* and the second argument is a positive finite odd integer, then the result
|
||||
* is negative infinity.</li>
|
||||
* <li>If the first argument is less than zero and the second argument is a
|
||||
* finite even integer, then the result is equal to the result of raising
|
||||
* the absolute value of the first argument to the power of the second
|
||||
* argument.</li>
|
||||
* <li>If the first argument is less than zero and the second argument is a
|
||||
* finite odd integer, then the result is equal to the negative of the
|
||||
* result of raising the absolute value of the first argument to the power
|
||||
* of the second argument.</li>
|
||||
* <li>If the first argument is finite and less than zero and the second
|
||||
* argument is finite and not an integer, then the result is NaN.</li>
|
||||
* <li>If both arguments are integers, then the result is exactly equal to
|
||||
* the mathematical result of raising the first argument to the power of
|
||||
* the second argument if that result can in fact be represented exactly as
|
||||
* a double value.</li>
|
||||
*
|
||||
* </ul><p>(In the foregoing descriptions, a floating-point value is
|
||||
* considered to be an integer if and only if it is a fixed point of the
|
||||
* method {@link #ceil(double)} or, equivalently, a fixed point of the
|
||||
* method {@link #floor(double)}. A value is a fixed point of a one-argument
|
||||
* method if and only if the result of applying the method to the value is
|
||||
* equal to the value.) This is accurate within 1 ulp, and is semi-monotonic.
|
||||
*
|
||||
* @param a the number to raise
|
||||
* @param b the power to raise it to
|
||||
* @return a<sup>b</sup>
|
||||
*/
|
||||
public native static double pow(double a, double b);
|
||||
|
||||
/**
|
||||
* Get the IEEE 754 floating point remainder on two numbers. This is the
|
||||
* value of <code>x - y * <em>n</em></code>, where <em>n</em> is the closest
|
||||
* double to <code>x / y</code> (ties go to the even n); for a zero
|
||||
* remainder, the sign is that of <code>x</code>. If either argument is NaN,
|
||||
* the first argument is infinite, or the second argument is zero, the result
|
||||
* is NaN; if x is finite but y is infinte, the result is x. This is
|
||||
* accurate within the limits of doubles.
|
||||
*
|
||||
* @param x the dividend (the top half)
|
||||
* @param y the divisor (the bottom half)
|
||||
* @return the IEEE 754-defined floating point remainder of x/y
|
||||
* @see #rint(double)
|
||||
*/
|
||||
public native static double IEEEremainder(double x, double y);
|
||||
|
||||
/**
|
||||
* Take the nearest integer that is that is greater than or equal to the
|
||||
* argument. If the argument is NaN, infinite, or zero, the result is the
|
||||
* same; if the argument is between -1 and 0, the result is negative zero.
|
||||
* Note that <code>Math.ceil(x) == -Math.floor(-x)</code>.
|
||||
*
|
||||
* @param a the value to act upon
|
||||
* @return the nearest integer >= <code>a</code>
|
||||
*/
|
||||
public native static double ceil(double a);
|
||||
|
||||
/**
|
||||
* Take the nearest integer that is that is less than or equal to the
|
||||
* argument. If the argument is NaN, infinite, or zero, the result is the
|
||||
* same. Note that <code>Math.ceil(x) == -Math.floor(-x)</code>.
|
||||
*
|
||||
* @param a the value to act upon
|
||||
* @return the nearest integer <= <code>a</code>
|
||||
*/
|
||||
public native static double floor(double a);
|
||||
|
||||
/**
|
||||
* Take the nearest integer to the argument. If it is exactly between
|
||||
* two integers, the even integer is taken. If the argument is NaN,
|
||||
* infinite, or zero, the result is the same.
|
||||
*
|
||||
* @param a the value to act upon
|
||||
* @return the nearest integer to <code>a</code>
|
||||
*/
|
||||
public native static double rint(double a);
|
||||
|
||||
/**
|
||||
* Take the nearest integer to the argument. This is equivalent to
|
||||
* <code>(int) Math.floor(a + 0.5f). If the argument is NaN, the result
|
||||
* is 0; otherwise if the argument is outside the range of int, the result
|
||||
* will be Integer.MIN_VALUE or Integer.MAX_VALUE, as appropriate.
|
||||
*
|
||||
* @param a the argument to round
|
||||
* @return the nearest integer to the argument
|
||||
* @see Integer#MIN_VALUE
|
||||
* @see Integer#MAX_VALUE
|
||||
*/
|
||||
public static int round(float a)
|
||||
{
|
||||
return (int) floor(a + 0.5f);
|
||||
}
|
||||
|
||||
/**
|
||||
* Take the nearest long to the argument. This is equivalent to
|
||||
* <code>(long) Math.floor(a + 0.5)</code>. If the argument is NaN, the
|
||||
* result is 0; otherwise if the argument is outside the range of long, the
|
||||
* result will be Long.MIN_VALUE or Long.MAX_VALUE, as appropriate.
|
||||
*
|
||||
* @param a the argument to round
|
||||
* @return the nearest long to the argument
|
||||
* @see Long#MIN_VALUE
|
||||
* @see Long#MAX_VALUE
|
||||
*/
|
||||
public static long round(double a)
|
||||
{
|
||||
return (long) floor(a + 0.5d);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a random number. This behaves like Random.nextDouble(), seeded by
|
||||
* System.currentTimeMillis() when first called. In other words, the number
|
||||
* is from a pseudorandom sequence, and lies in the range [+0.0, 1.0).
|
||||
* This random sequence is only used by this method, and is threadsafe,
|
||||
* although you may want your own random number generator if it is shared
|
||||
* among threads.
|
||||
*
|
||||
* @return a random number
|
||||
* @see Random#nextDouble()
|
||||
* @see System#currentTimeMillis()
|
||||
*/
|
||||
public static synchronized double random()
|
||||
{
|
||||
if (rand == null)
|
||||
rand = new Random();
|
||||
return rand.nextDouble();
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert from degrees to radians. The formula for this is
|
||||
* radians = degrees * (pi/180); however it is not always exact given the
|
||||
* limitations of floating point numbers.
|
||||
*
|
||||
* @param degrees an angle in degrees
|
||||
* @return the angle in radians
|
||||
* @since 1.2
|
||||
*/
|
||||
public static double toRadians(double degrees)
|
||||
{
|
||||
return degrees * (PI / 180);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert from radians to degrees. The formula for this is
|
||||
* degrees = radians * (180/pi); however it is not always exact given the
|
||||
* limitations of floating point numbers.
|
||||
*
|
||||
* @param rads an angle in radians
|
||||
* @return the angle in degrees
|
||||
* @since 1.2
|
||||
*/
|
||||
public static double toDegrees(double rads)
|
||||
{
|
||||
return rads * (180 / PI);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
1843
libjava/java/lang/StrictMath.java
Normal file
1843
libjava/java/lang/StrictMath.java
Normal file
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue
Block a user