/*
 * Copyright (c) 2015, 2017, 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;

Faster Math ceil / floor routines derived from StrictMath
/** * 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; // Copied from sun.misc.FloatConsts: public static final int FLOAT_SIGNIFICAND_WIDTH = 24; // sun.misc.FloatConsts.SIGNIFICAND_WIDTH public static final int FLOAT_EXP_BIAS = 127; // sun.misc.FloatConsts.EXP_BIAS public static final int FLOAT_EXP_BIT_MASK = 2139095040;// sun.misc.FloatConsts.EXP_BIT_MASK public static final int FLOAT_SIGNIF_BIT_MASK = 8388607;// sun.misc.FloatConsts.SIGNIF_BIT_MASK private FloatMath() { // utility class } // faster inlined min/max functions in the branch prediction is high 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) float value that is greater than or equal to the argument and is equal to a mathematical integer. Special cases:
  • If the argument value is already equal to a mathematical integer, then the result is the same as the argument.
  • If the argument is NaN or an infinity or positive zero or negative zero, then the result is the same as the argument.
  • If the argument value is less than zero but greater than -1.0, then the result is negative zero.
Note that the value of StrictMath.ceil(x) is exactly the value of -StrictMath.floor(-x).
Params:
  • a – a value.
Returns: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.
/** * 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 & FLOAT_EXP_BIT_MASK) >> (FLOAT_SIGNIFICAND_WIDTH - 1)) - FLOAT_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.0f) ? a : ( (a < 0.0f) ? -0.0f : 1.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 & (~(FLOAT_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) float value that is less than or equal to the argument and is equal to a mathematical integer. Special cases:
  • If the argument value is already equal to a mathematical integer, then the result is the same as the argument.
  • If the argument is NaN or an infinity or positive zero or negative zero, then the result is the same as the argument.
Params:
  • a – a value.
Returns:the largest (closest to positive infinity) floating-point value that less than or equal to the argument and is equal to a mathematical integer.
/** * 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 & FLOAT_EXP_BIT_MASK) >> (FLOAT_SIGNIFICAND_WIDTH - 1)) - FLOAT_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.0f) ? a : ( (a < 0.0f) ? -1.0f : 0.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 & (~(FLOAT_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.
Params:
  • a – a value.
Returns:the largest (closest to positive infinity) integer value that less than or equal to the argument and is equal to a mathematical integer.
/** * 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 ceil(double) optimized for the integer domain and supporting NaN and +/-Infinity.
Params:
  • a – a value.
Returns:the largest (closest to positive infinity) integer value that less than or equal to the argument and is equal to a mathematical integer.
/** * Faster alternative to ceil(double) 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 double a) { final int intpart = (int) a; if (a <= intpart || (CHECK_OVERFLOW && intpart == Integer.MAX_VALUE) || CHECK_NAN && Double.isNaN(a)) { return intpart; } return intpart + 1; }
Faster alternative to floor(float) optimized for the integer domain and supporting NaN and +/-Infinity.
Params:
  • a – a value.
Returns:the largest (closest to positive infinity) floating-point value that less than or equal to the argument and is equal to a mathematical integer.
/** * 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; }
Faster alternative to floor(double) optimized for the integer domain and supporting NaN and +/-Infinity.
Params:
  • a – a value.
Returns:the largest (closest to positive infinity) floating-point value that less than or equal to the argument and is equal to a mathematical integer.
/** * Faster alternative to floor(double) 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 double a) { final int intpart = (int) a; if (a >= intpart || (CHECK_OVERFLOW && intpart == Integer.MIN_VALUE) || CHECK_NAN && Double.isNaN(a)) { return intpart; } return intpart - 1; } }