< prev index next >

## openjfx9/modules/javafx.graphics/src/main/java/com/sun/marlin/FloatMath.java

```*** 20,32 ****
*
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
- package sun.java2d.marlin;

! import jdk.internal.math.FloatConsts;

/**
* Faster Math ceil / floor routines derived from StrictMath
*/
public final class FloatMath implements MarlinConst {
--- 20,31 ----
*
* or visit www.oracle.com if you need additional information or have any
* questions.
*/

! package com.sun.marlin;

/**
* Faster Math ceil / floor routines derived from StrictMath
*/
public final class FloatMath implements MarlinConst {
*** 43,178 ****
static float max(final float a, final float b) {
// no NaN handling
return (a >= b) ? a : b;
}

!     static int max(final int a, final int b) {
return (a >= b) ? a : b;
}

!     static int min(final int a, final int b) {
return (a <= b) ? a : b;
}

/**
-      * Returns the smallest (closest to negative infinity) {@code float} value
-      * that is greater than or equal to the argument and is equal to a
-      * mathematical integer. Special cases:
-      * <ul><li>If the argument value is already equal to a mathematical integer,
-      * then the result is the same as the argument.  <li>If the argument is NaN
-      * or an infinity or positive zero or negative zero, then the result is the
-      * same as the argument.  <li>If the argument value is less than zero but
-      * greater than -1.0, then the result is negative zero.</ul> Note that the
-      * value of {@code StrictMath.ceil(x)} is exactly the value of
-      * {@code -StrictMath.floor(-x)}.
-      *
-      * @param a a value.
-      * @return the smallest (closest to negative infinity) floating-point value
-      * that is greater than or equal to the argument and is equal to a
-      * mathematical integer.
-      */
-     public static float ceil_f(final float a) {
-         // Derived from StrictMath.ceil(double):
-
-         // Inline call to Math.getExponent(a) to
-         // compute only once Float.floatToRawIntBits(a)
-         final int doppel = Float.floatToRawIntBits(a);
-
-         final int exponent = ((doppel & FloatConsts.EXP_BIT_MASK)
-                 >> (FloatConsts.SIGNIFICAND_WIDTH - 1))
-                 - FloatConsts.EXP_BIAS;
-
-         if (exponent < 0) {
-             /*
-              * Absolute value of argument is less than 1.
-              * floorOrceil(-0.0) => -0.0
-              * floorOrceil(+0.0) => +0.0
-              */
-             return ((a == 0) ? a :
-                     ( (a < 0f) ? -0f : 1f) );
-         }
-         if (CHECK_OVERFLOW && (exponent >= 23)) { // 52 for double
-             /*
-              * Infinity, NaN, or a value so large it must be integral.
-              */
-             return a;
-         }
-         // Else the argument is either an integral value already XOR it
-         // has to be rounded to one.
-         assert exponent >= 0 && exponent <= 22; // 51 for double
-
-         final int intpart = doppel
-
-         if (intpart == doppel) {
-             return a; // integral value (including 0)
-         }
-
-         // 0 handled above as an integer
-         // sign: 1 for negative, 0 for positive numbers
-         // add : 0 for negative and 1 for positive numbers
-         return Float.intBitsToFloat(intpart) + ((~intpart) >>> 31);
-     }
-
-     /**
-      * Returns the largest (closest to positive infinity) {@code float} value
-      * that is less than or equal to the argument and is equal to a mathematical
-      * integer. Special cases:
-      * <ul><li>If the argument value is already equal to a mathematical integer,
-      * then the result is the same as the argument.  <li>If the argument is NaN
-      * or an infinity or positive zero or negative zero, then the result is the
-      * same as the argument.</ul>
-      *
-      * @param a a value.
-      * @return the largest (closest to positive infinity) floating-point value
-      * that less than or equal to the argument and is equal to a mathematical
-      * integer.
-      */
-     public static float floor_f(final float a) {
-         // Derived from StrictMath.floor(double):
-
-         // Inline call to Math.getExponent(a) to
-         // compute only once Float.floatToRawIntBits(a)
-         final int doppel = Float.floatToRawIntBits(a);
-
-         final int exponent = ((doppel & FloatConsts.EXP_BIT_MASK)
-                 >> (FloatConsts.SIGNIFICAND_WIDTH - 1))
-                 - FloatConsts.EXP_BIAS;
-
-         if (exponent < 0) {
-             /*
-              * Absolute value of argument is less than 1.
-              * floorOrceil(-0.0) => -0.0
-              * floorOrceil(+0.0) => +0.0
-              */
-             return ((a == 0) ? a :
-                     ( (a < 0f) ? -1f : 0f) );
-         }
-         if (CHECK_OVERFLOW && (exponent >= 23)) { // 52 for double
-             /*
-              * Infinity, NaN, or a value so large it must be integral.
-              */
-             return a;
-         }
-         // Else the argument is either an integral value already XOR it
-         // has to be rounded to one.
-         assert exponent >= 0 && exponent <= 22; // 51 for double
-
-         final int intpart = doppel
-
-         if (intpart == doppel) {
-             return a; // integral value (including 0)
-         }
-
-         // 0 handled above as an integer
-         // sign: 1 for negative, 0 for positive numbers
-         // add : -1 for negative and 0 for positive numbers
-         return Float.intBitsToFloat(intpart) + (intpart >> 31);
-     }
-
-     /**
* Faster alternative to ceil(float) optimized for the integer domain
* and supporting NaN and +/-Infinity.
*
* @param a a value.
* @return the largest (closest to positive infinity) integer value
--- 42,60 ----
static float max(final float a, final float b) {
// no NaN handling
return (a >= b) ? a : b;
}

!     public static int max(final int a, final int b) {
return (a >= b) ? a : b;
}

!     public static int min(final int a, final int b) {
return (a <= b) ? a : b;
}

/**
* Faster alternative to ceil(float) optimized for the integer domain
* and supporting NaN and +/-Infinity.
*
* @param a a value.
* @return the largest (closest to positive infinity) integer value
```
< prev index next >