Example usage for org.apache.commons.math3.exception NumberIsTooSmallException NumberIsTooSmallException

List of usage examples for org.apache.commons.math3.exception NumberIsTooSmallException NumberIsTooSmallException

Introduction

In this page you can find the example usage for org.apache.commons.math3.exception NumberIsTooSmallException NumberIsTooSmallException.

Prototype

public NumberIsTooSmallException(Localizable specific, Number wrong, Number min, boolean boundIsAllowed) 

Source Link

Document

Construct the exception with a specific context.

Usage

From source file:au.gov.ga.conn4d.utils.SplineInterpolator.java

/**
 * Computes an interpolating function for the data set.
 * /*from  w  ww  . j a  v a  2 s. c  om*/
 * @param x
 *            the arguments for the interpolation points
 * @param y
 *            the values for the interpolation points
 * @return a function which interpolates the data set
 * @throws DimensionMismatchException
 *             if {@code x} and {@code y} have different sizes.
 * @throws NonMonotonicSequenceException
 *             if {@code x} is not sorted in strict increasing order.
 * @throws NumberIsTooSmallException
 *             if the size of {@code x} is smaller than 3.
 */
public PolynomialSplineFunction interpolate(double x[], double y[])
        throws DimensionMismatchException, NumberIsTooSmallException, NonMonotonicSequenceException {
    if (x.length != y.length) {
        throw new DimensionMismatchException(x.length, y.length);
    }

    if (x.length < 3) {
        throw new NumberIsTooSmallException(LocalizedFormats.NUMBER_OF_POINTS, x.length, 3, true);
    }

    // Number of intervals. The number of data points is n + 1.
    final int n = x.length - 1;

    MathArrays.checkOrder(x);

    // Differences between knot points
    final double h[] = new double[n];
    for (int i = 0; i < n; i++) {
        h[i] = x[i + 1] - x[i];
    }

    final double mu[] = new double[n];
    final double z[] = new double[n + 1];
    mu[0] = 0d;
    z[0] = 0d;
    double g = 0;
    for (int i = 1; i < n; i++) {
        g = 2d * (x[i + 1] - x[i - 1]) - h[i - 1] * mu[i - 1];
        mu[i] = h[i] / g;
        z[i] = (3d * (y[i + 1] * h[i - 1] - y[i] * (x[i + 1] - x[i - 1]) + y[i - 1] * h[i]) / (h[i - 1] * h[i])
                - h[i - 1] * z[i - 1]) / g;
    }

    // cubic spline coefficients -- b is linear, c quadratic, d is cubic
    // (original y's are constants)
    final double b[] = new double[n];
    final double c[] = new double[n + 1];
    final double d[] = new double[n];

    z[n] = 0d;
    c[n] = 0d;

    for (int j = n - 1; j >= 0; j--) {
        c[j] = z[j] - mu[j] * c[j + 1];
        b[j] = (y[j + 1] - y[j]) / h[j] - h[j] * (c[j + 1] + 2d * c[j]) / 3d;
        d[j] = (c[j + 1] - c[j]) / (3d * h[j]);
    }

    final PolynomialFunction polynomials[] = new PolynomialFunction[n];
    final double coefficients[] = new double[4];
    for (int i = 0; i < n; i++) {
        coefficients[0] = y[i];
        coefficients[1] = b[i];
        coefficients[2] = c[i];
        coefficients[3] = d[i];
        polynomials[i] = new PolynomialFunction(coefficients);
    }

    return new PolynomialSplineFunction(x, polynomials);
}

From source file:au.gov.ga.conn4d.utils.SplineInterpolator.java

public PolynomialSplineFunction interpolate(double x[], float y[])
        throws DimensionMismatchException, NumberIsTooSmallException, NonMonotonicSequenceException {
    if (x.length != y.length) {
        throw new DimensionMismatchException(x.length, y.length);
    }/*from  ww  w. j  a v a 2s.  c o  m*/

    if (x.length < 3) {
        throw new NumberIsTooSmallException(LocalizedFormats.NUMBER_OF_POINTS, x.length, 3, true);
    }

    // Number of intervals. The number of data points is n + 1.
    final int n = x.length - 1;

    MathArrays.checkOrder(x);

    // Differences between knot points
    final double h[] = new double[n];
    for (int i = 0; i < n; i++) {
        h[i] = x[i + 1] - x[i];
    }

    final double mu[] = new double[n];
    final double z[] = new double[n + 1];
    mu[0] = 0d;
    z[0] = 0d;
    double g = 0;
    for (int i = 1; i < n; i++) {
        g = 2d * (x[i + 1] - x[i - 1]) - h[i - 1] * mu[i - 1];
        mu[i] = h[i] / g;
        z[i] = (3d * (y[i + 1] * h[i - 1] - y[i] * (x[i + 1] - x[i - 1]) + y[i - 1] * h[i]) / (h[i - 1] * h[i])
                - h[i - 1] * z[i - 1]) / g;
    }

    // cubic spline coefficients -- b is linear, c quadratic, d is cubic
    // (original y's are constants)
    final double b[] = new double[n];
    final double c[] = new double[n + 1];
    final double d[] = new double[n];

    z[n] = 0d;
    c[n] = 0d;

    for (int j = n - 1; j >= 0; j--) {
        c[j] = z[j] - mu[j] * c[j + 1];
        b[j] = (y[j + 1] - y[j]) / h[j] - h[j] * (c[j + 1] + 2d * c[j]) / 3d;
        d[j] = (c[j + 1] - c[j]) / (3d * h[j]);
    }

    final PolynomialFunction polynomials[] = new PolynomialFunction[n];
    final double coefficients[] = new double[4];
    for (int i = 0; i < n; i++) {
        coefficients[0] = y[i];
        coefficients[1] = b[i];
        coefficients[2] = c[i];
        coefficients[3] = d[i];
        polynomials[i] = new PolynomialFunction(coefficients);
    }

    return new PolynomialSplineFunction(x, polynomials);
}

From source file:cz.cuni.lf1.lge.ThunderSTORM.results.ModifiedLoess.java

/**
 * Compute a weighted loess fit on the data at the original abscissae.
 *
 * @param xval Arguments for the interpolation points.
 * @param yval Values for the interpolation points.
 * @param weights point weights: coefficients by which the robustness weight
 * of a point is multiplied.//from  w ww . j ava  2s  .c  om
 * @return the values of the loess fit at corresponding original abscissae.
 * @throws NonMonotonicSequenceException if {@code xval} not sorted in
 * strictly increasing order.
 * @throws DimensionMismatchException if {@code xval} and {@code yval} have
 * different sizes.
 * @throws NoDataException if {@code xval} or {@code yval} has zero size.
 * @throws NotFiniteNumberException if any of the arguments and values are
 not finite real numbers.
 * @throws NumberIsTooSmallException if the bandwidth is too small to
 * accomodate the size of the input data (i.e. the bandwidth must be
 * larger than 2/n).
 * @since 2.1
 */
public final double[] smooth(final double[] xval, final double[] yval, final double[] weights)
        throws NonMonotonicSequenceException, DimensionMismatchException, NoDataException,
        NotFiniteNumberException, NumberIsTooSmallException {
    if (xval.length != yval.length) {
        throw new DimensionMismatchException(xval.length, yval.length);
    }

    final int n = xval.length;

    if (n == 0) {
        throw new NoDataException();
    }

    checkAllFiniteReal(xval);
    checkAllFiniteReal(yval);
    checkAllFiniteReal(weights);

    MathArrays.checkOrder(xval, MathArrays.OrderDirection.INCREASING, false);

    if (n == 1) {
        return new double[] { yval[0] };
    }

    if (n == 2) {
        return new double[] { yval[0], yval[1] };
    }

    int bandwidthInPoints = (int) (bandwidth * n);

    if (bandwidthInPoints < 2) {
        throw new NumberIsTooSmallException(LocalizedFormats.BANDWIDTH, bandwidthInPoints, 2, true);
    }

    final double[] res = new double[n];

    final double[] residuals = new double[n];
    final double[] sortedResiduals = new double[n];

    final double[] robustnessWeights = new double[n];

    // Do an initial fit and 'robustnessIters' robustness iterations.
    // This is equivalent to doing 'robustnessIters+1' robustness iterations
    // starting with all robustness weights set to 1.
    Arrays.fill(robustnessWeights, 1);

    for (int iter = 0; iter <= robustnessIters; ++iter) {
        final int[] bandwidthInterval = { 0, bandwidthInPoints - 1 };
        // At each x, compute a local weighted linear regression
        for (int i = 0; i < n; ++i) {
            final double x = xval[i];

            // Find out the interval of source points on which
            // a regression is to be made.
            if (i > 0) {
                updateBandwidthInterval(xval, weights, i, bandwidthInterval);
            }

            final int ileft = bandwidthInterval[0];
            final int iright = bandwidthInterval[1];

            // Compute the point of the bandwidth interval that is
            // farthest from x
            final int edge;
            if (xval[i] - xval[ileft] > xval[iright] - xval[i]) {
                edge = ileft;
            } else {
                edge = iright;
            }

            // Compute a least-squares linear fit weighted by
            // the product of robustness weights and the tricube
            // weight function.
            // See http://en.wikipedia.org/wiki/Linear_regression
            // (section "Univariate linear case")
            // and http://en.wikipedia.org/wiki/Weighted_least_squares
            // (section "Weighted least squares")
            double sumWeights = 0;
            double sumX = 0;
            double sumXSquared = 0;
            double sumY = 0;
            double sumXY = 0;
            double denom = FastMath.abs(1.0 / (xval[edge] - x));
            for (int k = ileft; k <= iright; ++k) {
                final double xk = xval[k];
                final double yk = yval[k];
                final double dist = (k < i) ? x - xk : xk - x;
                final double w = tricube(dist * denom) * robustnessWeights[k] * weights[k];
                final double xkw = xk * w;
                sumWeights += w;
                sumX += xkw;
                sumXSquared += xk * xkw;
                sumY += yk * w;
                sumXY += yk * xkw;
            }

            final double meanX = sumX / sumWeights;
            final double meanY = sumY / sumWeights;
            final double meanXY = sumXY / sumWeights;
            final double meanXSquared = sumXSquared / sumWeights;

            final double beta;
            if (FastMath.sqrt(FastMath.abs(meanXSquared - meanX * meanX)) < accuracy) {
                beta = 0;
            } else {
                beta = (meanXY - meanX * meanY) / (meanXSquared - meanX * meanX);
            }

            final double alpha = meanY - beta * meanX;

            res[i] = beta * x + alpha;
            residuals[i] = FastMath.abs(yval[i] - res[i]);
        }

        // No need to recompute the robustness weights at the last
        // iteration, they won't be needed anymore
        if (iter == robustnessIters) {
            break;
        }

        // Recompute the robustness weights.

        // Find the median residual.
        // An arraycopy and a sort are completely tractable here,
        // because the preceding loop is a lot more expensive
        System.arraycopy(residuals, 0, sortedResiduals, 0, n);
        Arrays.sort(sortedResiduals);
        final double medianResidual = sortedResiduals[n / 2];

        if (FastMath.abs(medianResidual) < accuracy) {
            break;
        }

        for (int i = 0; i < n; ++i) {
            final double arg = residuals[i] / (6 * medianResidual);
            if (arg >= 1) {
                robustnessWeights[i] = 0;
            } else {
                final double w = 1 - arg * arg;
                robustnessWeights[i] = w * w;
            }
        }
    }

    return res;
}

From source file:embedded2.ESecure.TTest.java

/**
 * Check sample data.//from  w  w  w  . j ava2 s  .c  o  m
 *
 * @param data Sample data.
 * @throws NullArgumentException if {@code data} is {@code null}.
 * @throws NumberIsTooSmallException if there is not enough sample data.
 */
private static void checkSampleData(final double[] data)
        throws NullArgumentException, NumberIsTooSmallException {

    if (data == null) {
        throw new NullArgumentException();
    }
    if (data.length < 2) {
        throw new NumberIsTooSmallException(LocalizedFormats.INSUFFICIENT_DATA_FOR_T_STATISTIC, data.length, 2,
                true);
    }

}

From source file:embedded2.ESecure.TTest.java

/**
 * Check sample data./*from   ww w.  j av a 2 s  .com*/
 *
 * @param stat Statistical summary.
 * @throws NullArgumentException if {@code data} is {@code null}.
 * @throws NumberIsTooSmallException if there is not enough sample data.
 */
private static void checkSampleData(final StatisticalSummary stat)
        throws NullArgumentException, NumberIsTooSmallException {

    if (stat == null) {
        throw new NullArgumentException();
    }
    if (stat.getN() < 2) {
        throw new NumberIsTooSmallException(LocalizedFormats.INSUFFICIENT_DATA_FOR_T_STATISTIC, stat.getN(), 2,
                true);
    }

}

From source file:org.pmad.gmm.MyMixMNDEM.java

/**
 * Creates an object to fit a multivariate normal mixture model to data.
 *
 * @param data Data to use in fitting procedure
 * @throws NotStrictlyPositiveException if data has no rows
 * @throws DimensionMismatchException if rows of data have different numbers
 *             of columns//from  ww  w. ja  v  a2 s .c  o m
 * @throws NumberIsTooSmallException if the number of columns in the data is
 *             less than 2
 */
public MyMixMNDEM(double[][] data)
        throws NotStrictlyPositiveException, DimensionMismatchException, NumberIsTooSmallException {
    if (data.length < 1) {
        throw new NotStrictlyPositiveException(data.length);
    }

    this.data = new double[data.length][data[0].length];

    for (int i = 0; i < data.length; i++) {
        if (data[i].length != data[0].length) {
            // Jagged arrays not allowed
            throw new DimensionMismatchException(data[i].length, data[0].length);
        }
        if (data[i].length < 2) {
            throw new NumberIsTooSmallException(LocalizedFormats.NUMBER_TOO_SMALL, data[i].length, 2, true);
        }
        this.data[i] = MathArrays.copyOf(data[i], data[i].length);
    }
}

From source file:statalign.utils.BetaDistribution.java

/** {@inheritDoc} */
@Override/*from   w w  w. j a v a  2s  .  co  m*/
public double density(double x) {
    recomputeZ();
    if (x < 0 || x > 1) {
        return 0;
    } else if (x == 0) {
        if (alpha < 1) {
            throw new NumberIsTooSmallException(
                    LocalizedFormats.CANNOT_COMPUTE_BETA_DENSITY_AT_0_FOR_SOME_ALPHA, alpha, 1, false);
        }
        return 0;
    } else if (x == 1) {
        if (beta < 1) {
            throw new NumberIsTooSmallException(LocalizedFormats.CANNOT_COMPUTE_BETA_DENSITY_AT_1_FOR_SOME_BETA,
                    beta, 1, false);
        }
        return 0;
    } else {
        double logX = FastMath.log(x);
        double log1mX = FastMath.log1p(-x);
        return FastMath.exp((alpha - 1) * logX + (beta - 1) * log1mX - z);
    }
}