Example usage for org.apache.commons.math.util FastMath floor

Introduction

In this page you can find the example usage for org.apache.commons.math.util FastMath floor.

Prototype

public static double floor(double x) 

Source Link

Document

Get the largest whole number smaller than x.

Usage

From source file:net.malariagen.gatk.math.SaddlePointExpansion.java

/**
 * Compute the error of Stirling's series at the given value.
 * <p>//from w w  w .ja v  a2s  . c  o m
 * References:
 * <ol>
 * <li>Eric W. Weisstein. "Stirling's Series." From MathWorld--A Wolfram Web
 * Resource. <a target="_blank"
 * href="http://mathworld.wolfram.com/StirlingsSeries.html">
 * http://mathworld.wolfram.com/StirlingsSeries.html</a></li>
 * </ol>
 * </p>
 *
 * @param z the value.
 * @return the Striling's series error.
 */
static double getStirlingError(double z) {
    double ret;
    if (z < 15.0) {
        double z2 = 2.0 * z;
        if (FastMath.floor(z2) == z2) {
            ret = EXACT_STIRLING_ERRORS[(int) z2];
        } else {
            ret = Gamma.logGamma(z + 1.0) - (z + 0.5) * FastMath.log(z) + z - HALF_LOG_2_PI;
        }
    } else {
        double z2 = z * z;
        ret = (0.083333333333333333333 - (0.00277777777777777777778 - (0.00079365079365079365079365
                - (0.000595238095238095238095238 - 0.0008417508417508417508417508 / z2) / z2) / z2) / z2) / z;
    }
    return ret;
}

---

From source file:cz.paulrz.montecarlo.random.ParallelPercentile.java

/**
* Returns an estimate of the <code>p</code>th percentile of the values
* in the <code>values</code> array, starting with the element in (0-based)
* position <code>begin</code> in the array and including <code>length</code>
* values./*from   ww  w.  j a  va2s .c  o m*/
* <p>
* Calls to this method do not modify the internal <code>quantile</code>
* state of this statistic.</p>
* <p>
* <ul>
* <li>Returns <code>Double.NaN</code> if <code>length = 0</code></li>
* <li>Returns (for any value of <code>p</code>) <code>values[begin]</code>
*  if <code>length = 1 </code></li>
* <li>Throws <code>IllegalArgumentException</code> if <code>values</code>
*  is null , <code>begin</code> or <code>length</code> is invalid, or
* <code>p</code> is not a valid quantile value (p must be greater than 0
* and less than or equal to 100)</li>
* </ul></p>
* <p>
* See {@link ParallelPercentile} for a description of the percentile estimation
* algorithm used.</p>
*
* @param values array of input values
* @param p  the percentile to compute
* @param begin  the first (0-based) element to include in the computation
* @param length  the number of array elements to include
* @return  the percentile value
* @throws IllegalArgumentException if the parameters are not valid or the
* input array is null
*/
public double evaluate(final double[] values, final int begin, final int length, final double p)
        throws MathException {

    test(values, begin, length);

    if ((p > 100) || (p <= 0)) {
        throw new OutOfRangeException(p, 0, 100);
    }
    if (length == 0) {
        return Double.NaN;
    }
    if (length == 1) {
        return values[begin]; // always return single value for n = 1
    }
    double n = length;
    double pos = p * (n + 1) / 100;
    double fpos = FastMath.floor(pos);
    int intPos = (int) fpos;
    double dif = pos - fpos;
    double[] work;
    int[] pivotsHeap;
    if (values == getDataRef()) {
        work = getDataRef();
        pivotsHeap = cachedPivots;
    } else {
        work = new double[length];
        System.arraycopy(values, begin, work, 0, length);
        pivotsHeap = new int[(0x1 << MAX_CACHED_LEVELS) - 1];
        Arrays.fill(pivotsHeap, -1);
    }

    if (pos < 1) {
        return select(work, pivotsHeap, 0);
    }
    if (pos >= n) {
        return select(work, pivotsHeap, length - 1);
    }

    Future<Double> lowerFuture = CpuPool.executorService.submit(new SelectWorker(work, pivotsHeap, intPos - 1));
    Future<Double> upperFuture = CpuPool.executorService.submit(new SelectWorker(work, pivotsHeap, intPos));

    try {
        double lower = lowerFuture.get();
        double upper = upperFuture.get();
        return lower + dif * (upper - lower);
    } catch (InterruptedException e) {
        throw new MathException(e);
    } catch (ExecutionException e) {
        throw new MathException(e);
    }
}

---