1 /*

     2  * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 package sun.java2d.marlin;

    26 

    27 import sun.misc.DoubleConsts;

    28 import sun.misc.FloatConsts;

    29 

    30 /**

    31  * Faster Math ceil / floor routines derived from StrictMath

    32  */

    33 public final class FloatMath implements MarlinConst {

    34 

    35     // overflow / NaN handling enabled:

    36     static final boolean CHECK_OVERFLOW = true;

    37     static final boolean CHECK_NAN = true;

    38 

    39     private FloatMath() {

    40         // utility class

    41     }

    42 

    43     // faster inlined min/max functions in the branch prediction is high

    44     static float max(final float a, final float b) {

    45         // no NaN handling

    46         return (a >= b) ? a : b;

    47     }

    48 

    49     static int max(final int a, final int b) {

    50         return (a >= b) ? a : b;

    51     }

    52 

    53     static int min(final int a, final int b) {

    54         return (a <= b) ? a : b;

    55     }

    56 

    57     /**

    58      * Returns the smallest (closest to negative infinity) {@code float} value

    59      * that is greater than or equal to the argument and is equal to a

    60      * mathematical integer. Special cases:

    61      * <ul><li>If the argument value is already equal to a mathematical integer,

    62      * then the result is the same as the argument.  <li>If the argument is NaN

    63      * or an infinity or positive zero or negative zero, then the result is the

    64      * same as the argument.  <li>If the argument value is less than zero but

    65      * greater than -1.0, then the result is negative zero.</ul> Note that the

    66      * value of {@code StrictMath.ceil(x)} is exactly the value of

    67      * {@code -StrictMath.floor(-x)}.

    68      *

    69      * @param a a value.

    70      * @return the smallest (closest to negative infinity) floating-point value

    71      * that is greater than or equal to the argument and is equal to a

    72      * mathematical integer.

    73      */

    74     public static float ceil_f(final float a) {

    75         // Derived from StrictMath.ceil(double):

    76 

    77         // Inline call to Math.getExponent(a) to

    78         // compute only once Float.floatToRawIntBits(a)

    79         final int doppel = Float.floatToRawIntBits(a);

    80 

    81         final int exponent = ((doppel & FloatConsts.EXP_BIT_MASK)

    82                 >> (FloatConsts.SIGNIFICAND_WIDTH - 1))

    83                 - FloatConsts.EXP_BIAS;

    84 

    85         if (exponent < 0) {

    86             /*

    87              * Absolute value of argument is less than 1.

    88              * floorOrceil(-0.0) => -0.0

    89              * floorOrceil(+0.0) => +0.0

    90              */

    91             return ((a == 0) ? a :

    92                     ( (a < 0f) ? -0f : 1f) );

    93         }

    94         if (CHECK_OVERFLOW && (exponent >= 23)) { // 52 for double

    95             /*

    96              * Infinity, NaN, or a value so large it must be integral.

    97              */

    98             return a;

    99         }

   100         // Else the argument is either an integral value already XOR it

   101         // has to be rounded to one.

   102         assert exponent >= 0 && exponent <= 22; // 51 for double

   103 

   104         final int intpart = doppel

   105                 & (~(FloatConsts.SIGNIF_BIT_MASK >> exponent));

   106 

   107         if (intpart == doppel) {

   108             return a; // integral value (including 0)

   109         }

   110 

   111         // 0 handled above as an integer

   112         // sign: 1 for negative, 0 for positive numbers

   113         // add : 0 for negative and 1 for positive numbers

   114         return Float.intBitsToFloat(intpart) + ((~intpart) >>> 31);

   115     }

   116 

   117     /**

   118      * Returns the largest (closest to positive infinity) {@code float} value

   119      * that is less than or equal to the argument and is equal to a mathematical

   120      * integer. Special cases:

   121      * <ul><li>If the argument value is already equal to a mathematical integer,

   122      * then the result is the same as the argument.  <li>If the argument is NaN

   123      * or an infinity or positive zero or negative zero, then the result is the

   124      * same as the argument.</ul>

   125      *

   126      * @param a a value.

   127      * @return the largest (closest to positive infinity) floating-point value

   128      * that less than or equal to the argument and is equal to a mathematical

   129      * integer.

   130      */

   131     public static float floor_f(final float a) {

   132         // Derived from StrictMath.floor(double):

   133 

   134         // Inline call to Math.getExponent(a) to

   135         // compute only once Float.floatToRawIntBits(a)

   136         final int doppel = Float.floatToRawIntBits(a);

   137 

   138         final int exponent = ((doppel & FloatConsts.EXP_BIT_MASK)

   139                 >> (FloatConsts.SIGNIFICAND_WIDTH - 1))

   140                 - FloatConsts.EXP_BIAS;

   141 

   142         if (exponent < 0) {

   143             /*

   144              * Absolute value of argument is less than 1.

   145              * floorOrceil(-0.0) => -0.0

   146              * floorOrceil(+0.0) => +0.0

   147              */

   148             return ((a == 0) ? a :

   149                     ( (a < 0f) ? -1f : 0f) );

   150         }

   151         if (CHECK_OVERFLOW && (exponent >= 23)) { // 52 for double

   152             /*

   153              * Infinity, NaN, or a value so large it must be integral.

   154              */

   155             return a;

   156         }

   157         // Else the argument is either an integral value already XOR it

   158         // has to be rounded to one.

   159         assert exponent >= 0 && exponent <= 22; // 51 for double

   160 

   161         final int intpart = doppel

   162                 & (~(FloatConsts.SIGNIF_BIT_MASK >> exponent));

   163 

   164         if (intpart == doppel) {

   165             return a; // integral value (including 0)

   166         }

   167 

   168         // 0 handled above as an integer

   169         // sign: 1 for negative, 0 for positive numbers

   170         // add : -1 for negative and 0 for positive numbers

   171         return Float.intBitsToFloat(intpart) + (intpart >> 31);

   172     }

   173 

   174     /**

   175      * Faster alternative to ceil(float) optimized for the integer domain

   176      * and supporting NaN and +/-Infinity.

   177      *

   178      * @param a a value.

   179      * @return the largest (closest to positive infinity) integer value

   180      * that less than or equal to the argument and is equal to a mathematical

   181      * integer.

   182      */

   183     public static int ceil_int(final float a) {

   184         final int intpart = (int) a;

   185 

   186         if (a <= intpart

   187                 || (CHECK_OVERFLOW && intpart == Integer.MAX_VALUE)

   188                 || CHECK_NAN && Float.isNaN(a)) {

   189             return intpart;

   190         }

   191         return intpart + 1;

   192     }

   193 

   194     /**

   195      * Faster alternative to floor(float) optimized for the integer domain

   196      * and supporting NaN and +/-Infinity.

   197      *

   198      * @param a a value.

   199      * @return the largest (closest to positive infinity) floating-point value

   200      * that less than or equal to the argument and is equal to a mathematical

   201      * integer.

   202      */

   203     public static int floor_int(final float a) {

   204         final int intpart = (int) a;

   205 

   206         if (a >= intpart

   207                 || (CHECK_OVERFLOW && intpart == Integer.MIN_VALUE)

   208                 || CHECK_NAN && Float.isNaN(a)) {

   209             return intpart;

   210         }

   211         return intpart - 1;

   212     }

   213 

   214     /**

   215      * Returns a floating-point power of two in the normal range.

   216      */

   217     static double powerOfTwoD(int n) {

   218         assert (n >= DoubleConsts.MIN_EXPONENT && n <= DoubleConsts.MAX_EXPONENT);

   219         return Double.longBitsToDouble((((long) n + (long) DoubleConsts.EXP_BIAS)

   220                 << (DoubleConsts.SIGNIFICAND_WIDTH - 1))

   221                 & DoubleConsts.EXP_BIT_MASK);

   222     }

   223 }