//------------------------------------------------------------------------- private void testSensitivity(double[] xValues, double[] yValues, double[] keys, double delta) { PiecewisePolynomialWithSensitivityFunction1D func = new PiecewisePolynomialWithSensitivityFunction1D(); PiecewisePolynomialResultsWithSensitivity resultSensi = INTERP.interpolateWithSensitivity(xValues, yValues); DoubleArray[] computedArray = func.nodeSensitivity(resultSensi, keys); for (int i = 0; i < keys.Length; ++i) { double @base = func.evaluate(resultSensi, keys[i]).get(0); DoubleArray computed = func.nodeSensitivity(resultSensi, keys[i]); assertEquals(computed, computedArray[i]); for (int j = 0; j < yValues.Length; ++j) { double[] yValuesBump = Arrays.copyOf(yValues, yValues.Length); yValuesBump[j] += delta; PiecewisePolynomialResult resultBump = INTERP.interpolate(xValues, yValuesBump); double expected = (func.evaluate(resultBump, keys[i]).get(0) - @base) / delta; assertEquals(computed.get(j), expected, delta); } } }
/// <summary> /// Left extrapolation by linear function unless extra node is added on the left /// </summary> private PiecewisePolynomialResult extrapolateByLinearFunction(PiecewisePolynomialResult result, double[] xValues) { int nIntervalsAll = result.NumberOfIntervals; double[] nodes = result.Knots.toArray(); if (Math.Abs(xValues[xValues.Length - 1] - nodes[nIntervalsAll]) < EPS) { double lastNodeX = nodes[nIntervalsAll]; double lastNodeY = FUNC.evaluate(result, lastNodeX).get(0); double extraNode = 2.0 * nodes[nIntervalsAll] - nodes[nIntervalsAll - 1]; double extraDerivative = FUNC.differentiate(result, lastNodeX).get(0); double[] newKnots = new double[nIntervalsAll + 2]; Array.Copy(nodes, 0, newKnots, 0, nIntervalsAll + 1); newKnots[nIntervalsAll + 1] = extraNode; // dummy node, outside the data range double[][] newCoefMatrix = new double[nIntervalsAll + 1][]; for (int i = 0; i < nIntervalsAll; ++i) { newCoefMatrix[i] = Arrays.copyOf(result.CoefMatrix.row(i).toArray(), result.Order); } newCoefMatrix[nIntervalsAll] = new double[result.Order]; newCoefMatrix[nIntervalsAll][result.Order - 1] = lastNodeY; newCoefMatrix[nIntervalsAll][result.Order - 2] = extraDerivative; if (result is PiecewisePolynomialResultsWithSensitivity) { PiecewisePolynomialResultsWithSensitivity resultCast = (PiecewisePolynomialResultsWithSensitivity)result; double[] extraSense = FUNC.nodeSensitivity(resultCast, lastNodeX).toArray(); double[] extraSenseDer = FUNC.differentiateNodeSensitivity(resultCast, lastNodeX).toArray(); DoubleMatrix[] newCoefSense = new DoubleMatrix[nIntervalsAll + 1]; for (int i = 0; i < nIntervalsAll; ++i) { newCoefSense[i] = resultCast.getCoefficientSensitivity(i); } //JAVA TO C# CONVERTER NOTE: The following call to the 'RectangularArrays' helper class reproduces the rectangular array initialization that is automatic in Java: //ORIGINAL LINE: double[][] extraCoefSense = new double[resultCast.Order][extraSense.Length]; double[][] extraCoefSense = RectangularArrays.ReturnRectangularDoubleArray(resultCast.Order, extraSense.Length); extraCoefSense[resultCast.Order - 1] = Arrays.copyOf(extraSense, extraSense.Length); extraCoefSense[resultCast.Order - 2] = Arrays.copyOf(extraSenseDer, extraSenseDer.Length); newCoefSense[nIntervalsAll] = DoubleMatrix.copyOf(extraCoefSense); return(new PiecewisePolynomialResultsWithSensitivity(DoubleArray.copyOf(newKnots), DoubleMatrix.copyOf(newCoefMatrix), resultCast.Order, 1, newCoefSense)); } return(new PiecewisePolynomialResult(DoubleArray.copyOf(newKnots), DoubleMatrix.copyOf(newCoefMatrix), result.Order, 1)); } return(result); }
public virtual void interpolationTest() { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int nExamples = Y.length; int nExamples = Y.Length; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int n = XX.length; int n = XX.Length; for (int example = 0; example < nExamples; example++) { PiecewisePolynomialResult pp = PCHIP_S.interpolateWithSensitivity(X, Y[example]); for (int i = 0; i < n; i++) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final double y = PPVAL_S.evaluate(pp, XX[i]).get(0); double y = PPVAL_S.evaluate(pp, XX[i]).get(0); assertEquals("example: " + example + ", index:" + i, YY[example][i], y, 1e-14); } } }
/// <summary> /// No clamped points added /// </summary> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void notClampedTest() public virtual void notClampedTest() { double[][] xValuesSet = new double[][] { new double[] { -5.0, -1.4, 3.2, 3.5, 7.6 }, new double[] { 1.0, 2.0, 4.5, 12.1, 14.2 }, new double[] { -5.2, -3.4, -3.2, -0.9, -0.2 } }; double[][] yValuesSet = new double[][] { new double[] { -2.2, 1.1, 1.9, 2.3, -0.1 }, new double[] { 3.4, 5.2, 4.3, 1.1, 0.2 }, new double[] { 1.4, 2.2, 4.1, 1.9, 0.99 } }; for (int k = 0; k < xValuesSet.Length; ++k) { double[] xValues = Arrays.copyOf(xValuesSet[k], xValuesSet[k].Length); double[] yValues = Arrays.copyOf(yValuesSet[k], yValuesSet[k].Length); int nData = xValues.Length; double[] xyValues = new double[nData]; for (int j = 0; j < nData; ++j) { xyValues[j] = xValues[j] * yValues[j]; } int nKeys = 100; double interval = (xValues[nData - 1] - xValues[0]) / (nKeys - 1.0); int n = INTERP.Length; for (int i = 0; i < n; ++i) { ProductPiecewisePolynomialInterpolator interp = new ProductPiecewisePolynomialInterpolator(INTERP[i]); for (int j = 0; j < nKeys; ++j) { double key = xValues[0] + interval * j; InterpolatorTestUtil.assertRelative("notClampedTest", INTERP[i].interpolate(xValues, xyValues, key), interp.interpolate(xValues, yValues, key), EPS); } } n = INTERP_SENSE.Length; for (int i = 0; i < n; ++i) { ProductPiecewisePolynomialInterpolator interp = new ProductPiecewisePolynomialInterpolator(INTERP_SENSE[i]); PiecewisePolynomialResultsWithSensitivity result = interp.interpolateWithSensitivity(xValues, yValues); PiecewisePolynomialResultsWithSensitivity resultBase = INTERP_SENSE[i].interpolateWithSensitivity(xValues, xyValues); for (int j = 0; j < nKeys; ++j) { double key = xValues[0] + interval * j; InterpolatorTestUtil.assertRelative("notClampedTest", FUNC.evaluate(resultBase, key).get(0), FUNC.evaluate(result, key).get(0), EPS); InterpolatorTestUtil.assertArrayRelative("notClampedTest", FUNC.nodeSensitivity(resultBase, key).toArray(), FUNC.nodeSensitivity(result, key).toArray(), EPS); } } } }