java/12 : java.desktop/sun/java2d/marlin/FloatMath.java

FloatMath
https://openjdk.java.net/
GPLv2 + Classpath Exception
/*
 * 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;
    }
}
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.
/

java/ 12/ java.desktop/sun/java2d/marlin/FloatMath.java
