2 * Copyright (c) 1994, 2011, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
28 import org.apidesign.bck2brwsr.core.JavaScriptBody;
32 * The class {@code Math} contains methods for performing basic
33 * numeric operations such as the elementary exponential, logarithm,
34 * square root, and trigonometric functions.
36 * <p>Unlike some of the numeric methods of class
37 * {@code StrictMath}, all implementations of the equivalent
38 * functions of class {@code Math} are not defined to return the
39 * bit-for-bit same results. This relaxation permits
40 * better-performing implementations where strict reproducibility is
43 * <p>By default many of the {@code Math} methods simply call
44 * the equivalent method in {@code StrictMath} for their
45 * implementation. Code generators are encouraged to use
46 * platform-specific native libraries or microprocessor instructions,
47 * where available, to provide higher-performance implementations of
48 * {@code Math} methods. Such higher-performance
49 * implementations still must conform to the specification for
52 * <p>The quality of implementation specifications concern two
53 * properties, accuracy of the returned result and monotonicity of the
54 * method. Accuracy of the floating-point {@code Math} methods
55 * is measured in terms of <i>ulps</i>, units in the last place. For
56 * a given floating-point format, an ulp of a specific real number
57 * value is the distance between the two floating-point values
58 * bracketing that numerical value. When discussing the accuracy of a
59 * method as a whole rather than at a specific argument, the number of
60 * ulps cited is for the worst-case error at any argument. If a
61 * method always has an error less than 0.5 ulps, the method always
62 * returns the floating-point number nearest the exact result; such a
63 * method is <i>correctly rounded</i>. A correctly rounded method is
64 * generally the best a floating-point approximation can be; however,
65 * it is impractical for many floating-point methods to be correctly
66 * rounded. Instead, for the {@code Math} class, a larger error
67 * bound of 1 or 2 ulps is allowed for certain methods. Informally,
68 * with a 1 ulp error bound, when the exact result is a representable
69 * number, the exact result should be returned as the computed result;
70 * otherwise, either of the two floating-point values which bracket
71 * the exact result may be returned. For exact results large in
72 * magnitude, one of the endpoints of the bracket may be infinite.
73 * Besides accuracy at individual arguments, maintaining proper
74 * relations between the method at different arguments is also
75 * important. Therefore, most methods with more than 0.5 ulp errors
76 * are required to be <i>semi-monotonic</i>: whenever the mathematical
77 * function is non-decreasing, so is the floating-point approximation,
78 * likewise, whenever the mathematical function is non-increasing, so
79 * is the floating-point approximation. Not all approximations that
80 * have 1 ulp accuracy will automatically meet the monotonicity
84 * @author Joseph D. Darcy
88 public final class Math {
91 * Don't let anyone instantiate this class.
96 * The {@code double} value that is closer than any other to
97 * <i>e</i>, the base of the natural logarithms.
99 public static final double E = 2.7182818284590452354;
102 * The {@code double} value that is closer than any other to
103 * <i>pi</i>, the ratio of the circumference of a circle to its
106 public static final double PI = 3.14159265358979323846;
109 * Returns the trigonometric sine of an angle. Special cases:
110 * <ul><li>If the argument is NaN or an infinity, then the
112 * <li>If the argument is zero, then the result is a zero with the
113 * same sign as the argument.</ul>
115 * <p>The computed result must be within 1 ulp of the exact result.
116 * Results must be semi-monotonic.
118 * @param a an angle, in radians.
119 * @return the sine of the argument.
121 @JavaScriptBody(args="a", body="return Math.sin(a);")
122 public static double sin(double a) {
123 throw new UnsupportedOperationException();
127 * Returns the trigonometric cosine of an angle. Special cases:
128 * <ul><li>If the argument is NaN or an infinity, then the
129 * result is NaN.</ul>
131 * <p>The computed result must be within 1 ulp of the exact result.
132 * Results must be semi-monotonic.
134 * @param a an angle, in radians.
135 * @return the cosine of the argument.
137 @JavaScriptBody(args="a", body="return Math.cos(a);")
138 public static double cos(double a) {
139 throw new UnsupportedOperationException();
143 * Returns the trigonometric tangent of an angle. Special cases:
144 * <ul><li>If the argument is NaN or an infinity, then the result
146 * <li>If the argument is zero, then the result is a zero with the
147 * same sign as the argument.</ul>
149 * <p>The computed result must be within 1 ulp of the exact result.
150 * Results must be semi-monotonic.
152 * @param a an angle, in radians.
153 * @return the tangent of the argument.
155 @JavaScriptBody(args="a", body="return Math.tan(a);")
156 public static double tan(double a) {
157 throw new UnsupportedOperationException();
161 * Returns the arc sine of a value; the returned angle is in the
162 * range -<i>pi</i>/2 through <i>pi</i>/2. Special cases:
163 * <ul><li>If the argument is NaN or its absolute value is greater
164 * than 1, then the result is NaN.
165 * <li>If the argument is zero, then the result is a zero with the
166 * same sign as the argument.</ul>
168 * <p>The computed result must be within 1 ulp of the exact result.
169 * Results must be semi-monotonic.
171 * @param a the value whose arc sine is to be returned.
172 * @return the arc sine of the argument.
174 @JavaScriptBody(args="a", body="return Math.asin(a);")
175 public static double asin(double a) {
176 throw new UnsupportedOperationException();
180 * Returns the arc cosine of a value; the returned angle is in the
181 * range 0.0 through <i>pi</i>. Special case:
182 * <ul><li>If the argument is NaN or its absolute value is greater
183 * than 1, then the result is NaN.</ul>
185 * <p>The computed result must be within 1 ulp of the exact result.
186 * Results must be semi-monotonic.
188 * @param a the value whose arc cosine is to be returned.
189 * @return the arc cosine of the argument.
191 @JavaScriptBody(args="a", body="return Math.acos(a);")
192 public static double acos(double a) {
193 throw new UnsupportedOperationException();
197 * Returns the arc tangent of a value; the returned angle is in the
198 * range -<i>pi</i>/2 through <i>pi</i>/2. Special cases:
199 * <ul><li>If the argument is NaN, then the result is NaN.
200 * <li>If the argument is zero, then the result is a zero with the
201 * same sign as the argument.</ul>
203 * <p>The computed result must be within 1 ulp of the exact result.
204 * Results must be semi-monotonic.
206 * @param a the value whose arc tangent is to be returned.
207 * @return the arc tangent of the argument.
209 @JavaScriptBody(args="a", body="return Math.atan(a);")
210 public static double atan(double a) {
211 throw new UnsupportedOperationException();
215 * Converts an angle measured in degrees to an approximately
216 * equivalent angle measured in radians. The conversion from
217 * degrees to radians is generally inexact.
219 * @param angdeg an angle, in degrees
220 * @return the measurement of the angle {@code angdeg}
224 public static double toRadians(double angdeg) {
225 return angdeg / 180.0 * PI;
229 * Converts an angle measured in radians to an approximately
230 * equivalent angle measured in degrees. The conversion from
231 * radians to degrees is generally inexact; users should
232 * <i>not</i> expect {@code cos(toRadians(90.0))} to exactly
235 * @param angrad an angle, in radians
236 * @return the measurement of the angle {@code angrad}
240 public static double toDegrees(double angrad) {
241 return angrad * 180.0 / PI;
245 * Returns Euler's number <i>e</i> raised to the power of a
246 * {@code double} value. Special cases:
247 * <ul><li>If the argument is NaN, the result is NaN.
248 * <li>If the argument is positive infinity, then the result is
250 * <li>If the argument is negative infinity, then the result is
251 * positive zero.</ul>
253 * <p>The computed result must be within 1 ulp of the exact result.
254 * Results must be semi-monotonic.
256 * @param a the exponent to raise <i>e</i> to.
257 * @return the value <i>e</i><sup>{@code a}</sup>,
258 * where <i>e</i> is the base of the natural logarithms.
260 @JavaScriptBody(args="a", body="return Math.exp(a);")
261 public static double exp(double a) {
262 throw new UnsupportedOperationException();
266 * Returns the natural logarithm (base <i>e</i>) of a {@code double}
267 * value. Special cases:
268 * <ul><li>If the argument is NaN or less than zero, then the result
270 * <li>If the argument is positive infinity, then the result is
272 * <li>If the argument is positive zero or negative zero, then the
273 * result is negative infinity.</ul>
275 * <p>The computed result must be within 1 ulp of the exact result.
276 * Results must be semi-monotonic.
279 * @return the value ln {@code a}, the natural logarithm of
282 @JavaScriptBody(args="a", body="return Math.log(a);")
283 public static double log(double a) {
284 throw new UnsupportedOperationException();
288 * Returns the base 10 logarithm of a {@code double} value.
291 * <ul><li>If the argument is NaN or less than zero, then the result
293 * <li>If the argument is positive infinity, then the result is
295 * <li>If the argument is positive zero or negative zero, then the
296 * result is negative infinity.
297 * <li> If the argument is equal to 10<sup><i>n</i></sup> for
298 * integer <i>n</i>, then the result is <i>n</i>.
301 * <p>The computed result must be within 1 ulp of the exact result.
302 * Results must be semi-monotonic.
305 * @return the base 10 logarithm of {@code a}.
308 @JavaScriptBody(args="a", body="return Math.log(a) / Math.LN10;")
309 public static double log10(double a) {
310 throw new UnsupportedOperationException();
314 * Returns the correctly rounded positive square root of a
315 * {@code double} value.
317 * <ul><li>If the argument is NaN or less than zero, then the result
319 * <li>If the argument is positive infinity, then the result is positive
321 * <li>If the argument is positive zero or negative zero, then the
322 * result is the same as the argument.</ul>
323 * Otherwise, the result is the {@code double} value closest to
324 * the true mathematical square root of the argument value.
327 * @return the positive square root of {@code a}.
328 * If the argument is NaN or less than zero, the result is NaN.
330 @JavaScriptBody(args="a", body="return Math.sqrt(a);")
331 public static double sqrt(double a) {
332 throw new UnsupportedOperationException();
336 * Returns the smallest (closest to negative infinity)
337 * {@code double} value that is greater than or equal to the
338 * argument and is equal to a mathematical integer. Special cases:
339 * <ul><li>If the argument value is already equal to a
340 * mathematical integer, then the result is the same as the
341 * argument. <li>If the argument is NaN or an infinity or
342 * positive zero or negative zero, then the result is the same as
343 * the argument. <li>If the argument value is less than zero but
344 * greater than -1.0, then the result is negative zero.</ul> Note
345 * that the value of {@code Math.ceil(x)} is exactly the
346 * value of {@code -Math.floor(-x)}.
350 * @return the smallest (closest to negative infinity)
351 * floating-point value that is greater than or equal to
352 * the argument and is equal to a mathematical integer.
354 @JavaScriptBody(args="a", body="return Math.ceil(a);")
355 public static double ceil(double a) {
356 throw new UnsupportedOperationException();
360 * Returns the largest (closest to positive infinity)
361 * {@code double} value that is less than or equal to the
362 * argument and is equal to a mathematical integer. Special cases:
363 * <ul><li>If the argument value is already equal to a
364 * mathematical integer, then the result is the same as the
365 * argument. <li>If the argument is NaN or an infinity or
366 * positive zero or negative zero, then the result is the same as
370 * @return the largest (closest to positive infinity)
371 * floating-point value that less than or equal to the argument
372 * and is equal to a mathematical integer.
374 @JavaScriptBody(args="a", body="return Math.floor(a);")
375 public static double floor(double a) {
376 throw new UnsupportedOperationException();
380 * Returns the angle <i>theta</i> from the conversion of rectangular
381 * coordinates ({@code x}, {@code y}) to polar
382 * coordinates (r, <i>theta</i>).
383 * This method computes the phase <i>theta</i> by computing an arc tangent
384 * of {@code y/x} in the range of -<i>pi</i> to <i>pi</i>. Special
386 * <ul><li>If either argument is NaN, then the result is NaN.
387 * <li>If the first argument is positive zero and the second argument
388 * is positive, or the first argument is positive and finite and the
389 * second argument is positive infinity, then the result is positive
391 * <li>If the first argument is negative zero and the second argument
392 * is positive, or the first argument is negative and finite and the
393 * second argument is positive infinity, then the result is negative zero.
394 * <li>If the first argument is positive zero and the second argument
395 * is negative, or the first argument is positive and finite and the
396 * second argument is negative infinity, then the result is the
397 * {@code double} value closest to <i>pi</i>.
398 * <li>If the first argument is negative zero and the second argument
399 * is negative, or the first argument is negative and finite and the
400 * second argument is negative infinity, then the result is the
401 * {@code double} value closest to -<i>pi</i>.
402 * <li>If the first argument is positive and the second argument is
403 * positive zero or negative zero, or the first argument is positive
404 * infinity and the second argument is finite, then the result is the
405 * {@code double} value closest to <i>pi</i>/2.
406 * <li>If the first argument is negative and the second argument is
407 * positive zero or negative zero, or the first argument is negative
408 * infinity and the second argument is finite, then the result is the
409 * {@code double} value closest to -<i>pi</i>/2.
410 * <li>If both arguments are positive infinity, then the result is the
411 * {@code double} value closest to <i>pi</i>/4.
412 * <li>If the first argument is positive infinity and the second argument
413 * is negative infinity, then the result is the {@code double}
414 * value closest to 3*<i>pi</i>/4.
415 * <li>If the first argument is negative infinity and the second argument
416 * is positive infinity, then the result is the {@code double} value
417 * closest to -<i>pi</i>/4.
418 * <li>If both arguments are negative infinity, then the result is the
419 * {@code double} value closest to -3*<i>pi</i>/4.</ul>
421 * <p>The computed result must be within 2 ulps of the exact result.
422 * Results must be semi-monotonic.
424 * @param y the ordinate coordinate
425 * @param x the abscissa coordinate
426 * @return the <i>theta</i> component of the point
427 * (<i>r</i>, <i>theta</i>)
428 * in polar coordinates that corresponds to the point
429 * (<i>x</i>, <i>y</i>) in Cartesian coordinates.
431 @JavaScriptBody(args={"y", "x"}, body="return Math.atan2(y, x);")
432 public static double atan2(double y, double x) {
433 throw new UnsupportedOperationException();
437 * Returns the value of the first argument raised to the power of the
438 * second argument. Special cases:
440 * <ul><li>If the second argument is positive or negative zero, then the
442 * <li>If the second argument is 1.0, then the result is the same as the
444 * <li>If the second argument is NaN, then the result is NaN.
445 * <li>If the first argument is NaN and the second argument is nonzero,
446 * then the result is NaN.
450 * <li>the absolute value of the first argument is greater than 1
451 * and the second argument is positive infinity, or
452 * <li>the absolute value of the first argument is less than 1 and
453 * the second argument is negative infinity,
455 * then the result is positive infinity.
459 * <li>the absolute value of the first argument is greater than 1 and
460 * the second argument is negative infinity, or
461 * <li>the absolute value of the
462 * first argument is less than 1 and the second argument is positive
465 * then the result is positive zero.
467 * <li>If the absolute value of the first argument equals 1 and the
468 * second argument is infinite, then the result is NaN.
472 * <li>the first argument is positive zero and the second argument
473 * is greater than zero, or
474 * <li>the first argument is positive infinity and the second
475 * argument is less than zero,
477 * then the result is positive zero.
481 * <li>the first argument is positive zero and the second argument
482 * is less than zero, or
483 * <li>the first argument is positive infinity and the second
484 * argument is greater than zero,
486 * then the result is positive infinity.
490 * <li>the first argument is negative zero and the second argument
491 * is greater than zero but not a finite odd integer, or
492 * <li>the first argument is negative infinity and the second
493 * argument is less than zero but not a finite odd integer,
495 * then the result is positive zero.
499 * <li>the first argument is negative zero and the second argument
500 * is a positive finite odd integer, or
501 * <li>the first argument is negative infinity and the second
502 * argument is a negative finite odd integer,
504 * then the result is negative zero.
508 * <li>the first argument is negative zero and the second argument
509 * is less than zero but not a finite odd integer, or
510 * <li>the first argument is negative infinity and the second
511 * argument is greater than zero but not a finite odd integer,
513 * then the result is positive infinity.
517 * <li>the first argument is negative zero and the second argument
518 * is a negative finite odd integer, or
519 * <li>the first argument is negative infinity and the second
520 * argument is a positive finite odd integer,
522 * then the result is negative infinity.
524 * <li>If the first argument is finite and less than zero
526 * <li> if the second argument is a finite even integer, the
527 * result is equal to the result of raising the absolute value of
528 * the first argument to the power of the second argument
530 * <li>if the second argument is a finite odd integer, the result
531 * is equal to the negative of the result of raising the absolute
532 * value of the first argument to the power of the second
535 * <li>if the second argument is finite and not an integer, then
539 * <li>If both arguments are integers, then the result is exactly equal
540 * to the mathematical result of raising the first argument to the power
541 * of the second argument if that result can in fact be represented
542 * exactly as a {@code double} value.</ul>
544 * <p>(In the foregoing descriptions, a floating-point value is
545 * considered to be an integer if and only if it is finite and a
546 * fixed point of the method {@link #ceil ceil} or,
547 * equivalently, a fixed point of the method {@link #floor
548 * floor}. A value is a fixed point of a one-argument
549 * method if and only if the result of applying the method to the
550 * value is equal to the value.)
552 * <p>The computed result must be within 1 ulp of the exact result.
553 * Results must be semi-monotonic.
556 * @param b the exponent.
557 * @return the value {@code a}<sup>{@code b}</sup>.
559 @JavaScriptBody(args={"a", "b"}, body="return Math.pow(a, b);")
560 public static double pow(double a, double b) {
561 throw new UnsupportedOperationException();
565 * Returns the closest {@code int} to the argument, with ties
570 * <ul><li>If the argument is NaN, the result is 0.
571 * <li>If the argument is negative infinity or any value less than or
572 * equal to the value of {@code Integer.MIN_VALUE}, the result is
573 * equal to the value of {@code Integer.MIN_VALUE}.
574 * <li>If the argument is positive infinity or any value greater than or
575 * equal to the value of {@code Integer.MAX_VALUE}, the result is
576 * equal to the value of {@code Integer.MAX_VALUE}.</ul>
578 * @param a a floating-point value to be rounded to an integer.
579 * @return the value of the argument rounded to the nearest
581 * @see java.lang.Integer#MAX_VALUE
582 * @see java.lang.Integer#MIN_VALUE
584 @JavaScriptBody(args="a", body="return Math.round(a);")
585 public static int round(float a) {
586 throw new UnsupportedOperationException();
590 * Returns the closest {@code long} to the argument, with ties
594 * <ul><li>If the argument is NaN, the result is 0.
595 * <li>If the argument is negative infinity or any value less than or
596 * equal to the value of {@code Long.MIN_VALUE}, the result is
597 * equal to the value of {@code Long.MIN_VALUE}.
598 * <li>If the argument is positive infinity or any value greater than or
599 * equal to the value of {@code Long.MAX_VALUE}, the result is
600 * equal to the value of {@code Long.MAX_VALUE}.</ul>
602 * @param a a floating-point value to be rounded to a
604 * @return the value of the argument rounded to the nearest
605 * {@code long} value.
606 * @see java.lang.Long#MAX_VALUE
607 * @see java.lang.Long#MIN_VALUE
609 @JavaScriptBody(args="a", body="return Math.round(a);")
610 public static long round(double a) {
611 throw new UnsupportedOperationException();
614 // private static Random randomNumberGenerator;
616 // private static synchronized Random initRNG() {
617 // Random rnd = randomNumberGenerator;
618 // return (rnd == null) ? (randomNumberGenerator = new Random()) : rnd;
622 * Returns a {@code double} value with a positive sign, greater
623 * than or equal to {@code 0.0} and less than {@code 1.0}.
624 * Returned values are chosen pseudorandomly with (approximately)
625 * uniform distribution from that range.
627 * <p>When this method is first called, it creates a single new
628 * pseudorandom-number generator, exactly as if by the expression
630 * <blockquote>{@code new java.util.Random()}</blockquote>
632 * This new pseudorandom-number generator is used thereafter for
633 * all calls to this method and is used nowhere else.
635 * <p>This method is properly synchronized to allow correct use by
636 * more than one thread. However, if many threads need to generate
637 * pseudorandom numbers at a great rate, it may reduce contention
638 * for each thread to have its own pseudorandom-number generator.
640 * @return a pseudorandom {@code double} greater than or equal
641 * to {@code 0.0} and less than {@code 1.0}.
642 * @see Random#nextDouble()
644 public static double random() {
645 throw new UnsupportedOperationException();
649 * Returns the absolute value of an {@code int} value.
650 * If the argument is not negative, the argument is returned.
651 * If the argument is negative, the negation of the argument is returned.
653 * <p>Note that if the argument is equal to the value of
654 * {@link Integer#MIN_VALUE}, the most negative representable
655 * {@code int} value, the result is that same value, which is
658 * @param a the argument whose absolute value is to be determined
659 * @return the absolute value of the argument.
661 public static int abs(int a) {
662 return (a < 0) ? -a : a;
666 * Returns the absolute value of a {@code long} value.
667 * If the argument is not negative, the argument is returned.
668 * If the argument is negative, the negation of the argument is returned.
670 * <p>Note that if the argument is equal to the value of
671 * {@link Long#MIN_VALUE}, the most negative representable
672 * {@code long} value, the result is that same value, which
675 * @param a the argument whose absolute value is to be determined
676 * @return the absolute value of the argument.
678 public static long abs(long a) {
679 return (a < 0) ? -a : a;
683 * Returns the absolute value of a {@code float} value.
684 * If the argument is not negative, the argument is returned.
685 * If the argument is negative, the negation of the argument is returned.
687 * <ul><li>If the argument is positive zero or negative zero, the
688 * result is positive zero.
689 * <li>If the argument is infinite, the result is positive infinity.
690 * <li>If the argument is NaN, the result is NaN.</ul>
691 * In other words, the result is the same as the value of the expression:
692 * <p>{@code Float.intBitsToFloat(0x7fffffff & Float.floatToIntBits(a))}
694 * @param a the argument whose absolute value is to be determined
695 * @return the absolute value of the argument.
697 public static float abs(float a) {
698 return (a <= 0.0F) ? 0.0F - a : a;
702 * Returns the absolute value of a {@code double} value.
703 * If the argument is not negative, the argument is returned.
704 * If the argument is negative, the negation of the argument is returned.
706 * <ul><li>If the argument is positive zero or negative zero, the result
708 * <li>If the argument is infinite, the result is positive infinity.
709 * <li>If the argument is NaN, the result is NaN.</ul>
710 * In other words, the result is the same as the value of the expression:
711 * <p>{@code Double.longBitsToDouble((Double.doubleToLongBits(a)<<1)>>>1)}
713 * @param a the argument whose absolute value is to be determined
714 * @return the absolute value of the argument.
716 public static double abs(double a) {
717 return (a <= 0.0D) ? 0.0D - a : a;
721 * Returns the greater of two {@code int} values. That is, the
722 * result is the argument closer to the value of
723 * {@link Integer#MAX_VALUE}. If the arguments have the same value,
724 * the result is that same value.
726 * @param a an argument.
727 * @param b another argument.
728 * @return the larger of {@code a} and {@code b}.
730 public static int max(int a, int b) {
731 return (a >= b) ? a : b;
735 * Returns the greater of two {@code long} values. That is, the
736 * result is the argument closer to the value of
737 * {@link Long#MAX_VALUE}. If the arguments have the same value,
738 * the result is that same value.
740 * @param a an argument.
741 * @param b another argument.
742 * @return the larger of {@code a} and {@code b}.
744 public static long max(long a, long b) {
745 return (a >= b) ? a : b;
749 * Returns the greater of two {@code float} values. That is,
750 * the result is the argument closer to positive infinity. If the
751 * arguments have the same value, the result is that same
752 * value. If either value is NaN, then the result is NaN. Unlike
753 * the numerical comparison operators, this method considers
754 * negative zero to be strictly smaller than positive zero. If one
755 * argument is positive zero and the other negative zero, the
756 * result is positive zero.
758 * @param a an argument.
759 * @param b another argument.
760 * @return the larger of {@code a} and {@code b}.
762 @JavaScriptBody(args={"a", "b"},
763 body="return Math.max(a,b);"
765 public static float max(float a, float b) {
766 throw new UnsupportedOperationException();
770 * Returns the greater of two {@code double} values. That
771 * is, the result is the argument closer to positive infinity. If
772 * the arguments have the same value, the result is that same
773 * value. If either value is NaN, then the result is NaN. Unlike
774 * the numerical comparison operators, this method considers
775 * negative zero to be strictly smaller than positive zero. If one
776 * argument is positive zero and the other negative zero, the
777 * result is positive zero.
779 * @param a an argument.
780 * @param b another argument.
781 * @return the larger of {@code a} and {@code b}.
783 @JavaScriptBody(args={"a", "b"},
784 body="return Math.max(a,b);"
786 public static double max(double a, double b) {
787 throw new UnsupportedOperationException();
791 * Returns the smaller of two {@code int} values. That is,
792 * the result the argument closer to the value of
793 * {@link Integer#MIN_VALUE}. If the arguments have the same
794 * value, the result is that same value.
796 * @param a an argument.
797 * @param b another argument.
798 * @return the smaller of {@code a} and {@code b}.
800 public static int min(int a, int b) {
801 return (a <= b) ? a : b;
805 * Returns the smaller of two {@code long} values. That is,
806 * the result is the argument closer to the value of
807 * {@link Long#MIN_VALUE}. If the arguments have the same
808 * value, the result is that same value.
810 * @param a an argument.
811 * @param b another argument.
812 * @return the smaller of {@code a} and {@code b}.
814 public static long min(long a, long b) {
815 return (a <= b) ? a : b;
819 * Returns the smaller of two {@code float} values. That is,
820 * the result is the value closer to negative infinity. If the
821 * arguments have the same value, the result is that same
822 * value. If either value is NaN, then the result is NaN. Unlike
823 * the numerical comparison operators, this method considers
824 * negative zero to be strictly smaller than positive zero. If
825 * one argument is positive zero and the other is negative zero,
826 * the result is negative zero.
828 * @param a an argument.
829 * @param b another argument.
830 * @return the smaller of {@code a} and {@code b}.
832 @JavaScriptBody(args={"a", "b"},
833 body="return Math.min(a,b);"
835 public static float min(float a, float b) {
836 throw new UnsupportedOperationException();
840 * Returns the smaller of two {@code double} values. That
841 * is, the result is the value closer to negative infinity. If the
842 * arguments have the same value, the result is that same
843 * value. If either value is NaN, then the result is NaN. Unlike
844 * the numerical comparison operators, this method considers
845 * negative zero to be strictly smaller than positive zero. If one
846 * argument is positive zero and the other is negative zero, the
847 * result is negative zero.
849 * @param a an argument.
850 * @param b another argument.
851 * @return the smaller of {@code a} and {@code b}.
853 @JavaScriptBody(args={"a", "b"},
854 body="return Math.min(a,b);"
856 public static double min(double a, double b) {
857 throw new UnsupportedOperationException();
861 * Returns the size of an ulp of the argument. An ulp of a
862 * {@code double} value is the positive distance between this
863 * floating-point value and the {@code double} value next
864 * larger in magnitude. Note that for non-NaN <i>x</i>,
865 * <code>ulp(-<i>x</i>) == ulp(<i>x</i>)</code>.
869 * <li> If the argument is NaN, then the result is NaN.
870 * <li> If the argument is positive or negative infinity, then the
871 * result is positive infinity.
872 * <li> If the argument is positive or negative zero, then the result is
873 * {@code Double.MIN_VALUE}.
874 * <li> If the argument is ±{@code Double.MAX_VALUE}, then
875 * the result is equal to 2<sup>971</sup>.
878 * @param d the floating-point value whose ulp is to be returned
879 * @return the size of an ulp of the argument
880 * @author Joseph D. Darcy
883 // public static double ulp(double d) {
884 // return sun.misc.FpUtils.ulp(d);
888 * Returns the size of an ulp of the argument. An ulp of a
889 * {@code float} value is the positive distance between this
890 * floating-point value and the {@code float} value next
891 * larger in magnitude. Note that for non-NaN <i>x</i>,
892 * <code>ulp(-<i>x</i>) == ulp(<i>x</i>)</code>.
896 * <li> If the argument is NaN, then the result is NaN.
897 * <li> If the argument is positive or negative infinity, then the
898 * result is positive infinity.
899 * <li> If the argument is positive or negative zero, then the result is
900 * {@code Float.MIN_VALUE}.
901 * <li> If the argument is ±{@code Float.MAX_VALUE}, then
902 * the result is equal to 2<sup>104</sup>.
905 * @param f the floating-point value whose ulp is to be returned
906 * @return the size of an ulp of the argument
907 * @author Joseph D. Darcy
910 // public static float ulp(float f) {
911 // return sun.misc.FpUtils.ulp(f);
915 * Returns the signum function of the argument; zero if the argument
916 * is zero, 1.0 if the argument is greater than zero, -1.0 if the
917 * argument is less than zero.
921 * <li> If the argument is NaN, then the result is NaN.
922 * <li> If the argument is positive zero or negative zero, then the
923 * result is the same as the argument.
926 * @param d the floating-point value whose signum is to be returned
927 * @return the signum function of the argument
928 * @author Joseph D. Darcy
931 // public static double signum(double d) {
932 // return sun.misc.FpUtils.signum(d);
936 * Returns the signum function of the argument; zero if the argument
937 * is zero, 1.0f if the argument is greater than zero, -1.0f if the
938 * argument is less than zero.
942 * <li> If the argument is NaN, then the result is NaN.
943 * <li> If the argument is positive zero or negative zero, then the
944 * result is the same as the argument.
947 * @param f the floating-point value whose signum is to be returned
948 * @return the signum function of the argument
949 * @author Joseph D. Darcy
952 // public static float signum(float f) {
953 // return sun.misc.FpUtils.signum(f);
957 * Returns the first floating-point argument with the sign of the
958 * second floating-point argument. Note that unlike the {@link
959 * StrictMath#copySign(double, double) StrictMath.copySign}
960 * method, this method does not require NaN {@code sign}
961 * arguments to be treated as positive values; implementations are
962 * permitted to treat some NaN arguments as positive and other NaN
963 * arguments as negative to allow greater performance.
965 * @param magnitude the parameter providing the magnitude of the result
966 * @param sign the parameter providing the sign of the result
967 * @return a value with the magnitude of {@code magnitude}
968 * and the sign of {@code sign}.
971 // public static double copySign(double magnitude, double sign) {
972 // return sun.misc.FpUtils.rawCopySign(magnitude, sign);
976 * Returns the first floating-point argument with the sign of the
977 * second floating-point argument. Note that unlike the {@link
978 * StrictMath#copySign(float, float) StrictMath.copySign}
979 * method, this method does not require NaN {@code sign}
980 * arguments to be treated as positive values; implementations are
981 * permitted to treat some NaN arguments as positive and other NaN
982 * arguments as negative to allow greater performance.
984 * @param magnitude the parameter providing the magnitude of the result
985 * @param sign the parameter providing the sign of the result
986 * @return a value with the magnitude of {@code magnitude}
987 * and the sign of {@code sign}.
990 // public static float copySign(float magnitude, float sign) {
991 // return sun.misc.FpUtils.rawCopySign(magnitude, sign);
995 * Returns the unbiased exponent used in the representation of a
996 * {@code float}. Special cases:
999 * <li>If the argument is NaN or infinite, then the result is
1000 * {@link Float#MAX_EXPONENT} + 1.
1001 * <li>If the argument is zero or subnormal, then the result is
1002 * {@link Float#MIN_EXPONENT} -1.
1004 * @param f a {@code float} value
1005 * @return the unbiased exponent of the argument
1008 // public static int getExponent(float f) {
1009 // return sun.misc.FpUtils.getExponent(f);
1013 * Returns the unbiased exponent used in the representation of a
1014 * {@code double}. Special cases:
1017 * <li>If the argument is NaN or infinite, then the result is
1018 * {@link Double#MAX_EXPONENT} + 1.
1019 * <li>If the argument is zero or subnormal, then the result is
1020 * {@link Double#MIN_EXPONENT} -1.
1022 * @param d a {@code double} value
1023 * @return the unbiased exponent of the argument
1026 // public static int getExponent(double d) {
1027 // return sun.misc.FpUtils.getExponent(d);
1031 * Returns the floating-point number adjacent to the first
1032 * argument in the direction of the second argument. If both
1033 * arguments compare as equal the second argument is returned.
1038 * <li> If either argument is a NaN, then NaN is returned.
1040 * <li> If both arguments are signed zeros, {@code direction}
1041 * is returned unchanged (as implied by the requirement of
1042 * returning the second argument if the arguments compare as
1045 * <li> If {@code start} is
1046 * ±{@link Double#MIN_VALUE} and {@code direction}
1047 * has a value such that the result should have a smaller
1048 * magnitude, then a zero with the same sign as {@code start}
1051 * <li> If {@code start} is infinite and
1052 * {@code direction} has a value such that the result should
1053 * have a smaller magnitude, {@link Double#MAX_VALUE} with the
1054 * same sign as {@code start} is returned.
1056 * <li> If {@code start} is equal to ±
1057 * {@link Double#MAX_VALUE} and {@code direction} has a
1058 * value such that the result should have a larger magnitude, an
1059 * infinity with same sign as {@code start} is returned.
1062 * @param start starting floating-point value
1063 * @param direction value indicating which of
1064 * {@code start}'s neighbors or {@code start} should
1066 * @return The floating-point number adjacent to {@code start} in the
1067 * direction of {@code direction}.
1070 // public static double nextAfter(double start, double direction) {
1071 // return sun.misc.FpUtils.nextAfter(start, direction);
1075 * Returns the floating-point number adjacent to the first
1076 * argument in the direction of the second argument. If both
1077 * arguments compare as equal a value equivalent to the second argument
1083 * <li> If either argument is a NaN, then NaN is returned.
1085 * <li> If both arguments are signed zeros, a value equivalent
1086 * to {@code direction} is returned.
1088 * <li> If {@code start} is
1089 * ±{@link Float#MIN_VALUE} and {@code direction}
1090 * has a value such that the result should have a smaller
1091 * magnitude, then a zero with the same sign as {@code start}
1094 * <li> If {@code start} is infinite and
1095 * {@code direction} has a value such that the result should
1096 * have a smaller magnitude, {@link Float#MAX_VALUE} with the
1097 * same sign as {@code start} is returned.
1099 * <li> If {@code start} is equal to ±
1100 * {@link Float#MAX_VALUE} and {@code direction} has a
1101 * value such that the result should have a larger magnitude, an
1102 * infinity with same sign as {@code start} is returned.
1105 * @param start starting floating-point value
1106 * @param direction value indicating which of
1107 * {@code start}'s neighbors or {@code start} should
1109 * @return The floating-point number adjacent to {@code start} in the
1110 * direction of {@code direction}.
1113 // public static float nextAfter(float start, double direction) {
1114 // return sun.misc.FpUtils.nextAfter(start, direction);
1118 * Returns the floating-point value adjacent to {@code d} in
1119 * the direction of positive infinity. This method is
1120 * semantically equivalent to {@code nextAfter(d,
1121 * Double.POSITIVE_INFINITY)}; however, a {@code nextUp}
1122 * implementation may run faster than its equivalent
1123 * {@code nextAfter} call.
1127 * <li> If the argument is NaN, the result is NaN.
1129 * <li> If the argument is positive infinity, the result is
1130 * positive infinity.
1132 * <li> If the argument is zero, the result is
1133 * {@link Double#MIN_VALUE}
1137 * @param d starting floating-point value
1138 * @return The adjacent floating-point value closer to positive
1142 // public static double nextUp(double d) {
1143 // return sun.misc.FpUtils.nextUp(d);
1147 * Returns the floating-point value adjacent to {@code f} in
1148 * the direction of positive infinity. This method is
1149 * semantically equivalent to {@code nextAfter(f,
1150 * Float.POSITIVE_INFINITY)}; however, a {@code nextUp}
1151 * implementation may run faster than its equivalent
1152 * {@code nextAfter} call.
1156 * <li> If the argument is NaN, the result is NaN.
1158 * <li> If the argument is positive infinity, the result is
1159 * positive infinity.
1161 * <li> If the argument is zero, the result is
1162 * {@link Float#MIN_VALUE}
1166 * @param f starting floating-point value
1167 * @return The adjacent floating-point value closer to positive
1171 // public static float nextUp(float f) {
1172 // return sun.misc.FpUtils.nextUp(f);
1177 * Return {@code d} ×
1178 * 2<sup>{@code scaleFactor}</sup> rounded as if performed
1179 * by a single correctly rounded floating-point multiply to a
1180 * member of the double value set. See the Java
1181 * Language Specification for a discussion of floating-point
1182 * value sets. If the exponent of the result is between {@link
1183 * Double#MIN_EXPONENT} and {@link Double#MAX_EXPONENT}, the
1184 * answer is calculated exactly. If the exponent of the result
1185 * would be larger than {@code Double.MAX_EXPONENT}, an
1186 * infinity is returned. Note that if the result is subnormal,
1187 * precision may be lost; that is, when {@code scalb(x, n)}
1188 * is subnormal, {@code scalb(scalb(x, n), -n)} may not equal
1189 * <i>x</i>. When the result is non-NaN, the result has the same
1190 * sign as {@code d}.
1194 * <li> If the first argument is NaN, NaN is returned.
1195 * <li> If the first argument is infinite, then an infinity of the
1196 * same sign is returned.
1197 * <li> If the first argument is zero, then a zero of the same
1201 * @param d number to be scaled by a power of two.
1202 * @param scaleFactor power of 2 used to scale {@code d}
1203 * @return {@code d} × 2<sup>{@code scaleFactor}</sup>
1206 // public static double scalb(double d, int scaleFactor) {
1207 // return sun.misc.FpUtils.scalb(d, scaleFactor);
1211 * Return {@code f} ×
1212 * 2<sup>{@code scaleFactor}</sup> rounded as if performed
1213 * by a single correctly rounded floating-point multiply to a
1214 * member of the float value set. See the Java
1215 * Language Specification for a discussion of floating-point
1216 * value sets. If the exponent of the result is between {@link
1217 * Float#MIN_EXPONENT} and {@link Float#MAX_EXPONENT}, the
1218 * answer is calculated exactly. If the exponent of the result
1219 * would be larger than {@code Float.MAX_EXPONENT}, an
1220 * infinity is returned. Note that if the result is subnormal,
1221 * precision may be lost; that is, when {@code scalb(x, n)}
1222 * is subnormal, {@code scalb(scalb(x, n), -n)} may not equal
1223 * <i>x</i>. When the result is non-NaN, the result has the same
1224 * sign as {@code f}.
1228 * <li> If the first argument is NaN, NaN is returned.
1229 * <li> If the first argument is infinite, then an infinity of the
1230 * same sign is returned.
1231 * <li> If the first argument is zero, then a zero of the same
1235 * @param f number to be scaled by a power of two.
1236 * @param scaleFactor power of 2 used to scale {@code f}
1237 * @return {@code f} × 2<sup>{@code scaleFactor}</sup>
1240 // public static float scalb(float f, int scaleFactor) {
1241 // return sun.misc.FpUtils.scalb(f, scaleFactor);