@Test(expectedExceptions = IllegalArgumentException.class) public void linearFuncDiffTwiceMultiTest() { double[] xValues = new double[] {1, 2, 3, 4}; DoubleMatrix2D coefsMatrix = new DoubleMatrix2D( new double[][] {{1., -3.}, {0., 5.}, {1., 0.}, {0., 5.}, {1., 3.}, {0., 5.}}); double[] xKeys = new double[] {-2, 1, 2, 2.5}; final int dim = 2; final int nCoefs = 2; PiecewisePolynomialResult pp = new PiecewisePolynomialResult(new DoubleMatrix1D(xValues), coefsMatrix, nCoefs, dim); PiecewisePolynomialFunction1D function = new PiecewisePolynomialFunction1D(); function.differentiateTwice(pp, xKeys); }
/** Sample function is f(x) = (x-1)^4 */ @Test public void GeneralIntegrateDifferentiateTest() { final double[] knots = new double[] {1., 2., 3., 4}; final double[][] coefMat = new double[][] {{1., 0., 0., 0., 0.}, {1., 4., 6., 4., 1.}, {1., 8., 24., 32., 16.}}; final double[] xKeys = new double[] {-2, 1, 2.5, 4.}; final double[] initials = new double[] {1., 2.5, 23. / 7., 7.}; final int nKeys = xKeys.length; final int nInit = initials.length; final double[][] integrateExp = new double[nInit][nKeys]; for (int i = 0; i < nInit; ++i) { for (int j = 0; j < nKeys; ++j) { integrateExp[i][j] = Math.pow(xKeys[j] - 1., 5.) / 5. - Math.pow(initials[i] - 1., 5.) / 5.; } } final double[] differentiateExp = new double[] {-108., 0., 27. / 2., 108.}; final double[] differentiateTwiceExp = new double[nKeys]; for (int i = 0; i < nKeys; ++i) { differentiateTwiceExp[i] = 12. * (xKeys[i] - 1.) * (xKeys[i] - 1.); } PiecewisePolynomialFunction1D function = new PiecewisePolynomialFunction1D(); PiecewisePolynomialResult result = new PiecewisePolynomialResult(new DoubleMatrix1D(knots), new DoubleMatrix2D(coefMat), 5, 1); final double[] differentiate = function.differentiate(result, xKeys).getData()[0]; final double[] differentiateTwice = function.differentiateTwice(result, xKeys).getData()[0]; final double[][] integrate = new double[nInit][nKeys]; for (int i = 0; i < nInit; ++i) { for (int j = 0; j < nKeys; ++j) { integrate[i][j] = function.integrate(result, initials[i], xKeys).getData()[j]; } } for (int i = 0; i < nKeys; ++i) { final double ref = differentiateExp[i] == 0. ? 1. : Math.abs(differentiateExp[i]); assertEquals(differentiate[i], differentiateExp[i], ref * EPS); } for (int i = 0; i < nKeys; ++i) { final double ref = differentiateTwiceExp[i] == 0. ? 1. : Math.abs(differentiateTwiceExp[i]); assertEquals(differentiateTwice[i], differentiateTwiceExp[i], ref * EPS); } for (int j = 0; j < nInit; ++j) { for (int i = 0; i < nKeys; ++i) { final double ref = integrateExp[j][i] == 0. ? 1. : Math.abs(integrateExp[j][i]); assertEquals(integrate[j][i], integrateExp[j][i], ref * EPS); } } { final double ref = differentiateExp[0] == 0. ? 1. : Math.abs(differentiateExp[0]); assertEquals( function.differentiate(result, xKeys[0]).getData()[0], differentiateExp[0], ref * EPS); } { final double ref = differentiateExp[3] == 0. ? 1. : Math.abs(differentiateExp[3]); assertEquals( function.differentiate(result, xKeys[3]).getData()[0], differentiateExp[3], ref * EPS); } { final double ref = differentiateTwiceExp[0] == 0. ? 1. : Math.abs(differentiateTwiceExp[0]); assertEquals( function.differentiateTwice(result, xKeys[0]).getData()[0], differentiateTwiceExp[0], ref * EPS); } { final double ref = differentiateTwiceExp[3] == 0. ? 1. : Math.abs(differentiateTwiceExp[3]); assertEquals( function.differentiateTwice(result, xKeys[3]).getData()[0], differentiateTwiceExp[3], ref * EPS); } { final double ref = integrateExp[0][0] == 0. ? 1. : Math.abs(integrateExp[0][0]); assertEquals( function.integrate(result, initials[0], xKeys[0]), integrateExp[0][0], ref * EPS); } { final double ref = integrateExp[0][3] == 0. ? 1. : Math.abs(integrateExp[0][3]); assertEquals( function.integrate(result, initials[0], xKeys[3]), integrateExp[0][3], ref * EPS); } { final double ref = integrateExp[3][0] == 0. ? 1. : Math.abs(integrateExp[3][0]); assertEquals( function.integrate(result, initials[3], xKeys[0]), integrateExp[3][0], ref * EPS); } { final double ref = integrateExp[1][0] == 0. ? 1. : Math.abs(integrateExp[1][0]); assertEquals( function.integrate(result, initials[1], xKeys[0]), integrateExp[1][0], ref * EPS); } }
@Override public PiecewisePolynomialResult interpolate(final double[] xValues, final double[] yValues) { ArgumentChecker.notNull(xValues, "xValues"); ArgumentChecker.notNull(yValues, "yValues"); ArgumentChecker.isTrue( xValues.length == yValues.length | xValues.length + 2 == yValues.length, "(xValues length = yValues length) or (xValues length + 2 = yValues length)"); ArgumentChecker.isTrue(xValues.length > 2, "Data points should be more than 2"); final int nDataPts = xValues.length; final int yValuesLen = yValues.length; for (int i = 0; i < nDataPts; ++i) { ArgumentChecker.isFalse(Double.isNaN(xValues[i]), "xValues containing NaN"); ArgumentChecker.isFalse(Double.isInfinite(xValues[i]), "xValues containing Infinity"); } for (int i = 0; i < yValuesLen; ++i) { ArgumentChecker.isFalse(Double.isNaN(yValues[i]), "yValues containing NaN"); ArgumentChecker.isFalse(Double.isInfinite(yValues[i]), "yValues containing Infinity"); } for (int i = 0; i < nDataPts - 1; ++i) { for (int j = i + 1; j < nDataPts; ++j) { ArgumentChecker.isFalse(xValues[i] == xValues[j], "xValues should be distinct"); } } double[] xValuesSrt = Arrays.copyOf(xValues, nDataPts); double[] yValuesSrt = new double[nDataPts]; if (nDataPts == yValuesLen) { yValuesSrt = Arrays.copyOf(yValues, nDataPts); } else { yValuesSrt = Arrays.copyOfRange(yValues, 1, nDataPts + 1); } ParallelArrayBinarySort.parallelBinarySort(xValuesSrt, yValuesSrt); final double[] intervals = _solver.intervalsCalculator(xValuesSrt); final double[] slopes = _solver.slopesCalculator(yValuesSrt, intervals); final PiecewisePolynomialResult result = _method.interpolate(xValues, yValues); ArgumentChecker.isTrue(result.getOrder() >= 3, "Primary interpolant should be degree >= 2"); final double[] initialFirst = _function.differentiate(result, xValuesSrt).getData()[0]; final double[] initialSecond = _function.differentiateTwice(result, xValuesSrt).getData()[0]; double[] first = firstDerivativeCalculator(yValuesSrt, intervals, slopes, initialFirst); boolean modFirst = false; int k; double[] aValues = aValuesCalculator(slopes, first); double[] bValues = bValuesCalculator(slopes, first); double[][] intervalsA = getIntervalsA(intervals, slopes, first, bValues); double[][] intervalsB = getIntervalsB(intervals, slopes, first, aValues); while (modFirst == false) { k = 0; for (int i = 0; i < nDataPts - 2; ++i) { if (first[i + 1] > 0.) { if (intervalsA[i + 1][1] + Math.abs(intervalsA[i + 1][1]) * ERROR < intervalsB[i][0] - Math.abs(intervalsB[i][0]) * ERROR | intervalsA[i + 1][0] - Math.abs(intervalsA[i + 1][0]) * ERROR > intervalsB[i][1] + Math.abs(intervalsB[i][1]) * ERROR) { ++k; first[i + 1] = firstDerivativesRecalculator(intervals, slopes, aValues, bValues, i + 1); } } } if (k == 0) { modFirst = true; } aValues = aValuesCalculator(slopes, first); bValues = bValuesCalculator(slopes, first); intervalsA = getIntervalsA(intervals, slopes, first, bValues); intervalsB = getIntervalsB(intervals, slopes, first, aValues); } final double[] second = secondDerivativeCalculator(initialSecond, intervalsA, intervalsB); final double[][] coefs = _solver.solve(yValuesSrt, intervals, slopes, first, second); for (int i = 0; i < nDataPts - 1; ++i) { for (int j = 0; j < 6; ++j) { ArgumentChecker.isFalse(Double.isNaN(coefs[i][j]), "Too large input"); ArgumentChecker.isFalse(Double.isInfinite(coefs[i][j]), "Too large input"); } } return new PiecewisePolynomialResult( new DoubleMatrix1D(xValuesSrt), new DoubleMatrix2D(coefs), 6, 1); }
@Test public void quadraticAllTest() { final double[] knots = new double[] {1., 3.}; final DoubleMatrix2D coefsMatrix = new DoubleMatrix2D(new double[][] {{-1., 2., 1.}}); final double[] xKeys = new double[] {-2, 1, 2.5, 4.}; final double[] initials = new double[] {-0.5, 1., 2.5, 5.}; final int nKeys = xKeys.length; final int nInit = initials.length; final double[] valuesExp = new double[] {-14., 1., 7. / 4., -2.}; final double[][] integrateExp = new double[nInit][nKeys]; for (int i = 0; i < nInit; ++i) { for (int j = 0; j < nKeys; ++j) { integrateExp[i][j] = -1. / 3. * (xKeys[j] - initials[i]) * (xKeys[j] * xKeys[j] + initials[i] * initials[i] - 6. * xKeys[j] - 6. * initials[i] + 6. + initials[i] * xKeys[j]); } } final double[] differentiateExp = new double[nKeys]; for (int j = 0; j < nKeys; ++j) { differentiateExp[j] = -2. * (xKeys[j] - 1) + 2.; } final double[] differentiateTwiceExp = new double[nKeys]; for (int j = 0; j < nKeys; ++j) { differentiateTwiceExp[j] = -2.; } PiecewisePolynomialResult result = new PiecewisePolynomialResult(new DoubleMatrix1D(knots), coefsMatrix, 3, 1); PiecewisePolynomialFunction1D function = new PiecewisePolynomialFunction1D(); final double[] values = function.evaluate(result, xKeys).getData()[0]; final double[] differentiate = function.differentiate(result, xKeys).getData()[0]; final double[] differentiateTwice = function.differentiateTwice(result, xKeys).getData()[0]; final double[][] integrate = new double[nInit][nKeys]; for (int i = 0; i < nInit; ++i) { for (int j = 0; j < nKeys; ++j) { integrate[i][j] = function.integrate(result, initials[i], xKeys).getData()[j]; } } for (int i = 0; i < nKeys; ++i) { final double ref = valuesExp[i] == 0. ? 1. : Math.abs(valuesExp[i]); assertEquals(values[i], valuesExp[i], ref * EPS); } for (int i = 0; i < nKeys; ++i) { final double ref = differentiateExp[i] == 0. ? 1. : Math.abs(differentiateExp[i]); assertEquals(differentiate[i], differentiateExp[i], ref * EPS); } for (int i = 0; i < nKeys; ++i) { final double ref = differentiateTwiceExp[i] == 0. ? 1. : Math.abs(differentiateTwiceExp[i]); assertEquals(differentiateTwice[i], differentiateTwiceExp[i], ref * EPS); } { final double ref = differentiateTwiceExp[1] == 0. ? 1. : Math.abs(differentiateTwiceExp[1]); assertEquals(differentiateTwice[1], differentiateTwiceExp[1], ref * EPS); } for (int j = 0; j < nInit; ++j) { for (int i = 0; i < nKeys; ++i) { final double ref = integrateExp[j][i] == 0. ? 1. : Math.abs(integrateExp[j][i]); assertEquals(integrate[j][i], integrateExp[j][i], ref * EPS); } } }
@Override public PiecewisePolynomialResultsWithSensitivity interpolateWithSensitivity( final double[] xValues, final double[] yValues) { ArgumentChecker.notNull(xValues, "xValues"); ArgumentChecker.notNull(yValues, "yValues"); ArgumentChecker.isTrue( xValues.length == yValues.length | xValues.length + 2 == yValues.length, "(xValues length = yValues length) or (xValues length + 2 = yValues length)"); ArgumentChecker.isTrue(xValues.length > 2, "Data points should be more than 2"); final int nDataPts = xValues.length; final int yValuesLen = yValues.length; for (int i = 0; i < nDataPts; ++i) { ArgumentChecker.isFalse(Double.isNaN(xValues[i]), "xValues containing NaN"); ArgumentChecker.isFalse(Double.isInfinite(xValues[i]), "xValues containing Infinity"); } for (int i = 0; i < yValuesLen; ++i) { ArgumentChecker.isFalse(Double.isNaN(yValues[i]), "yValues containing NaN"); ArgumentChecker.isFalse(Double.isInfinite(yValues[i]), "yValues containing Infinity"); } for (int i = 0; i < nDataPts - 1; ++i) { for (int j = i + 1; j < nDataPts; ++j) { ArgumentChecker.isFalse(xValues[i] == xValues[j], "xValues should be distinct"); } } double[] yValuesSrt = new double[nDataPts]; if (nDataPts == yValuesLen) { yValuesSrt = Arrays.copyOf(yValues, nDataPts); } else { yValuesSrt = Arrays.copyOfRange(yValues, 1, nDataPts + 1); } final double[] intervals = _solver.intervalsCalculator(xValues); final double[] slopes = _solver.slopesCalculator(yValuesSrt, intervals); double[][] slopesSensitivity = _solver.slopeSensitivityCalculator(intervals); final DoubleMatrix1D[] firstWithSensitivity = new DoubleMatrix1D[nDataPts + 1]; final DoubleMatrix1D[] secondWithSensitivity = new DoubleMatrix1D[nDataPts + 1]; final PiecewisePolynomialResult result = _method.interpolate(xValues, yValues); ArgumentChecker.isTrue(result.getOrder() >= 3, "Primary interpolant should be degree >= 2"); final double[] initialFirst = _function.differentiate(result, xValues).getData()[0]; final double[] initialSecond = _function.differentiateTwice(result, xValues).getData()[0]; double[] first = firstDerivativeCalculator(yValuesSrt, intervals, slopes, initialFirst); boolean modFirst = false; int k; double[] aValues = aValuesCalculator(slopes, first); double[] bValues = bValuesCalculator(slopes, first); double[][] intervalsA = getIntervalsA(intervals, slopes, first, bValues); double[][] intervalsB = getIntervalsB(intervals, slopes, first, aValues); while (modFirst == false) { k = 0; for (int i = 0; i < nDataPts - 2; ++i) { if (first[i + 1] > 0.) { if (intervalsA[i + 1][1] + Math.abs(intervalsA[i + 1][1]) * ERROR < intervalsB[i][0] - Math.abs(intervalsB[i][0]) * ERROR | intervalsA[i + 1][0] - Math.abs(intervalsA[i + 1][0]) * ERROR > intervalsB[i][1] + Math.abs(intervalsB[i][1]) * ERROR) { ++k; first[i + 1] = firstDerivativesRecalculator(intervals, slopes, aValues, bValues, i + 1); } } } if (k == 0) { modFirst = true; } aValues = aValuesCalculator(slopes, first); bValues = bValuesCalculator(slopes, first); intervalsA = getIntervalsA(intervals, slopes, first, bValues); intervalsB = getIntervalsB(intervals, slopes, first, aValues); } final double[] second = secondDerivativeCalculator(initialSecond, intervalsA, intervalsB); firstWithSensitivity[0] = new DoubleMatrix1D(first); secondWithSensitivity[0] = new DoubleMatrix1D(second); /* * Centered finite difference method is used for computing node sensitivity */ int nExtra = (nDataPts == yValuesLen) ? 0 : 1; final double[] yValuesUp = Arrays.copyOf(yValues, nDataPts + 2 * nExtra); final double[] yValuesDw = Arrays.copyOf(yValues, nDataPts + 2 * nExtra); final double[][] tmpFirst = new double[nDataPts][nDataPts]; final double[][] tmpSecond = new double[nDataPts][nDataPts]; for (int l = nExtra; l < nDataPts + nExtra; ++l) { final double den = Math.abs(yValues[l]) < SMALL ? EPS : yValues[l] * EPS; yValuesUp[l] = Math.abs(yValues[l]) < SMALL ? EPS : yValues[l] * (1. + EPS); yValuesDw[l] = Math.abs(yValues[l]) < SMALL ? -EPS : yValues[l] * (1. - EPS); final double[] yValuesSrtUp = Arrays.copyOfRange(yValuesUp, nExtra, nDataPts + nExtra); final double[] yValuesSrtDw = Arrays.copyOfRange(yValuesDw, nExtra, nDataPts + nExtra); final DoubleMatrix1D[] yValuesUpDw = new DoubleMatrix1D[] {new DoubleMatrix1D(yValuesUp), new DoubleMatrix1D(yValuesDw)}; final DoubleMatrix1D[] yValuesSrtUpDw = new DoubleMatrix1D[] {new DoubleMatrix1D(yValuesSrtUp), new DoubleMatrix1D(yValuesSrtDw)}; final DoubleMatrix1D[] firstSecondUpDw = new DoubleMatrix1D[4]; for (int ii = 0; ii < 2; ++ii) { final double[] slopesUpDw = _solver.slopesCalculator(yValuesSrtUpDw[ii].getData(), intervals); final PiecewisePolynomialResult resultUpDw = _method.interpolate(xValues, yValuesUpDw[ii].getData()); final double[] initialFirstUpDw = _function.differentiate(resultUpDw, xValues).getData()[0]; final double[] initialSecondUpDw = _function.differentiateTwice(resultUpDw, xValues).getData()[0]; double[] firstUpDw = firstDerivativeCalculator( yValuesSrtUpDw[ii].getData(), intervals, slopesUpDw, initialFirstUpDw); boolean modFirstUpDw = false; double[] aValuesUpDw = aValuesCalculator(slopesUpDw, firstUpDw); double[] bValuesUpDw = bValuesCalculator(slopesUpDw, firstUpDw); double[][] intervalsAUpDw = getIntervalsA(intervals, slopesUpDw, firstUpDw, bValuesUpDw); double[][] intervalsBUpDw = getIntervalsB(intervals, slopesUpDw, firstUpDw, aValuesUpDw); while (modFirstUpDw == false) { k = 0; for (int i = 0; i < nDataPts - 2; ++i) { if (firstUpDw[i + 1] > 0.) { if (intervalsAUpDw[i + 1][1] + Math.abs(intervalsAUpDw[i + 1][1]) * ERROR < intervalsBUpDw[i][0] - Math.abs(intervalsBUpDw[i][0]) * ERROR | intervalsAUpDw[i + 1][0] - Math.abs(intervalsAUpDw[i + 1][0]) * ERROR > intervalsBUpDw[i][1] + Math.abs(intervalsBUpDw[i][1]) * ERROR) { ++k; firstUpDw[i + 1] = firstDerivativesRecalculator( intervals, slopesUpDw, aValuesUpDw, bValuesUpDw, i + 1); } } } if (k == 0) { modFirstUpDw = true; } aValuesUpDw = aValuesCalculator(slopesUpDw, firstUpDw); bValuesUpDw = bValuesCalculator(slopesUpDw, firstUpDw); intervalsAUpDw = getIntervalsA(intervals, slopesUpDw, firstUpDw, bValuesUpDw); intervalsBUpDw = getIntervalsB(intervals, slopesUpDw, firstUpDw, aValuesUpDw); } final double[] secondUpDw = secondDerivativeCalculator(initialSecondUpDw, intervalsAUpDw, intervalsBUpDw); firstSecondUpDw[ii] = new DoubleMatrix1D(firstUpDw); firstSecondUpDw[2 + ii] = new DoubleMatrix1D(secondUpDw); } for (int j = 0; j < nDataPts; ++j) { tmpFirst[j][l - nExtra] = 0.5 * (firstSecondUpDw[0].getData()[j] - firstSecondUpDw[1].getData()[j]) / den; tmpSecond[j][l - nExtra] = 0.5 * (firstSecondUpDw[2].getData()[j] - firstSecondUpDw[3].getData()[j]) / den; } yValuesUp[l] = yValues[l]; yValuesDw[l] = yValues[l]; } for (int i = 0; i < nDataPts; ++i) { firstWithSensitivity[i + 1] = new DoubleMatrix1D(tmpFirst[i]); secondWithSensitivity[i + 1] = new DoubleMatrix1D(tmpSecond[i]); } final DoubleMatrix2D[] resMatrix = _solver.solveWithSensitivity( yValuesSrt, intervals, slopes, slopesSensitivity, firstWithSensitivity, secondWithSensitivity); for (int l = 0; l < nDataPts; ++l) { DoubleMatrix2D m = resMatrix[l]; final int rows = m.getNumberOfRows(); final int cols = m.getNumberOfColumns(); for (int i = 0; i < rows; ++i) { for (int j = 0; j < cols; ++j) { ArgumentChecker.isTrue( Doubles.isFinite(m.getEntry(i, j)), "Matrix contains a NaN or infinite"); } } } final DoubleMatrix2D coefMatrix = resMatrix[0]; final DoubleMatrix2D[] coefSenseMatrix = new DoubleMatrix2D[nDataPts - 1]; System.arraycopy(resMatrix, 1, coefSenseMatrix, 0, nDataPts - 1); final int nCoefs = coefMatrix.getNumberOfColumns(); return new PiecewisePolynomialResultsWithSensitivity( new DoubleMatrix1D(xValues), coefMatrix, nCoefs, 1, coefSenseMatrix); }