--- /dev/null 2015-11-23 13:25:12.000000000 -0800 +++ new/src/java.desktop/share/classes/sun/java2d/marlin/FloatMath.java 2015-11-23 13:25:12.000000000 -0800 @@ -0,0 +1,223 @@ +/* + * Copyright (c) 2015, 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.java2d.marlin; + +import sun.misc.DoubleConsts; +import sun.misc.FloatConsts; + +/** + * Faster Math ceil / floor routines derived from StrictMath + */ +public final class FloatMath implements MarlinConst { + + // overflow / NaN handling enabled: + static final boolean CHECK_OVERFLOW = true; + static final boolean CHECK_NAN = true; + + private FloatMath() { + // utility class + } + + // faster inlined min/max functions in the branch prediction is high + 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: + * 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 + & (~(FloatConsts.SIGNIF_BIT_MASK >> exponent)); + + 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: + * + * + * @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 + & (~(FloatConsts.SIGNIF_BIT_MASK >> exponent)); + + 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 + * that less than or equal to the argument and is equal to a mathematical + * integer. + */ + public static int ceil_int(final float a) { + final int intpart = (int) a; + + if (a <= intpart + || (CHECK_OVERFLOW && intpart == Integer.MAX_VALUE) + || CHECK_NAN && Float.isNaN(a)) { + return intpart; + } + return intpart + 1; + } + + /** + * Faster alternative to floor(float) optimized for the integer domain + * and supporting NaN and +/-Infinity. + * + * @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 int floor_int(final float a) { + final int intpart = (int) a; + + if (a >= intpart + || (CHECK_OVERFLOW && intpart == Integer.MIN_VALUE) + || CHECK_NAN && Float.isNaN(a)) { + return intpart; + } + return intpart - 1; + } + + /** + * Returns a floating-point power of two in the normal range. + */ + 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_WIDTH - 1)) + & DoubleConsts.EXP_BIT_MASK); + } +}