Binding for {@link java.lang.Math#nextUp(float)}

@param f starting floating-point value
@return The adjacent floating-point value closer to positive
infinity.
427822
public static FloatBinding nextUp(final ObservableFloatValue f) {
        return createFloatBinding(() -> Math.nextUp(f.get()), f);
    }
91112
protected static double calcPosterior(double f, double alpha, double mu, double sigma, double lambda) {
    final double pi = calcP_i(f, mu, sigma);
    final double qi = calcQ_i(f, lambda);
    return (alpha * pi) / (alpha * pi + (1.0 - alpha) * qi);
  }
665505
@Override
    public float getFloat(int index) {
        check(index);
        final FLValue flValue = values.get(index);
        return flValue != null ? flValue.asFloat() : 0.0F;
    }
1100965
public static int floatToSortableInt(float value)
    {
        int bits = Float.floatToIntBits(value);
        return bits ^ (bits >> 31) & Integer.MAX_VALUE;
    }
50152
public static int search(float[] floatArray, float value) { 
        int start = 0;
        int end = floatArray.length - 1;
        int middle = 0;
        
        while(start <= end) {
            middle = (start + end) >> 1;
        
            if(value == floatArray[middle]) {
                return middle;
            }
            
            if(value < floatArray[middle]) {
                end = middle - 1 ;
            }
            else {
                start = middle + 1;
            }
        }
                

        return -1;
    }
824853
public static int nextAllOnesInt(int x) {
    x |= x >>> 1;
    x |= x >>> 2;
    x |= x >>> 4;
    x |= x >>> 8;
    x |= x >>> 16;
    return x;
  }
728148
public static FloatBinding min(final ObservableFloatValue a, final ObservableFloatValue b) {
        return createFloatBinding(() -> Math.min(a.get(), b.get()), a, b);
    }
515697
public float getFloat(String key) {
    if (containsKey(key)) {
      return Float.parseFloat(get(key));
    } else {
      throw new IllegalArgumentException("Missing key " + key + ".");
    }
  }
1272308
public final float set0(int idx, float f) {
    setWrite();
    if( _chk2.set_impl(idx,f) ) return f;
    (_chk2 = inflate_impl(new NewChunk(this))).set_impl(idx,f);
    return f;
  }
1366822
public static FloatBinding max(final float a, final ObservableFloatValue b) {
        return createFloatBinding(() -> Math.max(a, b.get()), b);
    }
375392
public static int getExponent(float f){
        /*
         * Bitwise convert f to integer, mask out exponent bits, shift
         * to the right and then subtract out float's bias adjust to
         * get true exponent value
         */
        return ((Float.floatToRawIntBits(f) & FloatConsts.EXP_BIT_MASK) >>
                (FloatConsts.SIGNIFICAND_WIDTH - 1)) - FloatConsts.EXP_BIAS;
    }
835208
public static double nextUp(double d) {
        if (Double.isNaN(d) || d == Double.POSITIVE_INFINITY) {
            return d;
        } else {
            d += 0.0;
            return Double.longBitsToDouble(Double.doubleToRawLongBits(d) + ((d >= 0.0) ? +1 : -1));
        }
    }
468057
public long nextLong(final long n) 
        {
        if (n<=0)
            throw new IllegalArgumentException("n must be > 0");
        
        long bits, val;
        do 
            {
            bits = (nextLong() >>> 1);
            val = bits % n;
            } 
        while(bits - val + (n-1) < 0);
        return val;
        }
305402
public static float max(final float a, final float b) {
        if (Float.isNaN(a)) {
            return b;
        } else if (Float.isNaN(b)) {
            return a;
        } else {
            return Math.max(a, b);
        }
    }
1078923
public static int maxFill(int n, float f) {
		return Math.min((int) Math.ceil((double) ((float) n * f)), n - 1);
	}
1374652
public synchronized PacketBuilder withFloat(final float f)
    {
        checkBuilt();
        try
        {
            dataOutputStream.writeFloat(f);
        }
        catch (final IOException e)
        {
            logger.error("Unable to add float: {} : {}", e.getClass(), e.getMessage());
        }
        return this;
    }
758350
public static float max(float[] x) {
        float m = Float.NEGATIVE_INFINITY;

        for (float n : x) {
            if (n > m) {
                m = n;
            }
        }

        return m;
    }