java库函数-----Math库函数(每日一更)
目录区
Java中的数学函数的应用:Math.sin,Math.exp。
源码区
/*
* Copyright (c) 1994, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
package java.lang;
import java.util.Random;
import sun.misc.FloatConsts;
import sun.misc.DoubleConsts;
/**
* 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 {@linkplain #ulp(double) 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.
*
* <p>
* The platform uses signed two's complement integer arithmetic with
* int and long primitive types. The developer should choose
* the primitive type to ensure that arithmetic operations consistently
* produce correct results, which in some cases means the operations
* will not overflow the range of values of the computation.
* The best practice is to choose the primitive type and algorithm to avoid
* overflow. In cases where the size is {@code int} or {@code long} and
* overflow errors need to be detected, the methods {@code addExact},
* {@code subtractExact}, {@code multiplyExact}, and {@code toIntExact}
* throw an {@code ArithmeticException} when the results overflow.
* For other arithmetic operations such as divide, absolute value,
* increment, decrement, and negation overflow occurs only with
* a specific minimum or maximum value and should be checked against
* the minimum or maximum as appropriate.
*
* @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 - f2</code> × <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, <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