United StatesChange Country, Oracle Worldwide Web Sites Communities I am a... I want to...
JDK-4826652 : Add copySign, nextAfter, nextUp, scalb, ilogb, etc. to Math and StrictMath

Details
Type:
Enhancement
Submit Date:
2003-03-04
Status:
Resolved
Updated Date:
2014-05-23
Project Name:
JDK
Resolved Date:
2005-08-20
Component:
core-libs
OS:
generic
Sub-Component:
java.lang
CPU:
generic
Priority:
P4
Resolution:
Fixed
Affected Versions:
1.3.0,5.0
Fixed Versions:

Related Reports
Duplicate:
Relates:
Relates:

Sub Tasks

Description
First portion of work for 4406429 "RFE: Add IEEE 754 Recommended Functions to Math, StrictMath."

                                    

Comments
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.
                                     
2005-10-25
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 floating-point literal {@code 0x1.0p-126f} and also
>      * equal to {@code Float.intBitsToFloat(0x00800000)}.
>      *
>      * @since 1.6
>      */
>     public static final float MIN_NORMAL = 0x1.0p-126f; // 1.17549435E-38f
>  
>     /**
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 floating-point literal {@code 0x1.0p-1022} and also
>      * equal to {@code Double.longBitsToDouble(0x0010000000000000L)}.
>      *
>      * @since 1.6
>      */
>     public static final double MIN_NORMAL = 0x1.0p-1022; // 2.2250738585072014E-308
>  
>     /**
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 floating-point argument with the sign of the
>      * second floating-point 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 floating-point argument with the sign of the
>      * second floating-point 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 floating-point 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
>      * &plusmn;{@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 &plusmn;
>      * {@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 floating-point value
>      * @param direction value indicating which of
>      * {@code start}'s neighbors or {@code start} should
>      * be returned
>      * @return The floating-point 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 floating-point 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
>      * &plusmn;{@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 &plusmn;
>      * {@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 floating-point value
>      * @param direction value indicating which of
>      * {@code start}'s neighbors or {@code start} should
>      * be returned
>      * @return The floating-point 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 floating-point 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 floating-point value
>      * @return The adjacent floating-point value closer to positive
>      * infinity.
>      * @since 1.6
>      */
>     public static double nextUp(double d) {
>       return sun.misc.FpUtils.nextUp(d);
>     }
>  
>     /**
>      * Returns the floating-point 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 floating-point value
>      * @return The adjacent floating-point value closer to positive
>      * infinity.
>      * @since 1.6
>      */
>     public static float nextUp(float f) {
>       return sun.misc.FpUtils.nextUp(f);
>     }
>  
>  
>     /**
>      * Return {@code d} &times;
>      * 2<sup>{@code scaleFactor}</sup> rounded as if performed
>      * by a single correctly rounded floating-point multiply to a
>      * member of the double value set.  See the Java
>      * Language Specification for a discussion of floating-point
>      * 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 non-NaN, 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} &times; 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} &times;
>      * 2<sup>{@code scaleFactor}</sup> rounded as if performed
>      * by a single correctly rounded floating-point multiply to a
>      * member of the float value set.  See the Java
>      * Language Specification for a discussion of floating-point
>      * 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 non-NaN, 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} &times; 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>
                                     
2005-08-12
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 floating-point argument with the sign of the
>      * second floating-point 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 floating-point argument with the sign of the
>      * second floating-point 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 floating-point 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
>      * &plusmn;{@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 &plusmn;
>      * {@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 floating-point value
>      * @param direction value indicating which of
>      * {@code start}'s neighbors or {@code start} should
>      * be returned
>      * @return The floating-point 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 floating-point 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
>      * &plusmn;{@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 &plusmn;
>      * {@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 floating-point value
>      * @param direction value indicating which of
>      * {@code start}'s neighbors or {@code start} should
>      * be returned
>      * @return The floating-point 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 floating-point 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 floating-point value
>      * @return The adjacent floating-point value closer to positive
>      * infinity.
>      * @since 1.6
>      */
>     public static double nextUp(double d) {
>       return sun.misc.FpUtils.nextUp(d);
>     }
>  
>     /**
>      * Returns the floating-point 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 floating-point value
>      * @return The adjacent floating-point value closer to positive
>      * infinity.
>      * @since 1.6
>      */
>     public static float nextUp(float f) {
>       return sun.misc.FpUtils.nextUp(f);
>     }
>  
>  
>     /**
>      * Return {@code d} &times;
>      * 2<sup>{@code scaleFactor}</sup> rounded as if performed
>      * by a single correctly rounded floating-point multiply to a
>      * member of the double value set.  See the Java
>      * Language Specification for a discussion of floating-point
>      * 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 non-NaN, 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} &times; 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} &times;
>      * 2<sup>{@code scaleFactor}</sup> rounded as if performed
>      * by a single correctly rounded floating-point multiply to a
>      * member of the float value set.  See the Java
>      * Language Specification for a discussion of floating-point
>      * 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 non-NaN, 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} &times; 2<sup>{@code scaleFactor}</sup>
>      * @since 1.6
>      */
>     public static float scalb(float f, int scaleFactor) {
>       return sun.misc.FpUtils.scalb(f, scaleFactor);
>     }
                                     
2005-08-12
EVALUATION

Initial work needed to address 4406429.

###@###.### 2003-03-03
                                     
2003-03-03



Hardware and Software, Engineered to Work Together