List of usage examples for org.apache.commons.math3.exception DimensionMismatchException DimensionMismatchException
public DimensionMismatchException(int wrong, int expected)
From source file:com.clust4j.utils.MatUtils.java
final static public void checkDimsForUniformity(final double[][] a, final double[][] b) { checkDimsForUniformity(a);/* w w w. j ava 2 s. co m*/ checkDimsForUniformity(b); if (a.length != b.length) throw new DimensionMismatchException(a.length, b.length); if (a[0].length != b[0].length) throw new DimensionMismatchException(a[0].length, b[0].length); }
From source file:com.clust4j.metrics.scoring.SupervisedMetric.java
private static void checkDims(int[] a, int[] b) { if (a.length != b.length) // Allow empty; so we don't use VecUtils throw new DimensionMismatchException(a.length, b.length); }
From source file:au.gov.ga.conn4d.utils.BicubicSplineInterpolatingFunction.java
/** * @param x Sample values of the x-coordinate, in increasing order. * @param y Sample values of the y-coordinate, in increasing order. * @param f Values of the function on every grid point. * @param dFdX Values of the partial derivative of function with respect * to x on every grid point.//from ww w . j a va2 s .c o m * @param dFdY Values of the partial derivative of function with respect * to y on every grid point. * @param d2FdXdY Values of the cross partial derivative of function on * every grid point. * @throws DimensionMismatchException if the various arrays do not contain * the expected number of elements. * @throws NonMonotonicSequenceException if {@code x} or {@code y} are * not strictly increasing. * @throws NoDataException if any of the arrays has zero length. */ public BicubicSplineInterpolatingFunction(double[] x, double[] y, double[][] f, double[][] dFdX, double[][] dFdY, double[][] d2FdXdY) throws DimensionMismatchException, NoDataException, NonMonotonicSequenceException { final int xLen = x.length; final int yLen = y.length; if (xLen == 0 || yLen == 0 || f.length == 0 || f[0].length == 0) { throw new NoDataException(); } if (xLen != f.length) { throw new DimensionMismatchException(xLen, f.length); } if (xLen != dFdX.length) { throw new DimensionMismatchException(xLen, dFdX.length); } if (xLen != dFdY.length) { throw new DimensionMismatchException(xLen, dFdY.length); } if (xLen != d2FdXdY.length) { throw new DimensionMismatchException(xLen, d2FdXdY.length); } MathArrays.checkOrder(x); MathArrays.checkOrder(y); xval = x.clone(); yval = y.clone(); final int lastI = xLen - 1; final int lastJ = yLen - 1; splines = new BicubicSplineFunction[lastI][lastJ]; for (int i = 0; i < lastI; i++) { if (f[i].length != yLen) { throw new DimensionMismatchException(f[i].length, yLen); } if (dFdX[i].length != yLen) { throw new DimensionMismatchException(dFdX[i].length, yLen); } if (dFdY[i].length != yLen) { throw new DimensionMismatchException(dFdY[i].length, yLen); } if (d2FdXdY[i].length != yLen) { throw new DimensionMismatchException(d2FdXdY[i].length, yLen); } final int ip1 = i + 1; for (int j = 0; j < lastJ; j++) { final int jp1 = j + 1; final double[] beta = new double[] { f[i][j], f[ip1][j], f[i][jp1], f[ip1][jp1], dFdX[i][j], dFdX[ip1][j], dFdX[i][jp1], dFdX[ip1][jp1], dFdY[i][j], dFdY[ip1][j], dFdY[i][jp1], dFdY[ip1][jp1], d2FdXdY[i][j], d2FdXdY[ip1][j], d2FdXdY[i][jp1], d2FdXdY[ip1][jp1] }; splines[i][j] = new BicubicSplineFunction(computeSplineCoefficients(beta)); } } }
From source file:au.gov.ga.conn4d.utils.TricubicSplineInterpolator.java
public TricubicSplineInterpolatingFunction interpolate(final double[] zval, final double[] yval, final double[] xval, final float[][][] fval) throws NoDataException, DimensionMismatchException, NonMonotonicSequenceException { if (zval.length == 0 || yval.length == 0 || xval.length == 0 || fval.length == 0) { throw new NoDataException(); }// ww w . j a v a 2 s. com if (zval.length != fval.length) { throw new DimensionMismatchException(zval.length, fval.length); } MathArrays.checkOrder(yval); MathArrays.checkOrder(xval); final int zLen = zval.length; final int yLen = yval.length; final int xLen = xval.length; final double[] zzval; float[][][] ffval = new float[zLen][][]; if (zval[0] > zval[zLen - 1]) { zzval = VectorMath.selectionSort(zval); for (int i = 0; i < zLen; i++) { ffval[i] = fval[zLen - 1 - i]; } } else { zzval = zval; ffval = fval; } // Samples, re-ordered as (z, x, y) and (y, z, x) tuplets // fvalXY[k][i][j] = f(xval[i], yval[j], zval[k]) // fvalZX[j][k][i] = f(xval[i], yval[j], zval[k]) final double[][][] fvalXY = new double[xLen][zLen][yLen]; final double[][][] fvalZX = new double[yLen][xLen][zLen]; for (int i = 0; i < zLen; i++) { if (ffval[i].length != yLen) { throw new DimensionMismatchException(ffval[i].length, yLen); } for (int j = 0; j < yLen; j++) { if (ffval[i][j].length != xLen) { throw new DimensionMismatchException(ffval[i][j].length, xLen); } for (int k = 0; k < xLen; k++) { final double v = ffval[i][j][k]; fvalXY[k][i][j] = v; fvalZX[j][k][i] = v; } } } final BicubicSplineInterpolator bsi = new BicubicSplineInterpolator(); // For each line x[i] (0 <= i < xLen), construct a 2D spline in y and z final BicubicSplineInterpolatingFunction[] xSplineYZ = new BicubicSplineInterpolatingFunction[zLen]; for (int i = 0; i < zLen; i++) { xSplineYZ[i] = bsi.interpolate(yval, xval, ffval[i]); } // For each line y[j] (0 <= j < yLen), construct a 2D spline in z and x final BicubicSplineInterpolatingFunction[] ySplineZX = new BicubicSplineInterpolatingFunction[yLen]; for (int j = 0; j < yLen; j++) { ySplineZX[j] = bsi.interpolate(xval, zzval, fvalZX[j]); } // For each line z[k] (0 <= k < zLen), construct a 2D spline in x and y final BicubicSplineInterpolatingFunction[] zSplineXY = new BicubicSplineInterpolatingFunction[xLen]; for (int k = 0; k < xLen; k++) { zSplineXY[k] = bsi.interpolate(zzval, yval, fvalXY[k]); } // Partial derivatives wrt x and wrt y final double[][][] dFdX = new double[zLen][yLen][xLen]; final double[][][] dFdY = new double[zLen][yLen][xLen]; final double[][][] d2FdXdY = new double[zLen][yLen][xLen]; for (int k = 0; k < xLen; k++) { final BicubicSplineInterpolatingFunction f = zSplineXY[k]; for (int i = 0; i < zLen; i++) { final double x = zzval[i]; for (int j = 0; j < yLen; j++) { final double y = yval[j]; dFdX[i][j][k] = f.partialDerivativeX(x, y); dFdY[i][j][k] = f.partialDerivativeY(x, y); d2FdXdY[i][j][k] = f.partialDerivativeXY(x, y); } } } // Partial derivatives wrt y and wrt z final double[][][] dFdZ = new double[zLen][yLen][xLen]; final double[][][] d2FdYdZ = new double[zLen][yLen][xLen]; for (int i = 0; i < zLen; i++) { final BicubicSplineInterpolatingFunction f = xSplineYZ[i]; for (int j = 0; j < yLen; j++) { final double y = yval[j]; for (int k = 0; k < xLen; k++) { final double z = xval[k]; dFdZ[i][j][k] = f.partialDerivativeY(y, z); d2FdYdZ[i][j][k] = f.partialDerivativeXY(y, z); } } } // Partial derivatives wrt x and wrt z final double[][][] d2FdZdX = new double[zLen][yLen][xLen]; for (int j = 0; j < yLen; j++) { final BicubicSplineInterpolatingFunction f = ySplineZX[j]; for (int k = 0; k < xLen; k++) { final double z = xval[k]; for (int i = 0; i < zLen; i++) { final double x = zzval[i]; d2FdZdX[i][j][k] = f.partialDerivativeXY(z, x); } } } // Third partial cross-derivatives final double[][][] d3FdXdYdZ = new double[zLen][yLen][xLen]; for (int i = 0; i < zLen; i++) { final int nI = nextIndex(i, zLen); final int pI = previousIndex(i); for (int j = 0; j < yLen; j++) { final int nJ = nextIndex(j, yLen); final int pJ = previousIndex(j); for (int k = 0; k < xLen; k++) { final int nK = nextIndex(k, xLen); final int pK = previousIndex(k); // XXX Not sure about this formula d3FdXdYdZ[i][j][k] = (ffval[nI][nJ][nK] - ffval[nI][pJ][nK] - ffval[pI][nJ][nK] + ffval[pI][pJ][nK] - ffval[nI][nJ][pK] + ffval[nI][pJ][pK] + ffval[pI][nJ][pK] - ffval[pI][pJ][pK]) / ((zzval[nI] - zzval[pI]) * (yval[nJ] - yval[pJ]) * (xval[nK] - xval[pK])); } } } // Create the interpolating splines return new TricubicSplineInterpolatingFunction(zzval, yval, xval, ffval, dFdX, dFdY, dFdZ, d2FdXdY, d2FdZdX, d2FdYdZ, d3FdXdYdZ); }
From source file:com.clust4j.utils.MatUtils.java
final static public void checkDimsForUniformity(final int[][] a, final int[][] b) { checkDimsForUniformity(a);//from ww w .ja va 2s .c om checkDimsForUniformity(b); if (a.length != b.length) throw new DimensionMismatchException(a.length, b.length); if (a[0].length != b[0].length) throw new DimensionMismatchException(a[0].length, b[0].length); }
From source file:gedi.util.datastructure.collections.doublecollections.DoubleArrayList.java
public void parallelSort(DoubleArrayList other) { if (size() != other.size()) throw new DimensionMismatchException(size(), other.size()); ArrayUtils.parallelSort(this.doubleArray, other.doubleArray, 0, size()); }
From source file:com.clust4j.algo.DBSCAN.java
/** {@inheritDoc} */ @Override//from w ww.ja v a2 s .c o m public int[] predict(RealMatrix newData) { final int[] fit_labels = getLabels(); // propagates errors final int n = newData.getColumnDimension(); // Make sure matches dimensionally if (n != this.data.getColumnDimension()) throw new DimensionMismatchException(n, data.getColumnDimension()); // Fit a radius model RadiusNeighbors radiusModel = new RadiusNeighborsParameters(eps) // no scale necessary; may already have been done .setMetric(dist_metric).setSeed(getSeed()).fitNewModel(data); final int[] newLabels = new int[newData.getRowDimension()]; Neighborhood theHood = radiusModel.getNeighbors(newData); int[][] indices = theHood.getIndices(); int[] idx_row; for (int i = 0; i < indices.length; i++) { idx_row = indices[i]; int current_class = NOISE_CLASS; if (idx_row.length == 0) { /* * If there are no indices in this point's radius, * we can just avoid the next step and exit early */ } else { // otherwise, we know there is something in the radius--noise or other int j = 0; while (j < idx_row.length) { current_class = fit_labels[idx_row[j]]; /* * The indices are ordered ascendingly by dist. * Even if the closest point is a noise point, it * could be within a border point's radius, so we * need to keep going. */ if (NOISE_CLASS == current_class) { j++; } else { break; } } } newLabels[i] = current_class; } return newLabels; }
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 www . j av a2s .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:com.clust4j.utils.MatUtils.java
final static public void checkDimsForUniformity(final boolean[][] a, final boolean[][] b) { checkDimsForUniformity(a);//from www . j ava 2 s.c o m checkDimsForUniformity(b); if (a.length != b.length) throw new DimensionMismatchException(a.length, b.length); if (a[0].length != b[0].length) throw new DimensionMismatchException(a[0].length, b[0].length); }
From source file:com.clust4j.algo.AbstractCentroidClusterer.java
/** Internal method for computing candidate distances. Protected for testing only */ static double[][] eucDists(double[][] centers, double[][] X) { MatUtils.checkDimsForUniformity(X);// w ww .jav a 2s. c o m MatUtils.checkDimsForUniformity(centers); final int m = X.length, n = X[0].length; if (n != centers[0].length) throw new DimensionMismatchException(n, centers[0].length); int next = 0; final double[][] dists = new double[centers.length][m]; for (double[] d : centers) { for (int i = 0; i < m; i++) dists[next][i] = Distance.EUCLIDEAN.getPartialDistance(d, X[i]); next++; } return dists; }