EVALUATION
Added methods
copySign
getExponent
nextAfter
nextUp
scalb
for float and double arguments to the Math and StrictMath classes. In addition, constants for MIN_NORMAL, MAX_EXPONENT, and MIN_EXPONENT were added to Float and Double.


SUGGESTED FIX
src/share/classes/java/lang>sccs sccsdiff r1.95 r1.96 Float.java
 Float.java 
64a65,74
> * A constant holding the smallest positive normal value of type
> * {@code float}, 2<sup>126</sup>. It is equal to the
> * hexadecimal floatingpoint literal {@code 0x1.0p126f} and also
> * equal to {@code Float.intBitsToFloat(0x00800000)}.
> *
> * @since 1.6
> */
> public static final float MIN_NORMAL = 0x1.0p126f; // 1.17549435E38f
>
> /**
72a83,100
> * Maximum exponent a finite {@code float} variable may have. It
> * is equal to the value returned by {@code
> * Math.getExponent(Float.MAX_VALUE)}.
> *
> * @since 1.6
> */
> public static final int MAX_EXPONENT = 127;
>
> /**
> * Minimum exponent a normalized {@code float} variable may have.
> * It is equal to the value returned by {@code
> * Math.getExponent(Float.MIN_NORMAL)}.
> *
> * @since 1.6
> */
> public static final int MIN_EXPONENT = 126;
>
> /**
src/share/classes/java/lang>sccs sccsdiff r1.95 r1.96 Double.java
 Double.java 
64a65,74
> * A constant holding the smallest positive normal value of type
> * {@code double}, 2<sup>1022</sup>. It is equal to the
> * hexadecimal floatingpoint literal {@code 0x1.0p1022} and also
> * equal to {@code Double.longBitsToDouble(0x0010000000000000L)}.
> *
> * @since 1.6
> */
> public static final double MIN_NORMAL = 0x1.0p1022; // 2.2250738585072014E308
>
> /**
73a84,101
> * Maximum exponent a finite {@code double} variable may have.
> * It is equal to the value returned by
> * {@code Math.getExponent(Double.MAX_VALUE)}.
> *
> * @since 1.6
> */
> public static final int MAX_EXPONENT = 1023;
>
> /**
> * Minimum exponent a normalized {@code double} variable may
> * have. It is equal to the value returned by
> * {@code Math.getExponent(Double.MIN_NORMAL)}.
> *
> * @since 1.6
> */
> public static final int MIN_EXPONENT = 1022;
>
> /**
src/share/classes/java/lang>sccs sccsdiff r1.70 r1.71 Math.java
 Math.java 
1180a1181
> * @since 1.5
1216a1218
> * @since 1.5
1220a1223,1512
>
> /**
> * Returns the first floatingpoint argument with the sign of the
> * second floatingpoint argument. Note that unlike the {@link
> * StrictMath#copySign(double, double) StrictMath.copySign}
> * method, this method does not require NaN <code>sign</code>
> * arguments to be treated as positive values; implementations are
> * permitted to treat some NaN arguments as positive and other NaN
> * arguments as negative to allow greater performance.
> *
> * @param magnitude the parameter providing the magnitude of the result
> * @param sign the parameter providing the sign of the result
> * @return a value with the magnitude of <code>magnitude</code>
> * and the sign of <code>sign</code>.
> * @since 1.6
> */
> public static double copySign(double magnitude, double sign) {
> return sun.misc.FpUtils.rawCopySign(magnitude, sign);
> }
>
> /**
> * Returns the first floatingpoint argument with the sign of the
> * second floatingpoint argument. Note that unlike the {@link
> * StrictMath#copySign(float, float) StrictMath.copySign}
> * method, this method does not require NaN <code>sign</code>
> * arguments to be treated as positive values; implementations are
> * permitted to treat some NaN arguments as positive and other NaN
> * arguments as negative to allow greater performance.
> *
> * @param magnitude the parameter providing the magnitude of the result
> * @param sign the parameter providing the sign of the result
> * @return a value with the magnitude of <code>magnitude</code>
> * and the sign of <code>sign</code>.
> * @since 1.6
> */
> public static float copySign(float magnitude, float sign) {
> return sun.misc.FpUtils.rawCopySign(magnitude, sign);
> }
>
> /**
> * Returns the unbiased exponent used in the representation of a
> * {@code float}. Special cases:
> *
> * <ul>
> * <li>If the argument is NaN or infinite, then the result is
> * {@link Float#MAX_EXPONENT} + 1.
> * <li>If the argument is zero or subnormal, then the result is
> * {@link Float#MIN_EXPONENT} 1.
> * </ul>
> * @param f a {@code float} value
> * @return the unbiased exponent of the argument
> * @since 1.6
> */
> public static int getExponent(float f) {
> return sun.misc.FpUtils.getExponent(f);
> }
>
> /**
> * Returns the unbiased exponent used in the representation of a
> * {@code double}. Special cases:
> *
> * <ul>
> * <li>If the argument is NaN or infinite, then the result is
> * {@link Double#MAX_EXPONENT} + 1.
> * <li>If the argument is zero or subnormal, then the result is
> * {@link Double#MIN_EXPONENT} 1.
> * </ul>
> * @param d a {@code double} value
> * @return the unbiased exponent of the argument
> * @since 1.6
> */
> public static int getExponent(double d) {
> return sun.misc.FpUtils.getExponent(d);
> }
>
> /**
> * Returns the floatingpoint number adjacent to the first
> * argument in the direction of the second argument. If both
> * arguments compare as equal the second argument is returned.
> *
> * <p>
> * Special cases:
> * <ul>
> * <li> If either argument is a NaN, then NaN is returned.
> *
> * <li> If both arguments are signed zeros, {@code direction}
> * is returned unchanged (as implied by the requirement of
> * returning the second argument if the arguments compare as
> * equal).
> *
> * <li> If {@code start} is
> * ±{@link Double#MIN_VALUE} and {@code direction}
> * has a value such that the result should have a smaller
> * magnitude, then a zero with the same sign as {@code start}
> * is returned.
> *
> * <li> If {@code start} is infinite and
> * {@code direction} has a value such that the result should
> * have a smaller magnitude, {@link Double#MAX_VALUE} with the
> * same sign as {@code start} is returned.
> *
> * <li> If {@code start} is equal to ±
> * {@link Double#MAX_VALUE} and {@code direction} has a
> * value such that the result should have a larger magnitude, an
> * infinity with same sign as {@code start} is returned.
> * </ul>
> *
> * @param start starting floatingpoint value
> * @param direction value indicating which of
> * {@code start}'s neighbors or {@code start} should
> * be returned
> * @return The floatingpoint number adjacent to {@code start} in the
> * direction of {@code direction}.
> * @since 1.6
> */
> public static double nextAfter(double start, double direction) {
> return sun.misc.FpUtils.nextAfter(start, direction);
> }
>
> /**
> * Returns the floatingpoint number adjacent to the first
> * argument in the direction of the second argument. If both
> * arguments compare as equal a value equivalent to the second argument
> * is returned.
> *
> * <p>
> * Special cases:
> * <ul>
> * <li> If either argument is a NaN, then NaN is returned.
> *
> * <li> If both arguments are signed zeros, a value equivalent
> * to {@code direction} is returned.
> *
> * <li> If {@code start} is
> * ±{@link Float#MIN_VALUE} and {@code direction}
> * has a value such that the result should have a smaller
> * magnitude, then a zero with the same sign as {@code start}
> * is returned.
> *
> * <li> If {@code start} is infinite and
> * {@code direction} has a value such that the result should
> * have a smaller magnitude, {@link Float#MAX_VALUE} with the
> * same sign as {@code start} is returned.
> *
> * <li> If {@code start} is equal to ±
> * {@link Float#MAX_VALUE} and {@code direction} has a
> * value such that the result should have a larger magnitude, an
> * infinity with same sign as {@code start} is returned.
> * </ul>
> *
> * @param start starting floatingpoint value
> * @param direction value indicating which of
> * {@code start}'s neighbors or {@code start} should
> * be returned
> * @return The floatingpoint number adjacent to {@code start} in the
> * direction of {@code direction}.
> * @since 1.6
> */
> public static float nextAfter(float start, double direction) {
> return sun.misc.FpUtils.nextAfter(start, direction);
> }
>
> /**
> * Returns the floatingpoint value adjacent to {@code d} in
> * the direction of positive infinity. This method is
> * semantically equivalent to {@code nextAfter(d,
> * Double.POSITIVE_INFINITY)}; however, a {@code nextUp}
> * implementation may run faster than its equivalent
> * {@code nextAfter} call.
> *
> * <p>Special Cases:
> * <ul>
> * <li> If the argument is NaN, the result is NaN.
> *
> * <li> If the argument is positive infinity, the result is
> * positive infinity.
> *
> * <li> If the argument is zero, the result is
> * {@link Double#MIN_VALUE}
> *
> * </ul>
> *
> * @param d starting floatingpoint value
> * @return The adjacent floatingpoint value closer to positive
> * infinity.
> * @since 1.6
> */
> public static double nextUp(double d) {
> return sun.misc.FpUtils.nextUp(d);
> }
>
> /**
> * Returns the floatingpoint value adjacent to {@code f} in
> * the direction of positive infinity. This method is
> * semantically equivalent to {@code nextAfter(f,
> * Float.POSITIVE_INFINITY)}; however, a {@code nextUp}
> * implementation may run faster than its equivalent
> * {@code nextAfter} call.
> *
> * <p>Special Cases:
> * <ul>
> * <li> If the argument is NaN, the result is NaN.
> *
> * <li> If the argument is positive infinity, the result is
> * positive infinity.
> *
> * <li> If the argument is zero, the result is
> * {@link Float#MIN_VALUE}
> *
> * </ul>
> *
> * @param f starting floatingpoint value
> * @return The adjacent floatingpoint value closer to positive
> * infinity.
> * @since 1.6
> */
> public static float nextUp(float f) {
> return sun.misc.FpUtils.nextUp(f);
> }
>
>
> /**
> * Return {@code d} ×
> * 2<sup>{@code scaleFactor}</sup> rounded as if performed
> * by a single correctly rounded floatingpoint multiply to a
> * member of the double value set. See the Java
> * Language Specification for a discussion of floatingpoint
> * value sets. If the exponent of the result is between {@link
> * Double#MIN_EXPONENT} and {@link Double#MAX_EXPONENT}, the
> * answer is calculated exactly. If the exponent of the result
> * would be larger than {@code Double.MAX_EXPONENT}, an
> * infinity is returned. Note that if the result is subnormal,
> * precision may be lost; that is, when {@code scalb(x, n)}
> * is subnormal, {@code scalb(scalb(x, n), n)} may not equal
> * <i>x</i>. When the result is nonNaN, the result has the same
> * sign as {@code d}.
> *
> *<p>
> * Special cases:
> * <ul>
> * <li> If the first argument is NaN, NaN is returned.
> * <li> If the first argument is infinite, then an infinity of the
> * same sign is returned.
> * <li> If the first argument is zero, then a zero of the same
> * sign is returned.
> * </ul>
> *
> * @param d number to be scaled by a power of two.
> * @param scaleFactor power of 2 used to scale {@code d}
> * @return {@code d} × 2<sup>{@code scaleFactor}</sup>
> * @since 1.6
> */
> public static double scalb(double d, int scaleFactor) {
> return sun.misc.FpUtils.scalb(d, scaleFactor);
> }
>
> /**
> * Return {@code f} ×
> * 2<sup>{@code scaleFactor}</sup> rounded as if performed
> * by a single correctly rounded floatingpoint multiply to a
> * member of the float value set. See the Java
> * Language Specification for a discussion of floatingpoint
> * value sets. If the exponent of the result is between {@link
> * Float#MIN_EXPONENT} and {@link Float#MAX_EXPONENT}, the
> * answer is calculated exactly. If the exponent of the result
> * would be larger than {@code Float.MAX_EXPONENT}, an
> * infinity is returned. Note that if the result is subnormal,
> * precision may be lost; that is, when {@code scalb(x, n)}
> * is subnormal, {@code scalb(scalb(x, n), n)} may not equal
> * <i>x</i>. When the result is nonNaN, the result has the same
> * sign as {@code f}.
> *
> *<p>
> * Special cases:
> * <ul>
> * <li> If the first argument is NaN, NaN is returned.
> * <li> If the first argument is infinite, then an infinity of the
> * same sign is returned.
> * <li> If the first argument is zero, then a zero of the same
> * sign is returned.
> * </ul>
> *
> * @param f number to be scaled by a power of two.
> * @param scaleFactor power of 2 used to scale {@code f}
> * @return {@code f} × 2<sup>{@code scaleFactor}</sup>
> * @since 1.6
> */
> public static float scalb(float f, int scaleFactor) {
> return sun.misc.FpUtils.scalb(f, scaleFactor);
> }
src/share/classes/java/lang>sccs sccsdiff r1.27 r1.28 StrictMath.jav>


SUGGESTED FIX
src/share/classes/java/lang>sccs sccsdiff r1.27 r1.28 StrictMath.jav>
 StrictMath.java 
1085a1086
> * @since 1.5
1116a1118
> * @since 1.5
1118a1121,1401
>
> /**
> * Returns the first floatingpoint argument with the sign of the
> * second floatingpoint argument. For this method, a NaN
> * {@code sign} argument is always treated as if it were
> * positive.
> *
> * @param magnitude the parameter providing the magnitude of the result
> * @param sign the parameter providing the sign of the result
> * @return a value with the magnitude of {@code magnitude}
> * and the sign of {@code sign}.
> * @since 1.6
> */
> public static double copySign(double magnitude, double sign) {
> return sun.misc.FpUtils.copySign(magnitude, sign);
> }
>
> /**
> * Returns the first floatingpoint argument with the sign of the
> * second floatingpoint argument. For this method, a NaN
> * {@code sign} argument is always treated as if it were
> * positive.
> *
> * @param magnitude the parameter providing the magnitude of the result
> * @param sign the parameter providing the sign of the result
> * @return a value with the magnitude of {@code magnitude}
> * and the sign of {@code sign}.
> * @since 1.6
> */
> public static float copySign(float magnitude, float sign) {
> return sun.misc.FpUtils.copySign(magnitude, sign);
> }
> /**
> * Returns the unbiased exponent used in the representation of a
> * {@code float}. Special cases:
> *
> * <ul>
> * <li>If the argument is NaN or infinite, then the result is
> * {@link Float#MAX_EXPONENT} + 1.
> * <li>If the argument is zero or subnormal, then the result is
> * {@link Float#MIN_EXPONENT} 1.
> * </ul>
> * @param f a {@code float} value
> * @since 1.6
> */
> public static int getExponent(float f) {
> return sun.misc.FpUtils.getExponent(f);
> }
>
> /**
> * Returns the unbiased exponent used in the representation of a
> * {@code double}. Special cases:
> *
> * <ul>
> * <li>If the argument is NaN or infinite, then the result is
> * {@link Double#MAX_EXPONENT} + 1.
> * <li>If the argument is zero or subnormal, then the result is
> * {@link Double#MIN_EXPONENT} 1.
> * </ul>
> * @param d a {@code double} value
> * @since 1.6
> */
> public static int getExponent(double d) {
> return sun.misc.FpUtils.getExponent(d);
> }
>
> /**
> * Returns the floatingpoint number adjacent to the first
> * argument in the direction of the second argument. If both
> * arguments compare as equal the second argument is returned.
> *
> * <p>
> * Special cases:
> * <ul>
> * <li> If either argument is a NaN, then NaN is returned.
> *
> * <li> If both arguments are signed zeros, {@code direction}
> * is returned unchanged (as implied by the requirement of
> * returning the second argument if the arguments compare as
> * equal).
> *
> * <li> If {@code start} is
> * ±{@link Double#MIN_VALUE} and {@code direction}
> * has a value such that the result should have a smaller
> * magnitude, then a zero with the same sign as {@code start}
> * is returned.
> *
> * <li> If {@code start} is infinite and
> * {@code direction} has a value such that the result should
> * have a smaller magnitude, {@link Double#MAX_VALUE} with the
> * same sign as {@code start} is returned.
> *
> * <li> If {@code start} is equal to ±
> * {@link Double#MAX_VALUE} and {@code direction} has a
> * value such that the result should have a larger magnitude, an
> * infinity with same sign as {@code start} is returned.
> * </ul>
> *
> * @param start starting floatingpoint value
> * @param direction value indicating which of
> * {@code start}'s neighbors or {@code start} should
> * be returned
> * @return The floatingpoint number adjacent to {@code start} in the
> * direction of {@code direction}.
> * @since 1.6
> */
> public static double nextAfter(double start, double direction) {
> return sun.misc.FpUtils.nextAfter(start, direction);
> }
>
> /**
> * Returns the floatingpoint number adjacent to the first
> * argument in the direction of the second argument. If both
> * arguments compare as equal a value equivalent to the second argument
> * is returned.
> *
> * <p>
> * Special cases:
> * <ul>
> * <li> If either argument is a NaN, then NaN is returned.
> *
> * <li> If both arguments are signed zeros, a value equivalent
> * to {@code direction} is returned.
> *
> * <li> If {@code start} is
> * ±{@link Float#MIN_VALUE} and {@code direction}
> * has a value such that the result should have a smaller
> * magnitude, then a zero with the same sign as {@code start}
> * is returned.
> *
> * <li> If {@code start} is infinite and
> * {@code direction} has a value such that the result should
> * have a smaller magnitude, {@link Float#MAX_VALUE} with the
> * same sign as {@code start} is returned.
> *
> * <li> If {@code start} is equal to ±
> * {@link Float#MAX_VALUE} and {@code direction} has a
> * value such that the result should have a larger magnitude, an
> * infinity with same sign as {@code start} is returned.
> * </ul>
> *
> * @param start starting floatingpoint value
> * @param direction value indicating which of
> * {@code start}'s neighbors or {@code start} should
> * be returned
> * @return The floatingpoint number adjacent to {@code start} in the
> * direction of {@code direction}.
> * @since 1.6
> */
> public static float nextAfter(float start, double direction) {
> return sun.misc.FpUtils.nextAfter(start, direction);
> }
>
> /**
> * Returns the floatingpoint value adjacent to {@code d} in
> * the direction of positive infinity. This method is
> * semantically equivalent to {@code nextAfter(d,
> * Double.POSITIVE_INFINITY)}; however, a {@code nextUp}
> * implementation may run faster than its equivalent
> * {@code nextAfter} call.
> *
> * <p>Special Cases:
> * <ul>
> * <li> If the argument is NaN, the result is NaN.
> *
> * <li> If the argument is positive infinity, the result is
> * positive infinity.
> *
> * <li> If the argument is zero, the result is
> * {@link Double#MIN_VALUE}
> *
> * </ul>
> *
> * @param d starting floatingpoint value
> * @return The adjacent floatingpoint value closer to positive
> * infinity.
> * @since 1.6
> */
> public static double nextUp(double d) {
> return sun.misc.FpUtils.nextUp(d);
> }
>
> /**
> * Returns the floatingpoint value adjacent to {@code f} in
> * the direction of positive infinity. This method is
> * semantically equivalent to {@code nextAfter(f,
> * Float.POSITIVE_INFINITY)}; however, a {@code nextUp}
> * implementation may run faster than its equivalent
> * {@code nextAfter} call.
> *
> * <p>Special Cases:
> * <ul>
> * <li> If the argument is NaN, the result is NaN.
> *
> * <li> If the argument is positive infinity, the result is
> * positive infinity.
> *
> * <li> If the argument is zero, the result is
> * {@link Float#MIN_VALUE}
> *
> * </ul>
> *
> * @param f starting floatingpoint value
> * @return The adjacent floatingpoint value closer to positive
> * infinity.
> * @since 1.6
> */
> public static float nextUp(float f) {
> return sun.misc.FpUtils.nextUp(f);
> }
>
>
> /**
> * Return {@code d} ×
> * 2<sup>{@code scaleFactor}</sup> rounded as if performed
> * by a single correctly rounded floatingpoint multiply to a
> * member of the double value set. See the Java
> * Language Specification for a discussion of floatingpoint
> * value sets. If the exponent of the result is between {@link
> * Double#MIN_EXPONENT} and {@link Double#MAX_EXPONENT}, the
> * answer is calculated exactly. If the exponent of the result
> * would be larger than {@code Double.MAX_EXPONENT}, an
> * infinity is returned. Note that if the result is subnormal,
> * precision may be lost; that is, when {@code scalb(x, n)}
> * is subnormal, {@code scalb(scalb(x, n), n)} may not equal
> * <i>x</i>. When the result is nonNaN, the result has the same
> * sign as {@code d}.
> *
> *<p>
> * Special cases:
> * <ul>
> * <li> If the first argument is NaN, NaN is returned.
> * <li> If the first argument is infinite, then an infinity of the
> * same sign is returned.
> * <li> If the first argument is zero, then a zero of the same
> * sign is returned.
> * </ul>
> *
> * @param d number to be scaled by a power of two.
> * @param scaleFactor power of 2 used to scale {@code d}
> * @return {@code d} × 2<sup>{@code scaleFactor}</sup>
> * @since 1.6
> */
> public static double scalb(double d, int scaleFactor) {
> return sun.misc.FpUtils.scalb(d, scaleFactor);
> }
>
> /**
> * Return {@code f} ×
> * 2<sup>{@code scaleFactor}</sup> rounded as if performed
> * by a single correctly rounded floatingpoint multiply to a
> * member of the float value set. See the Java
> * Language Specification for a discussion of floatingpoint
> * value sets. If the exponent of the result is between {@link
> * Float#MIN_EXPONENT} and {@link Float#MAX_EXPONENT}, the
> * answer is calculated exactly. If the exponent of the result
> * would be larger than {@code Float.MAX_EXPONENT}, an
> * infinity is returned. Note that if the result is subnormal,
> * precision may be lost; that is, when {@code scalb(x, n)}
> * is subnormal, {@code scalb(scalb(x, n), n)} may not equal
> * <i>x</i>. When the result is nonNaN, the result has the same
> * sign as {@code f}.
> *
> *<p>
> * Special cases:
> * <ul>
> * <li> If the first argument is NaN, NaN is returned.
> * <li> If the first argument is infinite, then an infinity of the
> * same sign is returned.
> * <li> If the first argument is zero, then a zero of the same
> * sign is returned.
> * </ul>
> *
> * @param f number to be scaled by a power of two.
> * @param scaleFactor power of 2 used to scale {@code f}
> * @return {@code f} × 2<sup>{@code scaleFactor}</sup>
> * @since 1.6
> */
> public static float scalb(float f, int scaleFactor) {
> return sun.misc.FpUtils.scalb(f, scaleFactor);
> }


EVALUATION
Initial work needed to address 4406429.
###@###.### 20030303


