java.lang.Object sun.misc.FpUtilsThe class {@code FpUtils} contains static utility methods for manipulating and inspecting {@code float} and {@code double} floatingpoint numbers. These methods include functionality recommended or required by the IEEE 754 floatingpoint standard.
Joseph
 D. DarcyField Summary  

static double  twoToTheDoubleScaleUp  
static double  twoToTheDoubleScaleDown 
Method from sun.misc.FpUtils Summary: 

copySign, copySign, getExponent, getExponent, ilogb, ilogb, isFinite, isFinite, isInfinite, isInfinite, isNaN, isNaN, isUnordered, isUnordered, nextAfter, nextAfter, nextDown, nextDown, nextUp, nextUp, powerOfTwoD, powerOfTwoF, rawCopySign, rawCopySign, scalb, scalb, signum, signum, ulp, ulp 
Methods from java.lang.Object: 

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait 
Method from sun.misc.FpUtils Detail: 

public static double copySign(double magnitude, double sign){ return rawCopySign(magnitude, (isNaN(sign)?1.0d:sign)); }

public static float copySign(float magnitude, float sign){ return rawCopySign(magnitude, (isNaN(sign)?1.0f:sign)); }

public static int getExponent(double d){ /* * Bitwise convert d to long, mask out exponent bits, shift * to the right and then subtract out double's bias adjust to * get true exponent value. */ return (int)(((Double.doubleToRawLongBits(d) & DoubleConsts.EXP_BIT_MASK) > > (DoubleConsts.SIGNIFICAND_WIDTH  1))  DoubleConsts.EXP_BIAS); }

public static int getExponent(float f){ /* * Bitwise convert f to integer, mask out exponent bits, shift * to the right and then subtract out float's bias adjust to * get true exponent value */ return ((Float.floatToRawIntBits(f) & FloatConsts.EXP_BIT_MASK) > > (FloatConsts.SIGNIFICAND_WIDTH  1))  FloatConsts.EXP_BIAS; }

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_EXPONENT1: // 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_WIDTH1) && exponent < DoubleConsts.MIN_EXPONENT); return exponent; } default: assert( exponent >= DoubleConsts.MIN_EXPONENT && exponent < = DoubleConsts.MAX_EXPONENT); return exponent; } }
scalb(x, ilogb(x)) is
always in the range [1, 2).
Special cases: 
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_EXPONENT1: // 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_WIDTH1) && exponent < FloatConsts.MIN_EXPONENT); return exponent; } default: assert( exponent >= FloatConsts.MIN_EXPONENT && exponent < = FloatConsts.MAX_EXPONENT); return exponent; } }
scalb(x, ilogb(x)) is
always in the range [1, 2).
Special cases: 
public static boolean isFinite(double d){ return Math.abs(d) < = DoubleConsts.MAX_VALUE; }

public static boolean isFinite(float f){ return Math.abs(f) < = FloatConsts.MAX_VALUE; }

public static boolean isInfinite(double d){ return Double.isInfinite(d); }
Note that this method is equivalent to the Double.isInfinite method; the functionality is included in this class for convenience. 
public static boolean isInfinite(float f){ return Float.isInfinite(f); }
Note that this method is equivalent to the Float.isInfinite method; the functionality is included in this class for convenience. 
public static boolean isNaN(double d){ return Double.isNaN(d); }
Note that this method is equivalent to the Double.isNaN method; the functionality is included in this class for convenience. 
public static boolean isNaN(float f){ return Float.isNaN(f); }
Note that this method is equivalent to the Float.isNaN method; the functionality is included in this class for convenience. 
public static boolean isUnordered(double arg1, double arg2){ return isNaN(arg1)  isNaN(arg2); }

public static boolean isUnordered(float arg1, float arg2){ return isNaN(arg1)  isNaN(arg2); }

public static double nextAfter(double start, double direction){ /* * The cases: * * nextAfter(+infinity, 0) == MAX_VALUE * nextAfter(+infinity, +infinity) == +infinity * nextAfter(infinity, 0) == MAX_VALUE * nextAfter(infinity, infinity) == infinity * * are naturally handled without any additional testing */ // First check for NaN values if (isNaN(start)  isNaN(direction)) { // return a NaN derived from the input NaN(s) return start + direction; } else if (start == direction) { return direction; } else { // start > direction or start < direction // Add +0.0 to get rid of a 0.0 (+0.0 + 0.0 = > +0.0) // then bitwise convert start to integer. long transducer = Double.doubleToRawLongBits(start + 0.0d); /* * IEEE 754 floatingpoint numbers are lexicographically * ordered if treated as signed magnitude integers . * Since Java's integers are two's complement, * incrementing" the two's complement representation of a * logically negative floatingpoint value *decrements* * the signedmagnitude representation. Therefore, when * the integer representation of a floatingpoint values * is less than zero, the adjustment to the representation * is in the opposite direction than would be expected at * first . */ if (direction > start) { // Calculate next greater value transducer = transducer + (transducer >= 0L ? 1L:1L); } else { // Calculate next lesser value assert direction < start; if (transducer > 0L) transducer; else if (transducer < 0L ) ++transducer; /* * transducer==0, the result is MIN_VALUE * * The transition from zero (implicitly * positive) to the smallest negative * signed magnitude value must be done * explicitly. */ else transducer = DoubleConsts.SIGN_BIT_MASK  1L; } return Double.longBitsToDouble(transducer); } }
Special cases: 
public static float nextAfter(float start, double direction){ /* * The cases: * * nextAfter(+infinity, 0) == MAX_VALUE * nextAfter(+infinity, +infinity) == +infinity * nextAfter(infinity, 0) == MAX_VALUE * nextAfter(infinity, infinity) == infinity * * are naturally handled without any additional testing */ // First check for NaN values if (isNaN(start)  isNaN(direction)) { // return a NaN derived from the input NaN(s) return start + (float)direction; } else if (start == direction) { return (float)direction; } else { // start > direction or start < direction // Add +0.0 to get rid of a 0.0 (+0.0 + 0.0 = > +0.0) // then bitwise convert start to integer. int transducer = Float.floatToRawIntBits(start + 0.0f); /* * IEEE 754 floatingpoint numbers are lexicographically * ordered if treated as signed magnitude integers . * Since Java's integers are two's complement, * incrementing" the two's complement representation of a * logically negative floatingpoint value *decrements* * the signedmagnitude representation. Therefore, when * the integer representation of a floatingpoint values * is less than zero, the adjustment to the representation * is in the opposite direction than would be expected at * first. */ if (direction > start) {// Calculate next greater value transducer = transducer + (transducer >= 0 ? 1:1); } else { // Calculate next lesser value assert direction < start; if (transducer > 0) transducer; else if (transducer < 0 ) ++transducer; /* * transducer==0, the result is MIN_VALUE * * The transition from zero (implicitly * positive) to the smallest negative * signed magnitude value must be done * explicitly. */ else transducer = FloatConsts.SIGN_BIT_MASK  1; } return Float.intBitsToFloat(transducer); } }
Special cases: 
public static double nextDown(double d){ if( isNaN(d)  d == Double.NEGATIVE_INFINITY) return d; else { if (d == 0.0) return Double.MIN_VALUE; else return Double.longBitsToDouble(Double.doubleToRawLongBits(d) + ((d > 0.0d)?1L:+1L)); } }
Special Cases: 
public static double nextDown(float f){ if( isNaN(f)  f == Float.NEGATIVE_INFINITY) return f; else { if (f == 0.0f) return Float.MIN_VALUE; else return Float.intBitsToFloat(Float.floatToRawIntBits(f) + ((f > 0.0f)?1:+1)); } }
Special Cases: 
public static double nextUp(double d){ if( isNaN(d)  d == Double.POSITIVE_INFINITY) return d; else { d += 0.0d; return Double.longBitsToDouble(Double.doubleToRawLongBits(d) + ((d >= 0.0d)?+1L:1L)); } }
Special Cases: 
public static float nextUp(float f){ if( isNaN(f)  f == FloatConsts.POSITIVE_INFINITY) return f; else { f += 0.0f; return Float.intBitsToFloat(Float.floatToRawIntBits(f) + ((f >= 0.0f)?+1:1)); } }
Special Cases: 
static double powerOfTwoD(int n){ assert(n >= DoubleConsts.MIN_EXPONENT && n < = DoubleConsts.MAX_EXPONENT); return Double.longBitsToDouble((((long)n + (long)DoubleConsts.EXP_BIAS) < < (DoubleConsts.SIGNIFICAND_WIDTH1)) & DoubleConsts.EXP_BIT_MASK); }

static float powerOfTwoF(int n){ assert(n >= FloatConsts.MIN_EXPONENT && n < = FloatConsts.MAX_EXPONENT); return Float.intBitsToFloat(((n + FloatConsts.EXP_BIAS) < < (FloatConsts.SIGNIFICAND_WIDTH1)) & FloatConsts.EXP_BIT_MASK); }

public static double rawCopySign(double magnitude, double sign){ return Double.longBitsToDouble((Double.doubleToRawLongBits(sign) & (DoubleConsts.SIGN_BIT_MASK))  (Double.doubleToRawLongBits(magnitude) & (DoubleConsts.EXP_BIT_MASK  DoubleConsts.SIGNIF_BIT_MASK))); }

public static float rawCopySign(float magnitude, float sign){ return Float.intBitsToFloat((Float.floatToRawIntBits(sign) & (FloatConsts.SIGN_BIT_MASK))  (Float.floatToRawIntBits(magnitude) & (FloatConsts.EXP_BIT_MASK  FloatConsts.SIGNIF_BIT_MASK))); }

public static double scalb(double d, int scale_factor){ /* * This method does not need to be declared strictfp to * compute the same correct result on all platforms. When * scaling up, it does not matter what order the * multiplystore operations are done; the result will be * finite or overflow regardless of the operation ordering. * However, to get the correct result when scaling down, a * particular ordering must be used. * * When scaling down, the multiplystore operations are * sequenced so that it is not possible for two consecutive * multiplystores to return subnormal results. If one * multiplystore result is subnormal, the next multiply will * round it away to zero. This is done by first multiplying * by 2 ^ (scale_factor % n) and then multiplying several * times by by 2^n as needed where n is the exponent of number * that is a covenient power of two. In this way, at most one * real rounding error occurs. If the double value set is * being used exclusively, the rounding will occur on a * multiply. If the doubleextendedexponent value set is * being used, the products will (perhaps) be exact but the * stores to d are guaranteed to round to the double value * set. * * It is _not_ a valid implementation to first multiply d by * 2^MIN_EXPONENT and then by 2 ^ (scale_factor % * MIN_EXPONENT) since even in a strictfp program double * rounding on underflow could occur; e.g. if the scale_factor * argument was (MIN_EXPONENT  n) and the exponent of d was a * little less than (MIN_EXPONENT  n), meaning the final * result would be subnormal. * * Since exact reproducibility of this method can be achieved * without any undue performance burden, there is no * compelling reason to allow double rounding on underflow in * scalb. */ // magnitude of a power of two so large that scaling a finite // nonzero value by it would be guaranteed to over or // underflow; due to rounding, scaling down takes takes an // additional power of two which is reflected here final int MAX_SCALE = DoubleConsts.MAX_EXPONENT + DoubleConsts.MIN_EXPONENT + DoubleConsts.SIGNIFICAND_WIDTH + 1; int exp_adjust = 0; int scale_increment = 0; double exp_delta = Double.NaN; // Make sure scaling factor is in a reasonable range if(scale_factor < 0) { scale_factor = Math.max(scale_factor, MAX_SCALE); scale_increment = 512; exp_delta = twoToTheDoubleScaleDown; } else { scale_factor = Math.min(scale_factor, MAX_SCALE); scale_increment = 512; exp_delta = twoToTheDoubleScaleUp; } // Calculate (scale_factor % +/512), 512 = 2^9, using // technique from "Hacker's Delight" section 102. int t = (scale_factor > > 91) > > > 32  9; exp_adjust = ((scale_factor + t) & (512 1))  t; d *= powerOfTwoD(exp_adjust); scale_factor = exp_adjust; while(scale_factor != 0) { d *= exp_delta; scale_factor = scale_increment; } return d; }
Special cases: 
public static float scalb(float f, int scale_factor){ // magnitude of a power of two so large that scaling a finite // nonzero value by it would be guaranteed to over or // underflow; due to rounding, scaling down takes takes an // additional power of two which is reflected here final int MAX_SCALE = FloatConsts.MAX_EXPONENT + FloatConsts.MIN_EXPONENT + FloatConsts.SIGNIFICAND_WIDTH + 1; // Make sure scaling factor is in a reasonable range scale_factor = Math.max(Math.min(scale_factor, MAX_SCALE), MAX_SCALE); /* * Since + MAX_SCALE for float fits well within the double * exponent range and + float  > double conversion is exact * the multiplication below will be exact. Therefore, the * rounding that occurs when the double product is cast to * float will be the correctly rounded float result. Since * all operations other than the final multiply will be exact, * it is not necessary to declare this method strictfp. */ return (float)((double)f*powerOfTwoD(scale_factor)); }
Special cases: 
public static double signum(double d){ return (d == 0.0  isNaN(d))?d:copySign(1.0, d); }
Special Cases: 
public static float signum(float f){ return (f == 0.0f  isNaN(f))?f:copySign(1.0f, f); }
Special Cases: 
public static double ulp(double d){ int exp = getExponent(d); switch(exp) { case DoubleConsts.MAX_EXPONENT+1: // NaN or infinity return Math.abs(d); case DoubleConsts.MIN_EXPONENT1: // zero or subnormal return Double.MIN_VALUE; default: assert exp < = DoubleConsts.MAX_EXPONENT && exp >= DoubleConsts.MIN_EXPONENT; // ulp(x) is usually 2^(SIGNIFICAND_WIDTH1)*(2^ilogb(x)) exp = exp  (DoubleConsts.SIGNIFICAND_WIDTH1); if (exp >= DoubleConsts.MIN_EXPONENT) { return powerOfTwoD(exp); } else { // return a subnormal result; left shift integer // representation of Double.MIN_VALUE appropriate // number of positions return Double.longBitsToDouble(1L < < (exp  (DoubleConsts.MIN_EXPONENT  (DoubleConsts.SIGNIFICAND_WIDTH1)) )); } } }
ulp(x) == ulp(x) .
Special Cases: 
public static float ulp(float f){ int exp = getExponent(f); switch(exp) { case FloatConsts.MAX_EXPONENT+1: // NaN or infinity return Math.abs(f); case FloatConsts.MIN_EXPONENT1: // zero or subnormal return FloatConsts.MIN_VALUE; default: assert exp < = FloatConsts.MAX_EXPONENT && exp >= FloatConsts.MIN_EXPONENT; // ulp(x) is usually 2^(SIGNIFICAND_WIDTH1)*(2^ilogb(x)) exp = exp  (FloatConsts.SIGNIFICAND_WIDTH1); if (exp >= FloatConsts.MIN_EXPONENT) { return powerOfTwoF(exp); } else { // return a subnormal result; left shift integer // representation of FloatConsts.MIN_VALUE appropriate // number of positions return Float.intBitsToFloat(1 < < (exp  (FloatConsts.MIN_EXPONENT  (FloatConsts.SIGNIFICAND_WIDTH1)) )); } } }
ulp(x) == ulp(x) .
Special Cases: 