/*

 * Copyright (c) 1994, 2011, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.lang;

import java.util.Random;

/**

 * The class {@code Math} contains methods for performing basic

 * numeric operations such as the elementary exponential, logarithm,

 * square root, and trigonometric functions.

 *

 * <p>Unlike some of the numeric methods of class

 * {@code StrictMath}, all implementations of the equivalent

 * functions of class {@code Math} are not defined to return the

 * bit-for-bit same results.  This relaxation permits

 * better-performing implementations where strict reproducibility is

 * not required.

 *

 * <p>By default many of the {@code Math} methods simply call

 * the equivalent method in {@code StrictMath} for their

 * implementation.  Code generators are encouraged to use

 * platform-specific native libraries or microprocessor instructions,

 * where available, to provide higher-performance implementations of

 * {@code Math} methods.  Such higher-performance

 * implementations still must conform to the specification for

 * {@code Math}.

 *

 * <p>The quality of implementation specifications concern two

 * properties, accuracy of the returned result and monotonicity of the

 * method.  Accuracy of the floating-point {@code Math} methods

 * is measured in terms of <i>ulps</i>, units in the last place.  For

 * a given floating-point format, an ulp of a specific real number

 * value is the distance between the two floating-point values

 * bracketing that numerical value.  When discussing the accuracy of a

 * method as a whole rather than at a specific argument, the number of

 * ulps cited is for the worst-case error at any argument.  If a

 * method always has an error less than 0.5 ulps, the method always

 * returns the floating-point number nearest the exact result; such a

 * method is <i>correctly rounded</i>.  A correctly rounded method is

 * generally the best a floating-point approximation can be; however,

 * it is impractical for many floating-point methods to be correctly

 * rounded.  Instead, for the {@code Math} class, a larger error

 * bound of 1 or 2 ulps is allowed for certain methods.  Informally,

 * with a 1 ulp error bound, when the exact result is a representable

 * number, the exact result should be returned as the computed result;

 * otherwise, either of the two floating-point values which bracket

 * the exact result may be returned.  For exact results large in

 * magnitude, one of the endpoints of the bracket may be infinite.

 * Besides accuracy at individual arguments, maintaining proper

 * relations between the method at different arguments is also

 * important.  Therefore, most methods with more than 0.5 ulp errors

 * are required to be <i>semi-monotonic</i>: whenever the mathematical

 * function is non-decreasing, so is the floating-point approximation,

 * likewise, whenever the mathematical function is non-increasing, so

 * is the floating-point approximation.  Not all approximations that

 * have 1 ulp accuracy will automatically meet the monotonicity

 * requirements.

 *

 * @author  unascribed

 * @author  Joseph D. Darcy

 * @since   JDK1.0

 */

public final class Math {

    /**

     * Don't let anyone instantiate this class.

     */

    private Math() {}

    /**

     * The {@code double} value that is closer than any other to

     * <i>e</i>, the base of the natural logarithms.

     */

    public static final double E = 2.7182818284590452354;

    /**

     * The {@code double} value that is closer than any other to

     * <i>pi</i>, the ratio of the circumference of a circle to its

     * diameter.

     */

    public static final double PI = 3.14159265358979323846;

    /**

     * Returns the trigonometric sine of an angle.  Special cases:

     * <ul><li>If the argument is NaN or an infinity, then the

     * result is NaN.

     * <li>If the argument is zero, then the result is a zero with the

     * same sign as the argument.</ul>

     *

     * <p>The computed result must be within 1 ulp of the exact result.

     * Results must be semi-monotonic.

     *

     * @param   a   an angle, in radians.

     * @return  the sine of the argument.

     */

    public static double sin(double a) {

        return StrictMath.sin(a); // default impl. delegates to StrictMath

    }

    /**

     * Returns the trigonometric cosine of an angle. Special cases:

     * <ul><li>If the argument is NaN or an infinity, then the

     * result is NaN.</ul>

     *

     * <p>The computed result must be within 1 ulp of the exact result.

     * Results must be semi-monotonic.

     *

     * @param   a   an angle, in radians.

     * @return  the cosine of the argument.

     */

    public static double cos(double a) {

        return StrictMath.cos(a); // default impl. delegates to StrictMath

    }

    /**

     * Returns the trigonometric tangent of an angle.  Special cases:

     * <ul><li>If the argument is NaN or an infinity, then the result

     * is NaN.

     * <li>If the argument is zero, then the result is a zero with the

     * same sign as the argument.</ul>

     *

     * <p>The computed result must be within 1 ulp of the exact result.

     * Results must be semi-monotonic.

     *

     * @param   a   an angle, in radians.

     * @return  the tangent of the argument.

     */

    public static double tan(double a) {

        return StrictMath.tan(a); // default impl. delegates to StrictMath

    }

    /**

     * Returns the arc sine of a value; the returned angle is in the

     * range -<i>pi</i>/2 through <i>pi</i>/2.  Special cases:

     * <ul><li>If the argument is NaN or its absolute value is greater

     * than 1, then the result is NaN.

     * <li>If the argument is zero, then the result is a zero with the

     * same sign as the argument.</ul>

     *

     * <p>The computed result must be within 1 ulp of the exact result.

     * Results must be semi-monotonic.

     *

     * @param   a   the value whose arc sine is to be returned.

     * @return  the arc sine of the argument.

     */

    public static double asin(double a) {

        return StrictMath.asin(a); // default impl. delegates to StrictMath

    }

    /**

     * Returns the arc cosine of a value; the returned angle is in the

     * range 0.0 through <i>pi</i>.  Special case:

     * <ul><li>If the argument is NaN or its absolute value is greater

     * than 1, then the result is NaN.</ul>

     *

     * <p>The computed result must be within 1 ulp of the exact result.

     * Results must be semi-monotonic.

     *

     * @param   a   the value whose arc cosine is to be returned.

     * @return  the arc cosine of the argument.

     */

    public static double acos(double a) {

        return StrictMath.acos(a); // default impl. delegates to StrictMath

    }

    /**

     * Returns the arc tangent of a value; the returned angle is in the

     * range -<i>pi</i>/2 through <i>pi</i>/2.  Special cases:

     * <ul><li>If the argument is NaN, then the result is NaN.

     * <li>If the argument is zero, then the result is a zero with the

     * same sign as the argument.</ul>

     *

     * <p>The computed result must be within 1 ulp of the exact result.

     * Results must be semi-monotonic.

     *

     * @param   a   the value whose arc tangent is to be returned.

     * @return  the arc tangent of the argument.

     */

    public static double atan(double a) {

        return StrictMath.atan(a); // default impl. delegates to StrictMath

    }

    /**

     * Converts an angle measured in degrees to an approximately

     * equivalent angle measured in radians.  The conversion from

     * degrees to radians is generally inexact.

     *

     * @param   angdeg   an angle, in degrees

     * @return  the measurement of the angle {@code angdeg}

     *          in radians.

     * @since   1.2

     */

    public static double toRadians(double angdeg) {

        return angdeg / 180.0 * PI;

    }

    /**

     * Converts an angle measured in radians to an approximately

     * equivalent angle measured in degrees.  The conversion from

     * radians to degrees is generally inexact; users should

     * <i>not</i> expect {@code cos(toRadians(90.0))} to exactly

     * equal {@code 0.0}.

     *

     * @param   angrad   an angle, in radians

     * @return  the measurement of the angle {@code angrad}

     *          in degrees.

     * @since   1.2

     */

    public static double toDegrees(double angrad) {

        return angrad * 180.0 / PI;

    }

    /**

     * Returns Euler's number <i>e</i> raised to the power of a

     * {@code double} value.  Special cases:

     * <ul><li>If the argument is NaN, the result is NaN.

     * <li>If the argument is positive infinity, then the result is

     * positive infinity.

     * <li>If the argument is negative infinity, then the result is

     * positive zero.</ul>

     *

     * <p>The computed result must be within 1 ulp of the exact result.

     * Results must be semi-monotonic.

     *

     * @param   a   the exponent to raise <i>e</i> to.

     * @return  the value <i>e</i><sup>{@code a}</sup>,

     *          where <i>e</i> is the base of the natural logarithms.

     */

    public static double exp(double a) {

        return StrictMath.exp(a); // default impl. delegates to StrictMath

    }

    /**

     * Returns the natural logarithm (base <i>e</i>) of a {@code double}

     * value.  Special cases:

     * <ul><li>If the argument is NaN or less than zero, then the result

     * is NaN.

     * <li>If the argument is positive infinity, then the result is

     * positive infinity.

     * <li>If the argument is positive zero or negative zero, then the

     * result is negative infinity.</ul>

     *

     * <p>The computed result must be within 1 ulp of the exact result.

     * Results must be semi-monotonic.

     *

     * @param   a   a value

     * @return  the value ln {@code a}, the natural logarithm of

     *          {@code a}.

     */

    public static double log(double a) {

        return StrictMath.log(a); // default impl. delegates to StrictMath

    }

    /**

     * Returns the base 10 logarithm of a {@code double} value.

     * Special cases:

     *

     * <ul><li>If the argument is NaN or less than zero, then the result

     * is NaN.

     * <li>If the argument is positive infinity, then the result is

     * positive infinity.

     * <li>If the argument is positive zero or negative zero, then the

     * result is negative infinity.

     * <li> If the argument is equal to 10<sup><i>n</i></sup> for

     * integer <i>n</i>, then the result is <i>n</i>.

     * </ul>

     *

     * <p>The computed result must be within 1 ulp of the exact result.

     * Results must be semi-monotonic.

     *

     * @param   a   a value

     * @return  the base 10 logarithm of  {@code a}.

     * @since 1.5

     */

    public static double log10(double a) {

        return StrictMath.log10(a); // default impl. delegates to StrictMath

    }

    /**

     * Returns the correctly rounded positive square root of a

     * {@code double} value.

     * Special cases:

     * <ul><li>If the argument is NaN or less than zero, then the result

     * is NaN.

     * <li>If the argument is positive infinity, then the result is positive

     * infinity.

     * <li>If the argument is positive zero or negative zero, then the

     * result is the same as the argument.</ul>

     * Otherwise, the result is the {@code double} value closest to

     * the true mathematical square root of the argument value.

     *

     * @param   a   a value.

     * @return  the positive square root of {@code a}.

     *          If the argument is NaN or less than zero, the result is NaN.

     */

    public static double sqrt(double a) {

        return StrictMath.sqrt(a); // default impl. delegates to StrictMath

                                   // Note that hardware sqrt instructions

                                   // frequently can be directly used by JITs

                                   // and should be much faster than doing

                                   // Math.sqrt in software.

    }

    /**

     * Returns the cube root of a {@code double} value.  For

     * positive finite {@code x}, {@code cbrt(-x) ==

     * -cbrt(x)}; that is, the cube root of a negative value is

     * the negative of the cube root of that value's magnitude.

     *

     * Special cases:

     *

     * <ul>

     *

     * <li>If the argument is NaN, then the result is NaN.

     *

     * <li>If the argument is infinite, then the result is an infinity

     * with the same sign as the argument.

     *

     * <li>If the argument is zero, then the result is a zero with the

     * same sign as the argument.

     *

     * </ul>

     *

     * <p>The computed result must be within 1 ulp of the exact result.

     *

     * @param   a   a value.

     * @return  the cube root of {@code a}.

     * @since 1.5

     */

    public static double cbrt(double a) {

        return StrictMath.cbrt(a);

    }

    /**

     * Computes the remainder operation on two arguments as prescribed

     * by the IEEE 754 standard.

     * The remainder value is mathematically equal to

     * <code>f1&nbsp;-&nbsp;f2</code>&nbsp;&times;&nbsp;<i>n</i>,

     * where <i>n</i> is the mathematical integer closest to the exact

     * mathematical value of the quotient {@code f1/f2}, and if two

     * mathematical integers are equally close to {@code f1/f2},

     * then <i>n</i> is the integer that is even. If the remainder is

     * zero, its sign is the same as the sign of the first argument.

     * Special cases:

     * <ul><li>If either argument is NaN, or the first argument is infinite,

     * or the second argument is positive zero or negative zero, then the

     * result is NaN.

     * <li>If the first argument is finite and the second argument is

     * infinite, then the result is the same as the first argument.</ul>

     *

     * @param   f1   the dividend.

     * @param   f2   the divisor.

     * @return  the remainder when {@code f1} is divided by

     *          {@code f2}.

     */

    public static double IEEEremainder(double f1, double f2) {

        return StrictMath.IEEEremainder(f1, f2); // delegate to StrictMath

    }

    /**

     * Returns the smallest (closest to negative infinity)

     * {@code double} value that is greater than or equal to the

     * argument and is equal to a mathematical integer. Special cases:

     * <ul><li>If the argument value is already equal to a

     * mathematical integer, then the result is the same as the

     * argument.  <li>If the argument is NaN or an infinity or

     * positive zero or negative zero, then the result is the same as

     * the argument.  <li>If the argument value is less than zero but

     * greater than -1.0, then the result is negative zero.</ul> Note

     * that the value of {@code Math.ceil(x)} is exactly the

     * value of {@code -Math.floor(-x)}.

     *

     *

     * @param   a   a value.

     * @return  the smallest (closest to negative infinity)

     *          floating-point value that is greater than or equal to

     *          the argument and is equal to a mathematical integer.

     */

    public static double ceil(double a) {

        return StrictMath.ceil(a); // default impl. delegates to StrictMath

    }

    /**

     * Returns the largest (closest to positive infinity)

     * {@code double} value that is less than or equal to the

     * argument and is equal to a mathematical integer. Special cases:

     * <ul><li>If the argument value is already equal to a

     * mathematical integer, then the result is the same as the

     * argument.  <li>If the argument is NaN or an infinity or

     * positive zero or negative zero, then the result is the same as

     * the argument.</ul>

     *

     * @param   a   a value.

     * @return  the largest (closest to positive infinity)

     *          floating-point value that less than or equal to the argument

     *          and is equal to a mathematical integer.

     */

    public static double floor(double a) {

        return StrictMath.floor(a); // default impl. delegates to StrictMath

    }

    /**

     * Returns the {@code double} value that is closest in value

     * to the argument and is equal to a mathematical integer. If two

     * {@code double} values that are mathematical integers are

     * equally close, the result is the integer value that is

     * even. Special cases:

     * <ul><li>If the argument value is already equal to a mathematical

     * integer, then the result is the same as the argument.

     * <li>If the argument is NaN or an infinity or positive zero or negative

     * zero, then the result is the same as the argument.</ul>

     *

     * @param   a   a {@code double} value.

     * @return  the closest floating-point value to {@code a} that is

     *          equal to a mathematical integer.

     */

    public static double rint(double a) {

        return StrictMath.rint(a); // default impl. delegates to StrictMath

    }

    /**

     * Returns the angle <i>theta</i> from the conversion of rectangular

     * coordinates ({@code x}, {@code y}) to polar

     * coordinates (r,&nbsp;<i>theta</i>).

     * This method computes the phase <i>theta</i> by computing an arc tangent

     * of {@code y/x} in the range of -<i>pi</i> to <i>pi</i>. Special

     * cases:

     * <ul><li>If either argument is NaN, then the result is NaN.

     * <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>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>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

     * {@code double} value closest to <i>pi</i>.

     * <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

     * {@code double} value closest to -<i>pi</i>.

     * <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

     * {@code double} value closest to <i>pi</i>/2.

     * <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

     * {@code double} value closest to -<i>pi</i>/2.

     * <li>If both arguments are positive infinity, then the result is the

     * {@code double} value closest to <i>pi</i>/4.

     * <li>If the first argument is positive infinity and the second argument

     * is negative infinity, then the result is the {@code double}

     * value closest to 3*<i>pi</i>/4.

     * <li>If the first argument is negative infinity and the second argument

     * is positive infinity, then the result is the {@code double} value

     * closest to -<i>pi</i>/4.

     * <li>If both arguments are negative infinity, then the result is the

     * {@code double} value closest to -3*<i>pi</i>/4.</ul>

     *

     * <p>The computed result must be within 2 ulps of the exact result.

     * Results must be semi-monotonic.

     *

     * @param   y   the ordinate coordinate

     * @param   x   the abscissa coordinate

     * @return  the <i>theta</i> component of the point

     *          (<i>r</i>,&nbsp;<i>theta</i>)

     *          in polar coordinates that corresponds to the point

     *          (<i>x</i>,&nbsp;<i>y</i>) in Cartesian coordinates.

     */

    public static double atan2(double y, double x) {

        return StrictMath.atan2(y, x); // default impl. delegates to StrictMath

    }

    /**

     * Returns the value of the first argument raised to the power of the

     * second argument. Special cases:

     *

     * <ul><li>If the second argument is positive or negative zero, then the

     * result is 1.0.

     * <li>If the second argument is 1.0, then the result is the same as the

     * first argument.

     * <li>If the second argument is NaN, then the result is NaN.

     * <li>If the first argument is NaN and the second argument is nonzero,

     * then the result is NaN.

     *

     * <li>If

     * <ul>

     * <li>the absolute value of the first argument is greater than 1

     * and the second argument is positive infinity, or

     * <li>the absolute value of the first argument is less than 1 and

     * the second argument is negative infinity,

     * </ul>

     * then the result is positive infinity.

     *

     * <li>If

     * <ul>

     * <li>the absolute value of the first argument is greater than 1 and

     * the second argument is negative infinity, or

     * <li>the absolute value of the

     * first argument is less than 1 and the second argument is positive

     * infinity,

     * </ul>

     * then the result is positive zero.

     *

     * <li>If the absolute value of the first argument equals 1 and the

     * second argument is infinite, then the result is NaN.

     *

     * <li>If

     * <ul>

     * <li>the first argument is positive zero and the second argument

     * is greater than zero, or

     * <li>the first argument is positive infinity and the second

     * argument is less than zero,

     * </ul>

     * then the result is positive zero.

     *

     * <li>If

     * <ul>

     * <li>the first argument is positive zero and the second argument

     * is less than zero, or

     * <li>the first argument is positive infinity and the second

     * argument is greater than zero,

     * </ul>

     * then the result is positive infinity.

     *

     * <li>If

     * <ul>

     * <li>the first argument is negative zero and the second argument

     * is greater than zero but not a finite odd integer, or

     * <li>the first argument is negative infinity and the second

     * argument is less than zero but not a finite odd integer,

     * </ul>

     * then the result is positive zero.

     *

     * <li>If

     * <ul>

     * <li>the first argument is negative zero and the second argument

     * is a positive finite odd integer, or

     * <li>the first argument is negative infinity and the second

     * argument is a negative finite odd integer,

     * </ul>

     * then the result is negative zero.

     *

     * <li>If

     * <ul>

     * <li>the first argument is negative zero and the second argument

     * is less than zero but not a finite odd integer, or

     * <li>the first argument is negative infinity and the second

     * argument is greater than zero but not a finite odd integer,

     * </ul>

     * then the result is positive infinity.

     *

     * <li>If

     * <ul>

     * <li>the first argument is negative zero and the second argument

     * is a negative finite odd integer, or

     * <li>the first argument is negative infinity and the second

     * argument is a positive finite odd integer,

     * </ul>

     * then the result is negative infinity.

     *

     * <li>If the first argument is finite and less than zero

     * <ul>

     * <li> if the second argument is a finite even integer, the

     * result is equal to the result of raising the absolute value of

     * the first argument to the power of the second argument

     *

     * <li>if the second argument is a finite odd integer, 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>if the second argument is finite and not an integer, then

     * the result is NaN.

     * </ul>

     *

     * <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 {@code double} value.</ul>

     *

     * <p>(In the foregoing descriptions, a floating-point value is

     * considered to be an integer if and only if it is finite and a

     * fixed point of the method {@link #ceil ceil} or,

     * equivalently, a fixed point of the method {@link #floor

     * floor}. 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.)

     *

     * <p>The computed result must be within 1 ulp of the exact result.

     * Results must be semi-monotonic.

     *

     * @param   a   the base.

     * @param   b   the exponent.

     * @return  the value {@code a}<sup>{@code b}</sup>.

     */

    public static double pow(double a, double b) {

        return StrictMath.pow(a, b); // default impl. delegates to StrictMath

    }

    /**

     * Returns the closest {@code int} to the argument, with ties

     * rounding up.

     *

     * <p>

     * Special cases:

     * <ul><li>If the argument is NaN, the result is 0.

     * <li>If the argument is negative infinity or any value less than or

     * equal to the value of {@code Integer.MIN_VALUE}, the result is

     * equal to the value of {@code Integer.MIN_VALUE}.

     * <li>If the argument is positive infinity or any value greater than or

     * equal to the value of {@code Integer.MAX_VALUE}, the result is

     * equal to the value of {@code Integer.MAX_VALUE}.</ul>

     *

     * @param   a   a floating-point value to be rounded to an integer.

     * @return  the value of the argument rounded to the nearest

     *          {@code int} value.

     * @see     java.lang.Integer#MAX_VALUE

     * @see     java.lang.Integer#MIN_VALUE

     */

    public static int round(float a) {

        if (a != 0x1.fffffep-2f) // greatest float value less than 0.5

            return (int)floor(a + 0.5f);

        else

            return 0;

    }

    /**

     * Returns the closest {@code long} to the argument, with ties

     * rounding up.

     *

     * <p>Special cases:

     * <ul><li>If the argument is NaN, the result is 0.

     * <li>If the argument is negative infinity or any value less than or

     * equal to the value of {@code Long.MIN_VALUE}, the result is

     * equal to the value of {@code Long.MIN_VALUE}.

     * <li>If the argument is positive infinity or any value greater than or

     * equal to the value of {@code Long.MAX_VALUE}, the result is

     * equal to the value of {@code Long.MAX_VALUE}.</ul>

     *

     * @param   a   a floating-point value to be rounded to a

     *          {@code long}.

     * @return  the value of the argument rounded to the nearest

     *          {@code long} value.

     * @see     java.lang.Long#MAX_VALUE

     * @see     java.lang.Long#MIN_VALUE

     */

    public static long round(double a) {

        if (a != 0x1.fffffffffffffp-2) // greatest double value less than 0.5

            return (long)floor(a + 0.5d);

        else

            return 0;

    }

    private static Random randomNumberGenerator;

    private static synchronized Random initRNG() {

        Random rnd = randomNumberGenerator;

        return (rnd == null) ? (randomNumberGenerator = new Random()) : rnd;

    }

    /**

     * Returns a {@code double} value with a positive sign, greater

     * than or equal to {@code 0.0} and less than {@code 1.0}.

     * Returned values are chosen pseudorandomly with (approximately)

     * uniform distribution from that range.

     *

     * <p>When this method is first called, it creates a single new

     * pseudorandom-number generator, exactly as if by the expression

     *

     * <blockquote>{@code new java.util.Random()}</blockquote>

     *

     * This new pseudorandom-number generator is used thereafter for

     * all calls to this method and is used nowhere else.

     *

     * <p>This method is properly synchronized to allow correct use by

     * more than one thread. However, if many threads need to generate

     * pseudorandom numbers at a great rate, it may reduce contention

     * for each thread to have its own pseudorandom-number generator.

     *

     * @return  a pseudorandom {@code double} greater than or equal

     * to {@code 0.0} and less than {@code 1.0}.

     * @see Random#nextDouble()

     */

    public static double random() {

        Random rnd = randomNumberGenerator;

        if (rnd == null) rnd = initRNG();

        return rnd.nextDouble();

    }

    /**

     * Returns the absolute value of an {@code int} value.

     * If the argument is not negative, the argument is returned.

     * If the argument is negative, the negation of the argument is returned.

     *

     * <p>Note that if the argument is equal to the value of

     * {@link Integer#MIN_VALUE}, the most negative representable

     * {@code int} value, the result is that same value, which is

     * negative.

     *

     * @param   a   the argument whose absolute value is to be determined

     * @return  the absolute value of the argument.

     */

    public static int abs(int a) {

        return (a < 0) ? -a : a;

    }

    /**

     * Returns the absolute value of a {@code long} value.

     * If the argument is not negative, the argument is returned.

     * If the argument is negative, the negation of the argument is returned.

     *

     * <p>Note that if the argument is equal to the value of

     * {@link Long#MIN_VALUE}, the most negative representable

     * {@code long} value, the result is that same value, which

     * is negative.

     *

     * @param   a   the argument whose absolute value is to be determined

     * @return  the absolute value of the argument.

     */

    public static long abs(long a) {

        return (a < 0) ? -a : a;

    }

    /**

     * Returns the absolute value of a {@code float} value.

     * If the argument is not negative, the argument is returned.

     * If the argument is negative, the negation of the argument is returned.

     * Special cases:

     * <ul><li>If the argument is positive zero or negative zero, the

     * result is positive zero.

     * <li>If the argument is infinite, the result is positive infinity.

     * <li>If the argument is NaN, the result is NaN.</ul>

     * In other words, the result is the same as the value of the expression:

     * <p>{@code Float.intBitsToFloat(0x7fffffff & Float.floatToIntBits(a))}

     *

     * @param   a   the argument whose absolute value is to be determined

     * @return  the absolute value of the argument.

     */

    public static float abs(float a) {

        return (a <= 0.0F) ? 0.0F - a : a;

    }

    /**

     * Returns the absolute value of a {@code double} value.

     * If the argument is not negative, the argument is returned.

     * If the argument is negative, the negation of the argument is returned.

     * Special cases:

     * <ul><li>If the argument is positive zero or negative zero, the result

     * is positive zero.

     * <li>If the argument is infinite, the result is positive infinity.

     * <li>If the argument is NaN, the result is NaN.</ul>

     * In other words, the result is the same as the value of the expression:

     * <p>{@code Double.longBitsToDouble((Double.doubleToLongBits(a)<<1)>>>1)}

     *

     * @param   a   the argument whose absolute value is to be determined

     * @return  the absolute value of the argument.

     */

    public static double abs(double a) {

        return (a <= 0.0D) ? 0.0D - a : a;

    }

    /**

     * Returns the greater of two {@code int} values. That is, the

     * result is the argument closer to the value of

     * {@link Integer#MAX_VALUE}. If the arguments have the same value,

     * the result is that same value.

     *

     * @param   a   an argument.

     * @param   b   another argument.

     * @return  the larger of {@code a} and {@code b}.

     */

    public static int max(int a, int b) {

        return (a >= b) ? a : b;

    }

    /**

     * Returns the greater of two {@code long} values. That is, the

     * result is the argument closer to the value of

     * {@link Long#MAX_VALUE}. If the arguments have the same value,

     * the result is that same value.

     *

     * @param   a   an argument.

     * @param   b   another argument.

     * @return  the larger of {@code a} and {@code b}.

     */

    public static long max(long a, long b) {

        return (a >= b) ? a : b;

    }

    private static long negativeZeroFloatBits = Float.floatToIntBits(-0.0f);

    private static long negativeZeroDoubleBits = Double.doubleToLongBits(-0.0d);

    /**

     * Returns the greater of two {@code float} values.  That is,

     * the result is the argument closer to positive infinity. If the

     * arguments have the same value, the result is that same

     * value. If either value is NaN, then the result is NaN.  Unlike

     * the numerical comparison operators, this method considers

     * negative zero to be strictly smaller than positive zero. If one

     * argument is positive zero and the other negative zero, the

     * result is positive zero.

     *

     * @param   a   an argument.

     * @param   b   another argument.

     * @return  the larger of {@code a} and {@code b}.

     */

    public static float max(float a, float b) {

        if (a != a) return a;   // a is NaN

        if ((a == 0.0f) && (b == 0.0f)

            && (Float.floatToIntBits(a) == negativeZeroFloatBits)) {

            return b;

        }

        return (a >= b) ? a : b;

    }

    /**

     * Returns the greater of two {@code double} values.  That

     * is, the result is the argument closer to positive infinity. If

     * the arguments have the same value, the result is that same

     * value. If either value is NaN, then the result is NaN.  Unlike

     * the numerical comparison operators, this method considers

     * negative zero to be strictly smaller than positive zero. If one

     * argument is positive zero and the other negative zero, the

     * result is positive zero.

     *

     * @param   a   an argument.

     * @param   b   another argument.

     * @return  the larger of {@code a} and {@code b}.

     */

    public static double max(double a, double b) {

        if (a != a) return a;   // a is NaN

        if ((a == 0.0d) && (b == 0.0d)

            && (Double.doubleToLongBits(a) == negativeZeroDoubleBits)) {

            return b;

        }

        return (a >= b) ? a : b;

    }

    /**

     * Returns the smaller of two {@code int} values. That is,

     * the result the argument closer to the value of

     * {@link Integer#MIN_VALUE}.  If the arguments have the same

     * value, the result is that same value.

     *

     * @param   a   an argument.

     * @param   b   another argument.

     * @return  the smaller of {@code a} and {@code b}.

     */

    public static int min(int a, int b) {

        return (a <= b) ? a : b;

    }

    /**

     * Returns the smaller of two {@code long} values. That is,

     * the result is the argument closer to the value of

     * {@link Long#MIN_VALUE}. If the arguments have the same

     * value, the result is that same value.

     *

     * @param   a   an argument.

     * @param   b   another argument.

     * @return  the smaller of {@code a} and {@code b}.

     */

    public static long min(long a, long b) {

        return (a <= b) ? a : b;

    }

    /**

     * Returns the smaller of two {@code float} values.  That is,

     * the result is the value closer to negative infinity. If the

     * arguments have the same value, the result is that same

     * value. If either value is NaN, then the result is NaN.  Unlike

     * the numerical comparison operators, this method considers

     * negative zero to be strictly smaller than positive zero.  If

     * one argument is positive zero and the other is negative zero,

     * the result is negative zero.

     *

     * @param   a   an argument.

     * @param   b   another argument.

     * @return  the smaller of {@code a} and {@code b}.

     */

    public static float min(float a, float b) {

        if (a != a) return a;   // a is NaN

        if ((a == 0.0f) && (b == 0.0f)

            && (Float.floatToIntBits(b) == negativeZeroFloatBits)) {

            return b;

        }

        return (a <= b) ? a : b;

    }

    /**

     * Returns the smaller of two {@code double} values.  That

     * is, the result is the value closer to negative infinity. If the

     * arguments have the same value, the result is that same

     * value. If either value is NaN, then the result is NaN.  Unlike

     * the numerical comparison operators, this method considers

     * negative zero to be strictly smaller than positive zero. If one

     * argument is positive zero and the other is negative zero, the

     * result is negative zero.

     *

     * @param   a   an argument.

     * @param   b   another argument.

     * @return  the smaller of {@code a} and {@code b}.

     */

    public static double min(double a, double b) {

        if (a != a) return a;   // a is NaN

        if ((a == 0.0d) && (b == 0.0d)

            && (Double.doubleToLongBits(b) == negativeZeroDoubleBits)) {

            return b;

        }

        return (a <= b) ? a : b;

    }

    /**

     * Returns the size of an ulp of the argument.  An ulp of a

     * {@code double} value is the positive distance between this

     * floating-point value and the {@code double} value next

     * larger in magnitude.  Note that for non-NaN <i>x</i>,

     * <code>ulp(-<i>x</i>) == ulp(<i>x</i>)</code>.

     *

     * <p>Special Cases:

     * <ul>

     * <li> If the argument is NaN, then the result is NaN.

     * <li> If the argument is positive or negative infinity, then the

     * result is positive infinity.

     * <li> If the argument is positive or negative zero, then the result is

     * {@code Double.MIN_VALUE}.

     * <li> If the argument is &plusmn;{@code Double.MAX_VALUE}, then

     * the result is equal to 2<sup>971</sup>.

     * </ul>

     *

     * @param d the floating-point value whose ulp is to be returned

     * @return the size of an ulp of the argument

     * @author Joseph D. Darcy

     * @since 1.5

     */

    public static double ulp(double d) {

        return sun.misc.FpUtils.ulp(d);

    }

    /**

     * Returns the size of an ulp of the argument.  An ulp of a

     * {@code float} value is the positive distance between this

     * floating-point value and the {@code float} value next

     * larger in magnitude.  Note that for non-NaN <i>x</i>,

     * <code>ulp(-<i>x</i>) == ulp(<i>x</i>)</code>.

     *

     * <p>Special Cases:

     * <ul>

     * <li> If the argument is NaN, then the result is NaN.

     * <li> If the argument is positive or negative infinity, then the

     * result is positive infinity.

     * <li> If the argument is positive or negative zero, then the result is

     * {@code Float.MIN_VALUE}.

     * <li> If the argument is &plusmn;{@code Float.MAX_VALUE}, then

     * the result is equal to 2<sup>104</sup>.

     * </ul>

     *

     * @param f the floating-point value whose ulp is to be returned

     * @return the size of an ulp of the argument

     * @author Joseph D. Darcy

     * @since 1.5

     */

    public static float ulp(float f) {

        return sun.misc.FpUtils.ulp(f);