Back to index...

	/*
	* Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package sun.misc;

	import sun.misc.FloatConsts;
	import sun.misc.DoubleConsts;

	/**
	* The class {@code FpUtils} contains static utility methods for
	* manipulating and inspecting {@code float} and
	* {@code double} floating-point numbers. These methods include
	* functionality recommended or required by the IEEE 754
	* floating-point standard.
	*
	* @author Joseph D. Darcy
	*/

	public class FpUtils {
	/*
	* The methods in this class are reasonably implemented using
	* direct or indirect bit-level manipulation of floating-point
	* values. However, having access to the IEEE 754 recommended
	* functions would obviate the need for most programmers to engage
	* in floating-point bit-twiddling.
	*
	* An IEEE 754 number has three fields, from most significant bit
	* to to least significant, sign, exponent, and significand.
	*
	* msb lsb
	* [sign\|exponent\| fractional_significand]
	*
	* Using some encoding cleverness, explained below, the high order
	* bit of the logical significand does not need to be explicitly
	* stored, thus "fractional_significand" instead of simply
	* "significand" in the figure above.
	*
	* For finite normal numbers, the numerical value encoded is
	*
	* (-1)^sign * 2^(exponent)*(1.fractional_significand)
	*
	* Most finite floating-point numbers are normalized; the exponent
	* value is reduced until the leading significand bit is 1.
	* Therefore, the leading 1 is redundant and is not explicitly
	* stored. If a numerical value is so small it cannot be
	* normalized, it has a subnormal representation. Subnormal
	* numbers don't have a leading 1 in their significand; subnormals
	* are encoding using a special exponent value. In other words,
	* the high-order bit of the logical significand can be elided in
	* from the representation in either case since the bit's value is
	* implicit from the exponent value.
	*
	* The exponent field uses a biased representation; if the bits of
	* the exponent are interpreted as a unsigned integer E, the
	* exponent represented is E - E_bias where E_bias depends on the
	* floating-point format. E can range between E_min and E_max,
	* constants which depend on the floating-point format. E_min and
	* E_max are -126 and +127 for float, -1022 and +1023 for double.
	*
	* The 32-bit float format has 1 sign bit, 8 exponent bits, and 23
	* bits for the significand (which is logically 24 bits wide
	* because of the implicit bit). The 64-bit double format has 1
	* sign bit, 11 exponent bits, and 52 bits for the significand
	* (logically 53 bits).
	*
	* Subnormal numbers and zero have the special exponent value
	* E_min -1; the numerical value represented by a subnormal is:
	*
	* (-1)^sign * 2^(E_min)*(0.fractional_significand)
	*
	* Zero is represented by all zero bits in the exponent and all
	* zero bits in the significand; zero can have either sign.
	*
	* Infinity and NaN are encoded using the exponent value E_max +
	* 1. Signed infinities have all significand bits zero; NaNs have
	* at least one non-zero significand bit.
	*
	* The details of IEEE 754 floating-point encoding will be used in
	* the methods below without further comment. For further
	* exposition on IEEE 754 numbers, see "IEEE Standard for Binary
	* Floating-Point Arithmetic" ANSI/IEEE Std 754-1985 or William
	* Kahan's "Lecture Notes on the Status of IEEE Standard 754 for
	* Binary Floating-Point Arithmetic",
	* http://www.cs.berkeley.edu/~wkahan/ieee754status/ieee754.ps.
	*
	* Many of this class's methods are members of the set of IEEE 754
	* recommended functions or similar functions recommended or
	* required by IEEE 754R. Discussion of various implementation
	* techniques for these functions have occurred in:
	*
	* W.J. Cody and Jerome T. Coonen, "Algorithm 772 Functions to
	* Support the IEEE Standard for Binary Floating-Point
	* Arithmetic," ACM Transactions on Mathematical Software,
	* vol. 19, no. 4, December 1993, pp. 443-451.
	*
	* Joseph D. Darcy, "Writing robust IEEE recommended functions in
	* ``100% Pure Java''(TM)," University of California, Berkeley
	* technical report UCB//CSD-98-1009.
	*/

	/**
	* Don't let anyone instantiate this class.
	*/
	private FpUtils() {}

	// Helper Methods

	// The following helper methods are used in the implementation of
	// the public recommended functions; they generally omit certain
	// tests for exception cases.

	/**
	* Returns unbiased exponent of a {@code double}.
	* @deprecated Use Math.getExponent.
	*/
	@Deprecated
	public static int getExponent(double d){
	return Math.getExponent(d);
	}

	/**
	* Returns unbiased exponent of a {@code float}.
	* @deprecated Use Math.getExponent.
	*/
	@Deprecated
	public static int getExponent(float f){
	return Math.getExponent(f);
	}


	/**
	* Returns the first floating-point argument with the sign of the
	* second floating-point argument. Note that unlike the {@link
	* FpUtils#copySign(double, double) copySign} method, this method
	* does not require NaN {@code sign} 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}
	* and the sign of {@code sign}.
	* @author Joseph D. Darcy
	* @deprecated Use Math.copySign.
	*/
	@Deprecated
	public static double rawCopySign(double magnitude, double sign) {
	return Math.copySign(magnitude, sign);
	}

	/**
	* Returns the first floating-point argument with the sign of the
	* second floating-point argument. Note that unlike the {@link
	* FpUtils#copySign(float, float) copySign} method, this method
	* does not require NaN {@code sign} 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}
	* and the sign of {@code sign}.
	* @author Joseph D. Darcy
	* @deprecated Use Math.copySign.
	*/
	@Deprecated
	public static float rawCopySign(float magnitude, float sign) {
	return Math.copySign(magnitude, sign);
	}

	/* ***************************************************************** */

	/**
	* Returns {@code true} if the argument is a finite
	* floating-point value; returns {@code false} otherwise (for
	* NaN and infinity arguments).
	*
	* @param d the {@code double} value to be tested
	* @return {@code true} if the argument is a finite
	* floating-point value, {@code false} otherwise.
	* @deprecated Use Double.isFinite.
	*/
	@Deprecated
	public static boolean isFinite(double d) {
	return Double.isFinite(d);
	}

	/**
	* Returns {@code true} if the argument is a finite
	* floating-point value; returns {@code false} otherwise (for
	* NaN and infinity arguments).
	*
	* @param f the {@code float} value to be tested
	* @return {@code true} if the argument is a finite
	* floating-point value, {@code false} otherwise.
	* @deprecated Use Float.isFinite.
	*/
	@Deprecated
	public static boolean isFinite(float f) {
	return Float.isFinite(f);
	}

	/**
	* Returns {@code true} if the specified number is infinitely
	* large in magnitude, {@code false} otherwise.
	*
	* <p>Note that this method is equivalent to the {@link
	* Double#isInfinite(double) Double.isInfinite} method; the
	* functionality is included in this class for convenience.
	*
	* @param d the value to be tested.
	* @return {@code true} if the value of the argument is positive
	* infinity or negative infinity; {@code false} otherwise.
	*/
	public static boolean isInfinite(double d) {
	return Double.isInfinite(d);
	}

	/**
	* Returns {@code true} if the specified number is infinitely
	* large in magnitude, {@code false} otherwise.
	*
	* <p>Note that this method is equivalent to the {@link
	* Float#isInfinite(float) Float.isInfinite} method; the
	* functionality is included in this class for convenience.
	*
	* @param f the value to be tested.
	* @return {@code true} if the argument is positive infinity or
	* negative infinity; {@code false} otherwise.
	*/
	public static boolean isInfinite(float f) {
	return Float.isInfinite(f);
	}

	/**
	* Returns {@code true} if the specified number is a
	* Not-a-Number (NaN) value, {@code false} otherwise.
	*
	* <p>Note that this method is equivalent to the {@link
	* Double#isNaN(double) Double.isNaN} method; the functionality is
	* included in this class for convenience.
	*
	* @param d the value to be tested.
	* @return {@code true} if the value of the argument is NaN;
	* {@code false} otherwise.
	*/
	public static boolean isNaN(double d) {
	return Double.isNaN(d);
	}

	/**
	* Returns {@code true} if the specified number is a
	* Not-a-Number (NaN) value, {@code false} otherwise.
	*
	* <p>Note that this method is equivalent to the {@link
	* Float#isNaN(float) Float.isNaN} method; the functionality is
	* included in this class for convenience.
	*
	* @param f the value to be tested.
	* @return {@code true} if the argument is NaN;
	* {@code false} otherwise.
	*/
	public static boolean isNaN(float f) {
	return Float.isNaN(f);
	}

	/**
	* Returns {@code true} if the unordered relation holds
	* between the two arguments. When two floating-point values are
	* unordered, one value is neither less than, equal to, nor
	* greater than the other. For the unordered relation to be true,
	* at least one argument must be a {@code NaN}.
	*
	* @param arg1 the first argument
	* @param arg2 the second argument
	* @return {@code true} if at least one argument is a NaN,
	* {@code false} otherwise.
	*/
	public static boolean isUnordered(double arg1, double arg2) {
	return isNaN(arg1) \|\| isNaN(arg2);
	}

	/**
	* Returns {@code true} if the unordered relation holds
	* between the two arguments. When two floating-point values are
	* unordered, one value is neither less than, equal to, nor
	* greater than the other. For the unordered relation to be true,
	* at least one argument must be a {@code NaN}.
	*
	* @param arg1 the first argument
	* @param arg2 the second argument
	* @return {@code true} if at least one argument is a NaN,
	* {@code false} otherwise.
	*/
	public static boolean isUnordered(float arg1, float arg2) {
	return isNaN(arg1) \|\| isNaN(arg2);
	}

	/**
	* Returns unbiased exponent of a {@code double}; for
	* subnormal values, the number is treated as if it were
	* normalized. That is for all finite, non-zero, positive numbers
	* <i>x</i>, <code>scalb(<i>x</i>, -ilogb(<i>x</i>))</code> is
	* always in the range [1, 2).
	* <p>
	* Special cases:
	* <ul>
	* <li> If the argument is NaN, then the result is 2<sup>30</sup>.
	* <li> If the argument is infinite, then the result is 2<sup>28</sup>.
	* <li> If the argument is zero, then the result is -(2<sup>28</sup>).
	* </ul>
	*
	* @param d floating-point number whose exponent is to be extracted
	* @return unbiased exponent of the argument.
	* @author Joseph D. Darcy
	*/
	public static int ilogb(double d) {
	int exponent = getExponent(d);

	switch (exponent) {
	case DoubleConsts.MAX_EXPONENT+1: // NaN or infinity
	if( isNaN(d) )
	return (1<<30); // 2^30
	else // infinite value
	return (1<<28); // 2^28

	case DoubleConsts.MIN_EXPONENT-1: // zero or subnormal
	if(d == 0.0) {
	return -(1<<28); // -(2^28)
	}
	else {
	long transducer = Double.doubleToRawLongBits(d);

	/*
	* To avoid causing slow arithmetic on subnormals,
	* the scaling to determine when d's significand
	* is normalized is done in integer arithmetic.
	* (there must be at least one "1" bit in the
	* significand since zero has been screened out.
	*/

	// isolate significand bits
	transducer &= DoubleConsts.SIGNIF_BIT_MASK;
	assert(transducer != 0L);

	// This loop is simple and functional. We might be
	// able to do something more clever that was faster;
	// e.g. number of leading zero detection on
	// (transducer << (# exponent and sign bits).
	while (transducer <
	(1L << (DoubleConsts.SIGNIFICAND_WIDTH - 1))) {
	transducer *= 2;
	exponent--;
	}
	exponent++;
	assert( exponent >=
	DoubleConsts.MIN_EXPONENT - (DoubleConsts.SIGNIFICAND_WIDTH-1) &&
	exponent < DoubleConsts.MIN_EXPONENT);
	return exponent;
	}

	default:
	assert( exponent >= DoubleConsts.MIN_EXPONENT &&
	exponent <= DoubleConsts.MAX_EXPONENT);
	return exponent;
	}
	}

	/**
	* Returns unbiased exponent of a {@code float}; for
	* subnormal values, the number is treated as if it were
	* normalized. That is for all finite, non-zero, positive numbers
	* <i>x</i>, <code>scalb(<i>x</i>, -ilogb(<i>x</i>))</code> is
	* always in the range [1, 2).
	* <p>
	* Special cases:
	* <ul>
	* <li> If the argument is NaN, then the result is 2<sup>30</sup>.
	* <li> If the argument is infinite, then the result is 2<sup>28</sup>.
	* <li> If the argument is zero, then the result is -(2<sup>28</sup>).
	* </ul>
	*
	* @param f floating-point number whose exponent is to be extracted
	* @return unbiased exponent of the argument.
	* @author Joseph D. Darcy
	*/
	public static int ilogb(float f) {
	int exponent = getExponent(f);

	switch (exponent) {
	case FloatConsts.MAX_EXPONENT+1: // NaN or infinity
	if( isNaN(f) )
	return (1<<30); // 2^30
	else // infinite value
	return (1<<28); // 2^28

	case FloatConsts.MIN_EXPONENT-1: // zero or subnormal
	if(f == 0.0f) {
	return -(1<<28); // -(2^28)
	}
	else {
	int transducer = Float.floatToRawIntBits(f);

	/*
	* To avoid causing slow arithmetic on subnormals,
	* the scaling to determine when f's significand
	* is normalized is done in integer arithmetic.
	* (there must be at least one "1" bit in the
	* significand since zero has been screened out.
	*/

	// isolate significand bits
	transducer &= FloatConsts.SIGNIF_BIT_MASK;
	assert(transducer != 0);

	// This loop is simple and functional. We might be
	// able to do something more clever that was faster;
	// e.g. number of leading zero detection on
	// (transducer << (# exponent and sign bits).
	while (transducer <
	(1 << (FloatConsts.SIGNIFICAND_WIDTH - 1))) {
	transducer *= 2;
	exponent--;
	}
	exponent++;
	assert( exponent >=
	FloatConsts.MIN_EXPONENT - (FloatConsts.SIGNIFICAND_WIDTH-1) &&
	exponent < FloatConsts.MIN_EXPONENT);
	return exponent;
	}

	default:
	assert( exponent >= FloatConsts.MIN_EXPONENT &&
	exponent <= FloatConsts.MAX_EXPONENT);
	return exponent;
	}
	}


	/*
	* The scalb operation should be reasonably fast; however, there
	* are tradeoffs in writing a method to minimize the worst case
	* performance and writing a method to minimize the time for
	* expected common inputs. Some processors operate very slowly on
	* subnormal operands, taking hundreds or thousands of cycles for
	* one floating-point add or multiply as opposed to, say, four
	* cycles for normal operands. For processors with very slow
	* subnormal execution, scalb would be fastest if written entirely
	* with integer operations; in other words, scalb would need to
	* include the logic of performing correct rounding of subnormal
	* values. This could be reasonably done in at most a few hundred
	* cycles. However, this approach may penalize normal operations
	* since at least the exponent of the floating-point argument must
	* be examined.
	*
	* The approach taken in this implementation is a compromise.
	* Floating-point multiplication is used to do most of the work;
	* but knowingly multiplying by a subnormal scaling factor is
	* avoided. However, the floating-point argument is not examined
	* to see whether or not it is subnormal since subnormal inputs
	* are assumed to be rare. At most three multiplies are needed to
	* scale from the largest to smallest exponent ranges (scaling
	* down, at most two multiplies are needed if subnormal scaling
	* factors are allowed). However, in this implementation an
	* expensive integer remainder operation is avoided at the cost of
	* requiring five floating-point multiplies in the worst case,
	* which should still be a performance win.
	*
	* If scaling of entire arrays is a concern, it would probably be
	* more efficient to provide a double[] scalb(double[], int)
	* version of scalb to avoid having to recompute the needed
	* scaling factors for each floating-point value.
	*/

	/**
	* Return {@code d} ×
	* 2<sup>{@code scale_factor}</sup> rounded as if performed
	* by a single correctly rounded floating-point multiply to a
	* member of the double value set. See section 4.2.3 of
	* <cite>The Java™ Language Specification</cite>
	* for a discussion of floating-point
	* value sets. If the exponent of the result is between the
	* {@code double}'s minimum exponent and maximum exponent,
	* the answer is calculated exactly. If the exponent of the
	* result would be larger than {@code doubles}'s maximum
	* 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 scale_factor power of 2 used to scale {@code d}
	* @return {@code d * }2<sup>{@code scale_factor}</sup>
	* @author Joseph D. Darcy
	* @deprecated Use Math.scalb.
	*/
	@Deprecated
	public static double scalb(double d, int scale_factor) {
	return Math.scalb(d, scale_factor);
	}

	/**
	* Return {@code f} ×
	* 2<sup>{@code scale_factor}</sup> rounded as if performed
	* by a single correctly rounded floating-point multiply to a
	* member of the float value set. See section 4.2.3 of
	* <cite>The Java™ Language Specification</cite>
	* for a discussion of floating-point
	* value sets. If the exponent of the result is between the
	* {@code float}'s minimum exponent and maximum exponent, the
	* answer is calculated exactly. If the exponent of the result
	* would be larger than {@code float}'s maximum 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 scale_factor power of 2 used to scale {@code f}
	* @return {@code f * }2<sup>{@code scale_factor}</sup>
	* @author Joseph D. Darcy
	* @deprecated Use Math.scalb.
	*/
	@Deprecated
	public static float scalb(float f, int scale_factor) {
	return Math.scalb(f, scale_factor);
	}

	/**
	* 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
	* ±{@code 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, {@code Double.MAX_VALUE} with the
	* same sign as {@code start} is returned.
	*
	* <li> If {@code start} is equal to ±
	* {@code 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}.
	* @author Joseph D. Darcy
	* @deprecated Use Math.nextAfter
	*/
	@Deprecated
	public static double nextAfter(double start, double direction) {
	return Math.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, 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 {@code float}
	* zero with the same sign as {@code direction} is returned
	* (as implied by the requirement of returning the second argument
	* if the arguments compare as equal).
	*
	* <li> If {@code start} is
	* ±{@code 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, {@code Float.MAX_VALUE} with the
	* same sign as {@code start} is returned.
	*
	* <li> If {@code start} is equal to ±
	* {@code 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}.
	* @author Joseph D. Darcy
	* @deprecated Use Math.nextAfter.
	*/
	@Deprecated
	public static float nextAfter(float start, double direction) {
	return Math.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
	* {@code Double.MIN_VALUE}
	*
	* </ul>
	*
	* @param d starting floating-point value
	* @return The adjacent floating-point value closer to positive
	* infinity.
	* @author Joseph D. Darcy
	* @deprecated use Math.nextUp.
	*/
	@Deprecated
	public static double nextUp(double d) {
	return Math.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,
	* 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
	* {@code Float.MIN_VALUE}
	*
	* </ul>
	*
	* @param f starting floating-point value
	* @return The adjacent floating-point value closer to positive
	* infinity.
	* @author Joseph D. Darcy
	* @deprecated Use Math.nextUp.
	*/
	@Deprecated
	public static float nextUp(float f) {
	return Math.nextUp(f);
	}

	/**
	* Returns the floating-point value adjacent to {@code d} in
	* the direction of negative infinity. This method is
	* semantically equivalent to {@code nextAfter(d,
	* Double.NEGATIVE_INFINITY)}; however, a
	* {@code nextDown} 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 negative infinity, the result is
	* negative infinity.
	*
	* <li> If the argument is zero, the result is
	* {@code -Double.MIN_VALUE}
	*
	* </ul>
	*
	* @param d starting floating-point value
	* @return The adjacent floating-point value closer to negative
	* infinity.
	* @author Joseph D. Darcy
	* @deprecated Use Math.nextDown.
	*/
	@Deprecated
	public static double nextDown(double d) {
	return Math.nextDown(d);
	}

	/**
	* Returns the floating-point value adjacent to {@code f} in
	* the direction of negative infinity. This method is
	* semantically equivalent to {@code nextAfter(f,
	* Float.NEGATIVE_INFINITY)}; however, a
	* {@code nextDown} 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 negative infinity, the result is
	* negative infinity.
	*
	* <li> If the argument is zero, the result is
	* {@code -Float.MIN_VALUE}
	*
	* </ul>
	*
	* @param f starting floating-point value
	* @return The adjacent floating-point value closer to negative
	* infinity.
	* @author Joseph D. Darcy
	* @deprecated Use Math.nextDown.
	*/
	@Deprecated
	public static double nextDown(float f) {
	return Math.nextDown(f);
	}

	/**
	* 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}.
	* @author Joseph D. Darcy
	* @since 1.5
	* @deprecated Use StrictMath.copySign.
	*/
	@Deprecated
	public static double copySign(double magnitude, double sign) {
	return StrictMath.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}.
	* @author Joseph D. Darcy
	* @deprecated Use StrictMath.copySign.
	*/
	@Deprecated
	public static float copySign(float magnitude, float sign) {
	return StrictMath.copySign(magnitude, sign);
	}

	/**
	* Returns the size of an ulp of the argument. An ulp of a
	* {@code double} value is the positive distance between this
	* floating-point value and the {@code double} value next
	* larger in magnitude. Note that for non-NaN <i>x</i>,
	* <code>ulp(-<i>x</i>) == ulp(<i>x</i>)</code>.
	*
	* <p>Special Cases:
	* <ul>
	* <li> If the argument is NaN, then the result is NaN.
	* <li> If the argument is positive or negative infinity, then the
	* result is positive infinity.
	* <li> If the argument is positive or negative zero, then the result is
	* {@code Double.MIN_VALUE}.
	* <li> If the argument is ±{@code Double.MAX_VALUE}, then
	* the result is equal to 2<sup>971</sup>.
	* </ul>
	*
	* @param d the floating-point value whose ulp is to be returned
	* @return the size of an ulp of the argument
	* @author Joseph D. Darcy
	* @since 1.5
	* @deprecated Use Math.ulp.
	*/
	@Deprecated
	public static double ulp(double d) {
	return Math.ulp(d);
	}

	/**
	* Returns the size of an ulp of the argument. An ulp of a
	* {@code float} value is the positive distance between this
	* floating-point value and the {@code float} value next
	* larger in magnitude. Note that for non-NaN <i>x</i>,
	* <code>ulp(-<i>x</i>) == ulp(<i>x</i>)</code>.
	*
	* <p>Special Cases:
	* <ul>
	* <li> If the argument is NaN, then the result is NaN.
	* <li> If the argument is positive or negative infinity, then the
	* result is positive infinity.
	* <li> If the argument is positive or negative zero, then the result is
	* {@code Float.MIN_VALUE}.
	* <li> If the argument is ±{@code Float.MAX_VALUE}, then
	* the result is equal to 2<sup>104</sup>.
	* </ul>
	*
	* @param f the floating-point value whose ulp is to be returned
	* @return the size of an ulp of the argument
	* @author Joseph D. Darcy
	* @since 1.5
	* @deprecated Use Math.ulp.
	*/
	@Deprecated
	public static float ulp(float f) {
	return Math.ulp(f);
	}

	/**
	* Returns the signum function of the argument; zero if the argument
	* is zero, 1.0 if the argument is greater than zero, -1.0 if the
	* argument is less than zero.
	*
	* <p>Special Cases:
	* <ul>
	* <li> If the argument is NaN, then the result is NaN.
	* <li> If the argument is positive zero or negative zero, then the
	* result is the same as the argument.
	* </ul>
	*
	* @param d the floating-point value whose signum is to be returned
	* @return the signum function of the argument
	* @author Joseph D. Darcy
	* @since 1.5
	* @deprecated Use Math.signum.
	*/
	@Deprecated
	public static double signum(double d) {
	return Math.signum(d);
	}

	/**
	* Returns the signum function of the argument; zero if the argument
	* is zero, 1.0f if the argument is greater than zero, -1.0f if the
	* argument is less than zero.
	*
	* <p>Special Cases:
	* <ul>
	* <li> If the argument is NaN, then the result is NaN.
	* <li> If the argument is positive zero or negative zero, then the
	* result is the same as the argument.
	* </ul>
	*
	* @param f the floating-point value whose signum is to be returned
	* @return the signum function of the argument
	* @author Joseph D. Darcy
	* @since 1.5
	* @deprecated Use Math.signum.
	*/
	@Deprecated
	public static float signum(float f) {
	return Math.signum(f);
	}
	}

Back to index...