Java Code Examples for org.apache.commons.math3.exception.util.LocalizedFormats#OUT_OF_BOUNDS_QUANTILE_VALUE

The following examples show how to use org.apache.commons.math3.exception.util.LocalizedFormats#OUT_OF_BOUNDS_QUANTILE_VALUE . You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source File: Percentile.java    From astor with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * 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.
 * <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>MathIllegalArgumentException</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 Percentile} 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 MathIllegalArgumentException 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 MathIllegalArgumentException {

    test(values, begin, length);
    if (p > 100 || p <= 0) {
        throw new OutOfRangeException(
                LocalizedFormats.OUT_OF_BOUNDS_QUANTILE_VALUE, p, 0, 100);
    }
    if (length == 0) {
        return Double.NaN;
    }
    if (length == 1) {
        return values[begin]; // always return single value for n = 1
    }

    final double[] work = getWorkArray(values, begin, length);
    final int[] pivotsHeap = getPivots(values);
    return work.length == 0 ? Double.NaN :
                estimationType.evaluate(work, pivotsHeap, p, kthSelector);
}
Example 2
Source File: Percentile.java    From astor with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * 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.
 * <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>MathIllegalArgumentException</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 Percentile} 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 MathIllegalArgumentException 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 MathIllegalArgumentException {

    test(values, begin, length);

    if ((p > 100) || (p <= 0)) {
        throw new OutOfRangeException(
                LocalizedFormats.OUT_OF_BOUNDS_QUANTILE_VALUE, 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);
    }
    double lower = select(work, pivotsHeap, intPos - 1);
    double upper = select(work, pivotsHeap, intPos);
    return lower + dif * (upper - lower);
}
Example 3
Source File: Percentile.java    From astor with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * 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.
 * <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>MathIllegalArgumentException</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 Percentile} 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 MathIllegalArgumentException 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 MathIllegalArgumentException {

    test(values, begin, length);
    if (p > 100 || p <= 0) {
        throw new OutOfRangeException(
                LocalizedFormats.OUT_OF_BOUNDS_QUANTILE_VALUE, p, 0, 100);
    }
    if (length == 0) {
        return Double.NaN;
    }
    if (length == 1) {
        return values[begin]; // always return single value for n = 1
    }

    final double[] work = getWorkArray(values, begin, length);
    final int[] pivotsHeap = getPivots(values);
    return work.length == 0 ? Double.NaN :
                estimationType.evaluate(work, pivotsHeap, p, kthSelector);
}
Example 4
Source File: Percentile.java    From astor with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * 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.
 * <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 Percentile} 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) {

    test(values, begin, length);

    if ((p > 100) || (p <= 0)) {
        throw new OutOfRangeException(LocalizedFormats.OUT_OF_BOUNDS_QUANTILE_VALUE, 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);
    }
    double lower = select(work, pivotsHeap, intPos - 1);
    double upper = select(work, pivotsHeap, intPos);
    return lower + dif * (upper - lower);
}
Example 5
Source File: Percentile.java    From astor with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * 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.
 * <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>MathIllegalArgumentException</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 Percentile} 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 MathIllegalArgumentException 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 MathIllegalArgumentException {

    test(values, begin, length);

    if ((p > 100) || (p <= 0)) {
        throw new OutOfRangeException(
                LocalizedFormats.OUT_OF_BOUNDS_QUANTILE_VALUE, 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);
    }
    double lower = select(work, pivotsHeap, intPos - 1);
    double upper = select(work, pivotsHeap, intPos);
    return lower + dif * (upper - lower);
}
Example 6
Source File: Percentile.java    From astor with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * 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.
 * <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>MathIllegalArgumentException</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 Percentile} 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 MathIllegalArgumentException 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 MathIllegalArgumentException {

    test(values, begin, length);

    if ((p > 100) || (p <= 0)) {
        throw new OutOfRangeException(
                LocalizedFormats.OUT_OF_BOUNDS_QUANTILE_VALUE, 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);
    }
    double lower = select(work, pivotsHeap, intPos - 1);
    double upper = select(work, pivotsHeap, intPos);
    return lower + dif * (upper - lower);
}
Example 7
Source File: Percentile.java    From astor with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * 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.
 * <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 Percentile} 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) {

    test(values, begin, length);

    if ((p > 100) || (p <= 0)) {
        throw new OutOfRangeException(LocalizedFormats.OUT_OF_BOUNDS_QUANTILE_VALUE, 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);
    }
    double lower = select(work, pivotsHeap, intPos - 1);
    double upper = select(work, pivotsHeap, intPos);
    return lower + dif * (upper - lower);
}
Example 8
Source File: Percentile.java    From astor with GNU General Public License v2.0 4 votes vote down vote up 
/**
 * 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.
 * <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>MathIllegalArgumentException</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 Percentile} 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 MathIllegalArgumentException 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 MathIllegalArgumentException {

    test(values, begin, length);

    if ((p > 100) || (p <= 0)) {
        throw new OutOfRangeException(
                LocalizedFormats.OUT_OF_BOUNDS_QUANTILE_VALUE, 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);
    }
    double lower = select(work, pivotsHeap, intPos - 1);
    double upper = select(work, pivotsHeap, intPos);
    return lower + dif * (upper - lower);
}
Example 9
Source File: Percentile.java    From astor with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Evaluate method to compute the percentile for a given bounded array
 * using earlier computed pivots heap.<br>
 * This basically calls the {@link #index(double, int) index} and then
 * {@link #estimate(double[], int[], double, int, KthSelector) estimate}
 * functions to return the estimated percentile value.
 *
 * @param work array of numbers to be used for finding the percentile
 * @param pivotsHeap a prior cached heap which can speed up estimation
 * @param p the p<sup>th</sup> quantile to be computed
 * @param kthSelector a {@link KthSelector} used for pivoting during search
 * @return estimated percentile
 * @throws OutOfRangeException if p is out of range
 * @throws NullArgumentException if work array is null
 */
protected double evaluate(final double[] work, final int[] pivotsHeap, final double p,
                          final KthSelector kthSelector) {
    MathUtils.checkNotNull(work);
    if (p > 100 || p <= 0) {
        throw new OutOfRangeException(LocalizedFormats.OUT_OF_BOUNDS_QUANTILE_VALUE,
                                      p, 0, 100);
    }
    return estimate(work, pivotsHeap, index(p/100d, work.length), work.length, kthSelector);
}
Example 10
Source File: Percentile.java    From astor with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the value of the quantile field (determines what percentile is
 * computed when evaluate() is called with no quantile argument).
 *
 * @param p a value between 0 < p <= 100
 * @throws MathIllegalArgumentException  if p is not greater than 0 and less
 * than or equal to 100
 */
public void setQuantile(final double p) throws MathIllegalArgumentException {
    if (p <= 0 || p > 100) {
        throw new OutOfRangeException(
                LocalizedFormats.OUT_OF_BOUNDS_QUANTILE_VALUE, p, 0, 100);
    }
    quantile = p;
}
Example 11
Source File: Percentile.java    From astor with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the value of the quantile field (determines what percentile is
 * computed when evaluate() is called with no quantile argument).
 *
 * @param p a value between 0 < p <= 100
 * @throws MathIllegalArgumentException  if p is not greater than 0 and less
 * than or equal to 100
 */
public void setQuantile(final double p) throws MathIllegalArgumentException {
    if (p <= 0 || p > 100) {
        throw new OutOfRangeException(
                LocalizedFormats.OUT_OF_BOUNDS_QUANTILE_VALUE, p, 0, 100);
    }
    quantile = p;
}
Example 12
Source File: Percentile.java    From astor with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the value of the quantile field (determines what percentile is
 * computed when evaluate() is called with no quantile argument).
 *
 * @param p a value between 0 < p <= 100
 * @throws MathIllegalArgumentException  if p is not greater than 0 and less
 * than or equal to 100
 */
public void setQuantile(final double p) throws MathIllegalArgumentException {
    if (p <= 0 || p > 100) {
        throw new OutOfRangeException(
                LocalizedFormats.OUT_OF_BOUNDS_QUANTILE_VALUE, p, 0, 100);
    }
    quantile = p;
}
Example 13
Source File: Percentile.java    From astor with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the value of the quantile field (determines what percentile is
 * computed when evaluate() is called with no quantile argument).
 *
 * @param p a value between 0 < p <= 100
 * @throws IllegalArgumentException  if p is not greater than 0 and less
 * than or equal to 100
 */
public void setQuantile(final double p) {
    if (p <= 0 || p > 100) {
        throw new OutOfRangeException(LocalizedFormats.OUT_OF_BOUNDS_QUANTILE_VALUE, p, 0, 100);
    }
    quantile = p;
}
Example 14
Source File: Percentile.java    From astor with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the value of the quantile field (determines what percentile is
 * computed when evaluate() is called with no quantile argument).
 *
 * @param p a value between 0 < p <= 100
 * @throws MathIllegalArgumentException  if p is not greater than 0 and less
 * than or equal to 100
 */
public void setQuantile(final double p) throws MathIllegalArgumentException {
    if (p <= 0 || p > 100) {
        throw new OutOfRangeException(
                LocalizedFormats.OUT_OF_BOUNDS_QUANTILE_VALUE, p, 0, 100);
    }
    quantile = p;
}
Example 15
Source File: Percentile.java    From astor with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the value of the quantile field (determines what percentile is
 * computed when evaluate() is called with no quantile argument).
 *
 * @param p a value between 0 < p <= 100
 * @throws IllegalArgumentException  if p is not greater than 0 and less
 * than or equal to 100
 */
public void setQuantile(final double p) {
    if (p <= 0 || p > 100) {
        throw new OutOfRangeException(LocalizedFormats.OUT_OF_BOUNDS_QUANTILE_VALUE, p, 0, 100);
    }
    quantile = p;
}
Example 16
Source File: Percentile.java    From astor with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the value of the quantile field (determines what percentile is
 * computed when evaluate() is called with no quantile argument).
 *
 * @param p a value between 0 < p <= 100
 * @throws MathIllegalArgumentException  if p is not greater than 0 and less
 * than or equal to 100
 */
public void setQuantile(final double p) throws MathIllegalArgumentException {
    if (p <= 0 || p > 100) {
        throw new OutOfRangeException(
                LocalizedFormats.OUT_OF_BOUNDS_QUANTILE_VALUE, p, 0, 100);
    }
    quantile = p;
}
Example 17
Source File: Percentile.java    From astor with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Evaluate method to compute the percentile for a given bounded array
 * using earlier computed pivots heap.<br>
 * This basically calls the {@link #index(double, int) index} and then
 * {@link #estimate(double[], int[], double, int, KthSelector) estimate}
 * functions to return the estimated percentile value.
 *
 * @param work array of numbers to be used for finding the percentile
 * @param pivotsHeap a prior cached heap which can speed up estimation
 * @param p the p<sup>th</sup> quantile to be computed
 * @param kthSelector a {@link KthSelector} used for pivoting during search
 * @return estimated percentile
 * @throws OutOfRangeException if p is out of range
 * @throws NullArgumentException if work array is null
 */
protected double evaluate(final double[] work, final int[] pivotsHeap, final double p,
                          final KthSelector kthSelector) {
    MathUtils.checkNotNull(work);
    if (p > 100 || p <= 0) {
        throw new OutOfRangeException(LocalizedFormats.OUT_OF_BOUNDS_QUANTILE_VALUE,
                                      p, 0, 100);
    }
    return estimate(work, pivotsHeap, index(p/100d, work.length), work.length, kthSelector);
}
Example 18
Source File: Percentile.java    From astor with GNU General Public License v2.0 3 votes vote down vote up 
/**
 * Sets the value of the quantile field (determines what percentile is
 * computed when evaluate() is called with no quantile argument).
 *
 * @param p a value between 0 < p <= 100
 * @throws MathIllegalArgumentException  if p is not greater than 0 and less
 * than or equal to 100
 */
public void setQuantile(final double p) throws MathIllegalArgumentException {
    if (p <= 0 || p > 100) {
        throw new OutOfRangeException(
                LocalizedFormats.OUT_OF_BOUNDS_QUANTILE_VALUE, p, 0, 100);
    }
    quantile = p;
}