001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017 package org.apache.commons.math.analysis.interpolation;
018
019 import org.apache.commons.math.MathException;
020 import org.apache.commons.math.TestUtils;
021 import org.apache.commons.math.analysis.UnivariateRealFunction;
022 import org.apache.commons.math.analysis.polynomials.PolynomialFunction;
023 import org.apache.commons.math.analysis.polynomials.PolynomialSplineFunction;
024
025 import junit.framework.Test;
026 import junit.framework.TestCase;
027 import junit.framework.TestSuite;
028
029 /**
030 * Test the SplineInterpolator.
031 *
032 * @version $Revision: 799857 $ $Date: 2009-08-01 09:07:12 -0400 (Sat, 01 Aug 2009) $
033 */
034 public class SplineInterpolatorTest extends TestCase {
035
036 /** error tolerance for spline interpolator value at knot points */
037 protected double knotTolerance = 1E-12;
038
039 /** error tolerance for interpolating polynomial coefficients */
040 protected double coefficientTolerance = 1E-6;
041
042 /** error tolerance for interpolated values -- high value is from sin test */
043 protected double interpolationTolerance = 1E-2;
044
045 public SplineInterpolatorTest(String name) {
046 super(name);
047 }
048
049 public static Test suite() {
050 TestSuite suite = new TestSuite(SplineInterpolatorTest.class);
051 suite.setName("UnivariateRealInterpolator Tests");
052 return suite;
053 }
054
055 public void testInterpolateLinearDegenerateTwoSegment()
056 throws Exception {
057 double x[] = { 0.0, 0.5, 1.0 };
058 double y[] = { 0.0, 0.5, 1.0 };
059 UnivariateRealInterpolator i = new SplineInterpolator();
060 UnivariateRealFunction f = i.interpolate(x, y);
061 verifyInterpolation(f, x, y);
062 verifyConsistency((PolynomialSplineFunction) f, x);
063
064 // Verify coefficients using analytical values
065 PolynomialFunction polynomials[] = ((PolynomialSplineFunction) f).getPolynomials();
066 double target[] = {y[0], 1d};
067 TestUtils.assertEquals(polynomials[0].getCoefficients(), target, coefficientTolerance);
068 target = new double[]{y[1], 1d};
069 TestUtils.assertEquals(polynomials[1].getCoefficients(), target, coefficientTolerance);
070
071 // Check interpolation
072 assertEquals(0.0,f.value(0.0), interpolationTolerance);
073 assertEquals(0.4,f.value(0.4), interpolationTolerance);
074 assertEquals(1.0,f.value(1.0), interpolationTolerance);
075 }
076
077 public void testInterpolateLinearDegenerateThreeSegment()
078 throws Exception {
079 double x[] = { 0.0, 0.5, 1.0, 1.5 };
080 double y[] = { 0.0, 0.5, 1.0, 1.5 };
081 UnivariateRealInterpolator i = new SplineInterpolator();
082 UnivariateRealFunction f = i.interpolate(x, y);
083 verifyInterpolation(f, x, y);
084
085 // Verify coefficients using analytical values
086 PolynomialFunction polynomials[] = ((PolynomialSplineFunction) f).getPolynomials();
087 double target[] = {y[0], 1d};
088 TestUtils.assertEquals(polynomials[0].getCoefficients(), target, coefficientTolerance);
089 target = new double[]{y[1], 1d};
090 TestUtils.assertEquals(polynomials[1].getCoefficients(), target, coefficientTolerance);
091 target = new double[]{y[2], 1d};
092 TestUtils.assertEquals(polynomials[2].getCoefficients(), target, coefficientTolerance);
093
094 // Check interpolation
095 assertEquals(0,f.value(0), interpolationTolerance);
096 assertEquals(1.4,f.value(1.4), interpolationTolerance);
097 assertEquals(1.5,f.value(1.5), interpolationTolerance);
098 }
099
100 public void testInterpolateLinear() throws Exception {
101 double x[] = { 0.0, 0.5, 1.0 };
102 double y[] = { 0.0, 0.5, 0.0 };
103 UnivariateRealInterpolator i = new SplineInterpolator();
104 UnivariateRealFunction f = i.interpolate(x, y);
105 verifyInterpolation(f, x, y);
106 verifyConsistency((PolynomialSplineFunction) f, x);
107
108 // Verify coefficients using analytical values
109 PolynomialFunction polynomials[] = ((PolynomialSplineFunction) f).getPolynomials();
110 double target[] = {y[0], 1.5d, 0d, -2d};
111 TestUtils.assertEquals(polynomials[0].getCoefficients(), target, coefficientTolerance);
112 target = new double[]{y[1], 0d, -3d, 2d};
113 TestUtils.assertEquals(polynomials[1].getCoefficients(), target, coefficientTolerance);
114 }
115
116 public void testInterpolateSin() throws Exception {
117 double x[] =
118 {
119 0.0,
120 Math.PI / 6d,
121 Math.PI / 2d,
122 5d * Math.PI / 6d,
123 Math.PI,
124 7d * Math.PI / 6d,
125 3d * Math.PI / 2d,
126 11d * Math.PI / 6d,
127 2.d * Math.PI };
128 double y[] = { 0d, 0.5d, 1d, 0.5d, 0d, -0.5d, -1d, -0.5d, 0d };
129 UnivariateRealInterpolator i = new SplineInterpolator();
130 UnivariateRealFunction f = i.interpolate(x, y);
131 verifyInterpolation(f, x, y);
132 verifyConsistency((PolynomialSplineFunction) f, x);
133
134 /* Check coefficients against values computed using R (version 1.8.1, Red Hat Linux 9)
135 *
136 * To replicate in R:
137 * x[1] <- 0
138 * x[2] <- pi / 6, etc, same for y[] (could use y <- scan() for y values)
139 * g <- splinefun(x, y, "natural")
140 * splinecoef <- eval(expression(z), envir = environment(g))
141 * print(splinecoef)
142 */
143 PolynomialFunction polynomials[] = ((PolynomialSplineFunction) f).getPolynomials();
144 double target[] = {y[0], 1.002676d, 0d, -0.17415829d};
145 TestUtils.assertEquals(polynomials[0].getCoefficients(), target, coefficientTolerance);
146 target = new double[]{y[1], 8.594367e-01, -2.735672e-01, -0.08707914};
147 TestUtils.assertEquals(polynomials[1].getCoefficients(), target, coefficientTolerance);
148 target = new double[]{y[2], 1.471804e-17,-5.471344e-01, 0.08707914};
149 TestUtils.assertEquals(polynomials[2].getCoefficients(), target, coefficientTolerance);
150 target = new double[]{y[3], -8.594367e-01, -2.735672e-01, 0.17415829};
151 TestUtils.assertEquals(polynomials[3].getCoefficients(), target, coefficientTolerance);
152 target = new double[]{y[4], -1.002676, 6.548562e-17, 0.17415829};
153 TestUtils.assertEquals(polynomials[4].getCoefficients(), target, coefficientTolerance);
154 target = new double[]{y[5], -8.594367e-01, 2.735672e-01, 0.08707914};
155 TestUtils.assertEquals(polynomials[5].getCoefficients(), target, coefficientTolerance);
156 target = new double[]{y[6], 3.466465e-16, 5.471344e-01, -0.08707914};
157 TestUtils.assertEquals(polynomials[6].getCoefficients(), target, coefficientTolerance);
158 target = new double[]{y[7], 8.594367e-01, 2.735672e-01, -0.17415829};
159 TestUtils.assertEquals(polynomials[7].getCoefficients(), target, coefficientTolerance);
160
161 //Check interpolation
162 assertEquals(Math.sqrt(2d) / 2d,f.value(Math.PI/4d),interpolationTolerance);
163 assertEquals(Math.sqrt(2d) / 2d,f.value(3d*Math.PI/4d),interpolationTolerance);
164 }
165
166
167 public void testIllegalArguments() throws MathException {
168 // Data set arrays of different size.
169 UnivariateRealInterpolator i = new SplineInterpolator();
170 try {
171 double xval[] = { 0.0, 1.0 };
172 double yval[] = { 0.0, 1.0, 2.0 };
173 i.interpolate(xval, yval);
174 fail("Failed to detect data set array with different sizes.");
175 } catch (IllegalArgumentException iae) {
176 }
177 // X values not sorted.
178 try {
179 double xval[] = { 0.0, 1.0, 0.5 };
180 double yval[] = { 0.0, 1.0, 2.0 };
181 i.interpolate(xval, yval);
182 fail("Failed to detect unsorted arguments.");
183 } catch (IllegalArgumentException iae) {
184 }
185 }
186
187 /**
188 * verifies that f(x[i]) = y[i] for i = 0..n-1 where n is common length.
189 */
190 protected void verifyInterpolation(UnivariateRealFunction f, double x[], double y[])
191 throws Exception{
192 for (int i = 0; i < x.length; i++) {
193 assertEquals(f.value(x[i]), y[i], knotTolerance);
194 }
195 }
196
197 /**
198 * Verifies that interpolating polynomials satisfy consistency requirement:
199 * adjacent polynomials must agree through two derivatives at knot points
200 */
201 protected void verifyConsistency(PolynomialSplineFunction f, double x[])
202 throws Exception {
203 PolynomialFunction polynomials[] = f.getPolynomials();
204 for (int i = 1; i < x.length - 2; i++) {
205 // evaluate polynomials and derivatives at x[i + 1]
206 assertEquals(polynomials[i].value(x[i +1] - x[i]), polynomials[i + 1].value(0), 0.1);
207 assertEquals(polynomials[i].derivative().value(x[i +1] - x[i]),
208 polynomials[i + 1].derivative().value(0), 0.5);
209 assertEquals(polynomials[i].polynomialDerivative().derivative().value(x[i +1] - x[i]),
210 polynomials[i + 1].polynomialDerivative().derivative().value(0), 0.5);
211 }
212 }
213
214 }