* 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);
    }