commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From l..@apache.org
Subject [5/8] git commit: Fixed end of line encoding problems.
Date Fri, 17 Oct 2014 08:41:29 GMT
Fixed end of line encoding problems.

Project: http://git-wip-us.apache.org/repos/asf/commons-math/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-math/commit/f44d4852
Tree: http://git-wip-us.apache.org/repos/asf/commons-math/tree/f44d4852
Diff: http://git-wip-us.apache.org/repos/asf/commons-math/diff/f44d4852

Branch: refs/heads/master
Commit: f44d4852ab758cdf0011efa028c85c68b8b36bee
Parents: bf88cac
Author: Luc Maisonobe <luc@apache.org>
Authored: Fri Oct 17 10:23:23 2014 +0200
Committer: Luc Maisonobe <luc@apache.org>
Committed: Fri Oct 17 10:23:23 2014 +0200

----------------------------------------------------------------------
 .../interpolation/AkimaSplineInterpolator.java  | 450 +++++++++---------
 .../AkimaSplineInterpolatorTest.java            | 454 +++++++++----------
 2 files changed, 452 insertions(+), 452 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/commons-math/blob/f44d4852/src/main/java/org/apache/commons/math3/analysis/interpolation/AkimaSplineInterpolator.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math3/analysis/interpolation/AkimaSplineInterpolator.java
b/src/main/java/org/apache/commons/math3/analysis/interpolation/AkimaSplineInterpolator.java
index 8fb896c..260cbfb 100644
--- a/src/main/java/org/apache/commons/math3/analysis/interpolation/AkimaSplineInterpolator.java
+++ b/src/main/java/org/apache/commons/math3/analysis/interpolation/AkimaSplineInterpolator.java
@@ -1,225 +1,225 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.math3.analysis.interpolation;
-
-import org.apache.commons.math3.analysis.polynomials.PolynomialFunction;
-import org.apache.commons.math3.analysis.polynomials.PolynomialSplineFunction;
-import org.apache.commons.math3.exception.DimensionMismatchException;
-import org.apache.commons.math3.exception.NonMonotonicSequenceException;
-import org.apache.commons.math3.exception.NullArgumentException;
-import org.apache.commons.math3.exception.NumberIsTooSmallException;
-import org.apache.commons.math3.exception.util.LocalizedFormats;
-import org.apache.commons.math3.util.FastMath;
-import org.apache.commons.math3.util.MathArrays;
-import org.apache.commons.math3.util.Precision;
-
-/**
- * Computes a cubic spline interpolation for the data set using the Akima
- * algorithm, as originally formulated by Hiroshi Akima in his 1970 paper
- * "A New Method of Interpolation and Smooth Curve Fitting Based on Local Procedures."
- * J. ACM 17, 4 (October 1970), 589-602. DOI=10.1145/321607.321609
- * http://doi.acm.org/10.1145/321607.321609
- * <p>
- * This implementation is based on the Akima implementation in the CubicSpline
- * class in the Math.NET Numerics library. The method referenced is
- * CubicSpline.InterpolateAkimaSorted
- * <p>
- * The {@link #interpolate(double[], double[])} method returns a
- * {@link PolynomialSplineFunction} consisting of n cubic polynomials, defined
- * over the subintervals determined by the x values, x[0] < x[i] ... < x[n]. The
- * Akima algorithm requires that n >= 5.
- * </p>
- * <p>
- */
-
-public class AkimaSplineInterpolator
-    implements UnivariateInterpolator {
-
-
-    /**
-     * The minimum number of points that are needed to compute the function
-     */
-    public static final int MINIMUM_NUMBER_POINTS = 5;
-
-    /**
-     * Default constructor. Builds an AkimaSplineInterpolator object
-     */
-    public AkimaSplineInterpolator() {
-
-    }
-
-    /**
-     * Computes an interpolating function for the data set.
-     *
-     * @param xvals the arguments for the interpolation points
-     * @param yvals 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 5.
-     */
-    public PolynomialSplineFunction interpolate(double[] xvals, double[] yvals)
-        throws DimensionMismatchException, NumberIsTooSmallException,
-        NonMonotonicSequenceException {
-        if (xvals == null || yvals == null) {
-            throw new NullArgumentException();
-        }
-
-        if (xvals.length != yvals.length) {
-            throw new DimensionMismatchException(xvals.length, yvals.length);
-        }
-
-        if (xvals.length < MINIMUM_NUMBER_POINTS) {
-            throw new NumberIsTooSmallException(
-                                                LocalizedFormats.NUMBER_OF_POINTS,
-                                                xvals.length,
-                                                MINIMUM_NUMBER_POINTS, true);
-        }
-
-        MathArrays.checkOrder(xvals);
-
-        final int numberOfDiffAndWeightElements = xvals.length - 1;
-
-        double differences[] = new double[numberOfDiffAndWeightElements];
-        double weights[] = new double[numberOfDiffAndWeightElements];
-
-        for (int i = 0; i < differences.length; i++) {
-            differences[i] = (yvals[i + 1] - yvals[i]) /
-                             (xvals[i + 1] - xvals[i]);
-        }
-
-        for (int i = 1; i < weights.length; i++) {
-            weights[i] = FastMath.abs(differences[i] - differences[i - 1]);
-        }
-
-        /* Prepare Hermite interpolation scheme */
-
-        double firstDerivatives[] = new double[xvals.length];
-
-        for (int i = 2; i < firstDerivatives.length - 2; i++) {
-            if (Precision.equals(weights[i - 1], 0.0) &&
-                Precision.equals(weights[i + 1], 0.0)) {
-                firstDerivatives[i] = (((xvals[i + 1] - xvals[i]) * differences[i - 1]) +
((xvals[i] - xvals[i - 1]) * differences[i])) /
-                                      (xvals[i + 1] - xvals[i - 1]);
-            } else {
-                firstDerivatives[i] = ((weights[i + 1] * differences[i - 1]) + (weights[i
- 1] * differences[i])) /
-                                      (weights[i + 1] + weights[i - 1]);
-            }
-        }
-
-        firstDerivatives[0] = this.differentiateThreePoint(xvals, yvals, 0, 0,
-                                                           1, 2);
-        firstDerivatives[1] = this.differentiateThreePoint(xvals, yvals, 1, 0,
-                                                           1, 2);
-        firstDerivatives[xvals.length - 2] = this
-            .differentiateThreePoint(xvals, yvals, xvals.length - 2,
-                                     xvals.length - 3, xvals.length - 2,
-                                     xvals.length - 1);
-        firstDerivatives[xvals.length - 1] = this
-            .differentiateThreePoint(xvals, yvals, xvals.length - 1,
-                                     xvals.length - 3, xvals.length - 2,
-                                     xvals.length - 1);
-
-        return this.interpolateHermiteSorted(xvals, yvals, firstDerivatives);
-    }
-
-    /**
-     * Three point differentiation helper, modeled off of the same method in the
-     * Math.NET CubicSpline class. This is used by both the Apache Math and the
-     * Math.NET Akima Cubic Spline algorithms
-     *
-     * @param xvals x values to calculate the numerical derivative with
-     * @param yvals y values to calculate the numerical derivative with
-     * @param indexOfDifferentiation index of the elemnt we are calculating the derivative
around
-     * @param indexOfFirstSample index of the first element to sample for the three point
method
-     * @param indexOfSecondsample index of the second element to sample for the three point
method
-     * @param indexOfThirdSample index of the third element to sample for the three point
method
-     * @return the derivative
-     */
-    private double differentiateThreePoint(double[] xvals, double[] yvals,
-                                           int indexOfDifferentiation,
-                                           int indexOfFirstSample,
-                                           int indexOfSecondsample,
-                                           int indexOfThirdSample) {
-        double x0 = yvals[indexOfFirstSample];
-        double x1 = yvals[indexOfSecondsample];
-        double x2 = yvals[indexOfThirdSample];
-
-        double t = xvals[indexOfDifferentiation] - xvals[indexOfFirstSample];
-        double t1 = xvals[indexOfSecondsample] - xvals[indexOfFirstSample];
-        double t2 = xvals[indexOfThirdSample] - xvals[indexOfFirstSample];
-
-        double a = (x2 - x0 - (t2 / t1 * (x1 - x0))) / (t2 * t2 - t1 * t2);
-        double b = (x1 - x0 - a * t1 * t1) / t1;
-        return (2 * a * t) + b;
-    }
-
-    /**
-     * Creates a Hermite cubic spline interpolation from the set of (x,y) value
-     * pairs and their derivatives. This is modeled off of the
-     * InterpolateHermiteSorted method in the Math.NET CubicSpline class.
-     *
-     * @param xvals x values for interpolation
-     * @param yvals y values for interpolation
-     * @param firstDerivatives first derivative values of the function
-     * @return polynomial that fits the function
-     */
-    private PolynomialSplineFunction interpolateHermiteSorted(double[] xvals,
-                                                              double[] yvals,
-                                                              double[] firstDerivatives)
{
-        if (xvals.length != yvals.length) {
-            throw new DimensionMismatchException(xvals.length, yvals.length);
-        }
-
-        if (xvals.length != firstDerivatives.length) {
-            throw new DimensionMismatchException(xvals.length,
-                                                 firstDerivatives.length);
-        }
-
-        final int minimumLength = 2;
-        if (xvals.length < minimumLength) {
-            throw new NumberIsTooSmallException(
-                                                LocalizedFormats.NUMBER_OF_POINTS,
-                                                xvals.length, minimumLength,
-                                                true);
-        }
-
-        int size = xvals.length - 1;
-        final PolynomialFunction polynomials[] = new PolynomialFunction[size];
-        final double coefficients[] = new double[4];
-
-        for (int i = 0; i < polynomials.length; i++) {
-            double w = xvals[i + 1] - xvals[i];
-            double w2 = w * w;
-            coefficients[0] = yvals[i];
-            coefficients[1] = firstDerivatives[i];
-            coefficients[2] = (3 * (yvals[i + 1] - yvals[i]) / w - 2 *
-                               firstDerivatives[i] - firstDerivatives[i + 1]) /
-                              w;
-            coefficients[3] = (2 * (yvals[i] - yvals[i + 1]) / w +
-                               firstDerivatives[i] + firstDerivatives[i + 1]) /
-                              w2;
-            polynomials[i] = new PolynomialFunction(coefficients);
-        }
-
-        return new PolynomialSplineFunction(xvals, polynomials);
-
-    }
-}
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math3.analysis.interpolation;
+
+import org.apache.commons.math3.analysis.polynomials.PolynomialFunction;
+import org.apache.commons.math3.analysis.polynomials.PolynomialSplineFunction;
+import org.apache.commons.math3.exception.DimensionMismatchException;
+import org.apache.commons.math3.exception.NonMonotonicSequenceException;
+import org.apache.commons.math3.exception.NullArgumentException;
+import org.apache.commons.math3.exception.NumberIsTooSmallException;
+import org.apache.commons.math3.exception.util.LocalizedFormats;
+import org.apache.commons.math3.util.FastMath;
+import org.apache.commons.math3.util.MathArrays;
+import org.apache.commons.math3.util.Precision;
+
+/**
+ * Computes a cubic spline interpolation for the data set using the Akima
+ * algorithm, as originally formulated by Hiroshi Akima in his 1970 paper
+ * "A New Method of Interpolation and Smooth Curve Fitting Based on Local Procedures."
+ * J. ACM 17, 4 (October 1970), 589-602. DOI=10.1145/321607.321609
+ * http://doi.acm.org/10.1145/321607.321609
+ * <p>
+ * This implementation is based on the Akima implementation in the CubicSpline
+ * class in the Math.NET Numerics library. The method referenced is
+ * CubicSpline.InterpolateAkimaSorted
+ * <p>
+ * The {@link #interpolate(double[], double[])} method returns a
+ * {@link PolynomialSplineFunction} consisting of n cubic polynomials, defined
+ * over the subintervals determined by the x values, x[0] < x[i] ... < x[n]. The
+ * Akima algorithm requires that n >= 5.
+ * </p>
+ * <p>
+ */
+
+public class AkimaSplineInterpolator
+    implements UnivariateInterpolator {
+
+
+    /**
+     * The minimum number of points that are needed to compute the function
+     */
+    public static final int MINIMUM_NUMBER_POINTS = 5;
+
+    /**
+     * Default constructor. Builds an AkimaSplineInterpolator object
+     */
+    public AkimaSplineInterpolator() {
+
+    }
+
+    /**
+     * Computes an interpolating function for the data set.
+     *
+     * @param xvals the arguments for the interpolation points
+     * @param yvals 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 5.
+     */
+    public PolynomialSplineFunction interpolate(double[] xvals, double[] yvals)
+        throws DimensionMismatchException, NumberIsTooSmallException,
+        NonMonotonicSequenceException {
+        if (xvals == null || yvals == null) {
+            throw new NullArgumentException();
+        }
+
+        if (xvals.length != yvals.length) {
+            throw new DimensionMismatchException(xvals.length, yvals.length);
+        }
+
+        if (xvals.length < MINIMUM_NUMBER_POINTS) {
+            throw new NumberIsTooSmallException(
+                                                LocalizedFormats.NUMBER_OF_POINTS,
+                                                xvals.length,
+                                                MINIMUM_NUMBER_POINTS, true);
+        }
+
+        MathArrays.checkOrder(xvals);
+
+        final int numberOfDiffAndWeightElements = xvals.length - 1;
+
+        double differences[] = new double[numberOfDiffAndWeightElements];
+        double weights[] = new double[numberOfDiffAndWeightElements];
+
+        for (int i = 0; i < differences.length; i++) {
+            differences[i] = (yvals[i + 1] - yvals[i]) /
+                             (xvals[i + 1] - xvals[i]);
+        }
+
+        for (int i = 1; i < weights.length; i++) {
+            weights[i] = FastMath.abs(differences[i] - differences[i - 1]);
+        }
+
+        /* Prepare Hermite interpolation scheme */
+
+        double firstDerivatives[] = new double[xvals.length];
+
+        for (int i = 2; i < firstDerivatives.length - 2; i++) {
+            if (Precision.equals(weights[i - 1], 0.0) &&
+                Precision.equals(weights[i + 1], 0.0)) {
+                firstDerivatives[i] = (((xvals[i + 1] - xvals[i]) * differences[i - 1]) +
((xvals[i] - xvals[i - 1]) * differences[i])) /
+                                      (xvals[i + 1] - xvals[i - 1]);
+            } else {
+                firstDerivatives[i] = ((weights[i + 1] * differences[i - 1]) + (weights[i
- 1] * differences[i])) /
+                                      (weights[i + 1] + weights[i - 1]);
+            }
+        }
+
+        firstDerivatives[0] = this.differentiateThreePoint(xvals, yvals, 0, 0,
+                                                           1, 2);
+        firstDerivatives[1] = this.differentiateThreePoint(xvals, yvals, 1, 0,
+                                                           1, 2);
+        firstDerivatives[xvals.length - 2] = this
+            .differentiateThreePoint(xvals, yvals, xvals.length - 2,
+                                     xvals.length - 3, xvals.length - 2,
+                                     xvals.length - 1);
+        firstDerivatives[xvals.length - 1] = this
+            .differentiateThreePoint(xvals, yvals, xvals.length - 1,
+                                     xvals.length - 3, xvals.length - 2,
+                                     xvals.length - 1);
+
+        return this.interpolateHermiteSorted(xvals, yvals, firstDerivatives);
+    }
+
+    /**
+     * Three point differentiation helper, modeled off of the same method in the
+     * Math.NET CubicSpline class. This is used by both the Apache Math and the
+     * Math.NET Akima Cubic Spline algorithms
+     *
+     * @param xvals x values to calculate the numerical derivative with
+     * @param yvals y values to calculate the numerical derivative with
+     * @param indexOfDifferentiation index of the elemnt we are calculating the derivative
around
+     * @param indexOfFirstSample index of the first element to sample for the three point
method
+     * @param indexOfSecondsample index of the second element to sample for the three point
method
+     * @param indexOfThirdSample index of the third element to sample for the three point
method
+     * @return the derivative
+     */
+    private double differentiateThreePoint(double[] xvals, double[] yvals,
+                                           int indexOfDifferentiation,
+                                           int indexOfFirstSample,
+                                           int indexOfSecondsample,
+                                           int indexOfThirdSample) {
+        double x0 = yvals[indexOfFirstSample];
+        double x1 = yvals[indexOfSecondsample];
+        double x2 = yvals[indexOfThirdSample];
+
+        double t = xvals[indexOfDifferentiation] - xvals[indexOfFirstSample];
+        double t1 = xvals[indexOfSecondsample] - xvals[indexOfFirstSample];
+        double t2 = xvals[indexOfThirdSample] - xvals[indexOfFirstSample];
+
+        double a = (x2 - x0 - (t2 / t1 * (x1 - x0))) / (t2 * t2 - t1 * t2);
+        double b = (x1 - x0 - a * t1 * t1) / t1;
+        return (2 * a * t) + b;
+    }
+
+    /**
+     * Creates a Hermite cubic spline interpolation from the set of (x,y) value
+     * pairs and their derivatives. This is modeled off of the
+     * InterpolateHermiteSorted method in the Math.NET CubicSpline class.
+     *
+     * @param xvals x values for interpolation
+     * @param yvals y values for interpolation
+     * @param firstDerivatives first derivative values of the function
+     * @return polynomial that fits the function
+     */
+    private PolynomialSplineFunction interpolateHermiteSorted(double[] xvals,
+                                                              double[] yvals,
+                                                              double[] firstDerivatives)
{
+        if (xvals.length != yvals.length) {
+            throw new DimensionMismatchException(xvals.length, yvals.length);
+        }
+
+        if (xvals.length != firstDerivatives.length) {
+            throw new DimensionMismatchException(xvals.length,
+                                                 firstDerivatives.length);
+        }
+
+        final int minimumLength = 2;
+        if (xvals.length < minimumLength) {
+            throw new NumberIsTooSmallException(
+                                                LocalizedFormats.NUMBER_OF_POINTS,
+                                                xvals.length, minimumLength,
+                                                true);
+        }
+
+        int size = xvals.length - 1;
+        final PolynomialFunction polynomials[] = new PolynomialFunction[size];
+        final double coefficients[] = new double[4];
+
+        for (int i = 0; i < polynomials.length; i++) {
+            double w = xvals[i + 1] - xvals[i];
+            double w2 = w * w;
+            coefficients[0] = yvals[i];
+            coefficients[1] = firstDerivatives[i];
+            coefficients[2] = (3 * (yvals[i + 1] - yvals[i]) / w - 2 *
+                               firstDerivatives[i] - firstDerivatives[i + 1]) /
+                              w;
+            coefficients[3] = (2 * (yvals[i] - yvals[i + 1]) / w +
+                               firstDerivatives[i] + firstDerivatives[i + 1]) /
+                              w2;
+            polynomials[i] = new PolynomialFunction(coefficients);
+        }
+
+        return new PolynomialSplineFunction(xvals, polynomials);
+
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/f44d4852/src/test/java/org/apache/commons/math3/analysis/interpolation/AkimaSplineInterpolatorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math3/analysis/interpolation/AkimaSplineInterpolatorTest.java
b/src/test/java/org/apache/commons/math3/analysis/interpolation/AkimaSplineInterpolatorTest.java
index 017241a..adf39d6 100644
--- a/src/test/java/org/apache/commons/math3/analysis/interpolation/AkimaSplineInterpolatorTest.java
+++ b/src/test/java/org/apache/commons/math3/analysis/interpolation/AkimaSplineInterpolatorTest.java
@@ -1,227 +1,227 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.math3.analysis.interpolation;
-
-import org.apache.commons.math3.analysis.UnivariateFunction;
-import org.apache.commons.math3.distribution.UniformRealDistribution;
-import org.apache.commons.math3.exception.DimensionMismatchException;
-import org.apache.commons.math3.exception.NonMonotonicSequenceException;
-import org.apache.commons.math3.exception.NullArgumentException;
-import org.apache.commons.math3.exception.NumberIsTooSmallException;
-import org.apache.commons.math3.random.RandomGenerator;
-import org.apache.commons.math3.random.Well19937c;
-import org.apache.commons.math3.util.FastMath;
-import org.apache.commons.math3.util.Precision;
-import org.junit.Assert;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-
-public class AkimaSplineInterpolatorTest
-{
-
-    @Test
-    public void testIllegalArguments()
-    {
-        // Data set arrays of different size.
-        UnivariateInterpolator i = new AkimaSplineInterpolator();
-
-        try
-        {
-            double yval[] = { 0.0, 1.0, 2.0, 3.0, 4.0 };
-            i.interpolate( null, yval );
-            Assert.fail( "Failed to detect x null pointer" );
-        }
-        catch ( NullArgumentException iae )
-        {
-            // Expected.
-        }
-
-        try
-        {
-            double xval[] = { 0.0, 1.0, 2.0, 3.0, 4.0 };
-            i.interpolate( xval, null );
-            Assert.fail( "Failed to detect y null pointer" );
-        }
-        catch ( NullArgumentException iae )
-        {
-            // Expected.
-        }
-
-        try
-        {
-            double xval[] = { 0.0, 1.0, 2.0, 3.0 };
-            double yval[] = { 0.0, 1.0, 2.0, 3.0 };
-            i.interpolate( xval, yval );
-            Assert.fail( "Failed to detect insufficient data" );
-        }
-        catch ( NumberIsTooSmallException iae )
-        {
-            // Expected.
-        }
-
-        try
-        {
-            double xval[] = { 0.0, 1.0, 2.0, 3.0, 4.0 };
-            double yval[] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0 };
-            i.interpolate( xval, yval );
-            Assert.fail( "Failed to detect data set array with different sizes." );
-        }
-        catch ( DimensionMismatchException iae )
-        {
-            // Expected.
-        }
-
-        // X values not sorted.
-        try
-        {
-            double xval[] = { 0.0, 1.0, 0.5, 7.0, 3.5, 2.2, 8.0 };
-            double yval[] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
-            i.interpolate( xval, yval );
-            Assert.fail( "Failed to detect unsorted arguments." );
-        }
-        catch ( NonMonotonicSequenceException iae )
-        {
-            // Expected.
-        }
-    }
-
-    /*
-     * Interpolate a straight line. <p> y = 2 x - 5 <p> Tolerances determined
by performing same calculation using
-     * Math.NET over ten runs of 100 random number draws for the same function over the same
span with the same number
-     * of elements
-     */
-    @Test
-    public void testInterpolateLine()
-    {
-        final int numberOfElements = 10;
-        final double minimumX = -10;
-        final double maximumX = 10;
-        final int numberOfSamples = 100;
-        final double interpolationTolerance = 1e-15;
-        final double maxTolerance = 1e-15;
-
-        UnivariateFunction f = new UnivariateFunction()
-        {
-            public double value( double x )
-            {
-                return 2 * x - 5;
-            }
-        };
-
-        testInterpolation( minimumX, maximumX, numberOfElements, numberOfSamples, f, interpolationTolerance,
-                           maxTolerance );
-    }
-
-    /*
-     * Interpolate a straight line. <p> y = 3 x<sup>2</sup> - 5 x + 7 <p>
Tolerances determined by performing same
-     * calculation using Math.NET over ten runs of 100 random number draws for the same function
over the same span with
-     * the same number of elements
-     */
-
-    @Test
-    public void testInterpolateParabola()
-    {
-        final int numberOfElements = 10;
-        final double minimumX = -10;
-        final double maximumX = 10;
-        final int numberOfSamples = 100;
-        final double interpolationTolerance = 7e-15;
-        final double maxTolerance = 6e-14;
-
-        UnivariateFunction f = new UnivariateFunction()
-        {
-            public double value( double x )
-            {
-                return ( 3 * x * x ) - ( 5 * x ) + 7;
-            }
-        };
-
-        testInterpolation( minimumX, maximumX, numberOfElements, numberOfSamples, f, interpolationTolerance,
-                           maxTolerance );
-    }
-
-    /*
-     * Interpolate a straight line. <p> y = 3 x<sup>3</sup> - 0.5 x<sup>2</sup>
+ x - 1 <p> Tolerances determined by
-     * performing same calculation using Math.NET over ten runs of 100 random number draws
for the same function over
-     * the same span with the same number of elements
-     */
-    @Test
-    public void testInterpolateCubic()
-    {
-        final int numberOfElements = 10;
-        final double minimumX = -3;
-        final double maximumX = 3;
-        final int numberOfSamples = 100;
-        final double interpolationTolerance = 0.37;
-        final double maxTolerance = 3.8;
-
-        UnivariateFunction f = new UnivariateFunction()
-        {
-            public double value( double x )
-            {
-                return ( 3 * x * x * x ) - ( 0.5 * x * x ) + ( 1 * x ) - 1;
-            }
-        };
-
-        testInterpolation( minimumX, maximumX, numberOfElements, numberOfSamples, f, interpolationTolerance,
-                           maxTolerance );
-    }
-
-    private void testInterpolation( double minimumX, double maximumX, int numberOfElements,
int numberOfSamples,
-                                    UnivariateFunction f, double tolerance, double maxTolerance
)
-    {
-        double expected;
-        double actual;
-        double currentX;
-        final double delta = ( maximumX - minimumX ) / ( (double) numberOfElements );
-        double xValues[] = new double[numberOfElements];
-        double yValues[] = new double[numberOfElements];
-
-        for ( int i = 0; i < numberOfElements; i++ )
-        {
-            xValues[i] = minimumX + delta * (double) i;
-            yValues[i] = f.value( xValues[i] );
-        }
-
-        UnivariateFunction interpolation = new AkimaSplineInterpolator().interpolate( xValues,
yValues );
-
-        for ( int i = 0; i < numberOfElements; i++ )
-        {
-            currentX = xValues[i];
-            expected = f.value( currentX );
-            actual = interpolation.value( currentX );
-            assertTrue( Precision.equals( expected, actual ) );
-        }
-
-        final RandomGenerator rng = new Well19937c( 1234567L ); // "tol" depends on the seed.
-        final UniformRealDistribution distX =
-            new UniformRealDistribution( rng, xValues[0], xValues[xValues.length - 1] );
-
-        double sumError = 0;
-        for ( int i = 0; i < numberOfSamples; i++ )
-        {
-            currentX = distX.sample();
-            expected = f.value( currentX );
-            actual = interpolation.value( currentX );
-            sumError += FastMath.abs( actual - expected );
-            assertEquals( expected, actual, maxTolerance );
-        }
-
-        assertEquals( 0.0, ( sumError / (double) numberOfSamples ), tolerance );
-    }
-}
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math3.analysis.interpolation;
+
+import org.apache.commons.math3.analysis.UnivariateFunction;
+import org.apache.commons.math3.distribution.UniformRealDistribution;
+import org.apache.commons.math3.exception.DimensionMismatchException;
+import org.apache.commons.math3.exception.NonMonotonicSequenceException;
+import org.apache.commons.math3.exception.NullArgumentException;
+import org.apache.commons.math3.exception.NumberIsTooSmallException;
+import org.apache.commons.math3.random.RandomGenerator;
+import org.apache.commons.math3.random.Well19937c;
+import org.apache.commons.math3.util.FastMath;
+import org.apache.commons.math3.util.Precision;
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class AkimaSplineInterpolatorTest
+{
+
+    @Test
+    public void testIllegalArguments()
+    {
+        // Data set arrays of different size.
+        UnivariateInterpolator i = new AkimaSplineInterpolator();
+
+        try
+        {
+            double yval[] = { 0.0, 1.0, 2.0, 3.0, 4.0 };
+            i.interpolate( null, yval );
+            Assert.fail( "Failed to detect x null pointer" );
+        }
+        catch ( NullArgumentException iae )
+        {
+            // Expected.
+        }
+
+        try
+        {
+            double xval[] = { 0.0, 1.0, 2.0, 3.0, 4.0 };
+            i.interpolate( xval, null );
+            Assert.fail( "Failed to detect y null pointer" );
+        }
+        catch ( NullArgumentException iae )
+        {
+            // Expected.
+        }
+
+        try
+        {
+            double xval[] = { 0.0, 1.0, 2.0, 3.0 };
+            double yval[] = { 0.0, 1.0, 2.0, 3.0 };
+            i.interpolate( xval, yval );
+            Assert.fail( "Failed to detect insufficient data" );
+        }
+        catch ( NumberIsTooSmallException iae )
+        {
+            // Expected.
+        }
+
+        try
+        {
+            double xval[] = { 0.0, 1.0, 2.0, 3.0, 4.0 };
+            double yval[] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0 };
+            i.interpolate( xval, yval );
+            Assert.fail( "Failed to detect data set array with different sizes." );
+        }
+        catch ( DimensionMismatchException iae )
+        {
+            // Expected.
+        }
+
+        // X values not sorted.
+        try
+        {
+            double xval[] = { 0.0, 1.0, 0.5, 7.0, 3.5, 2.2, 8.0 };
+            double yval[] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
+            i.interpolate( xval, yval );
+            Assert.fail( "Failed to detect unsorted arguments." );
+        }
+        catch ( NonMonotonicSequenceException iae )
+        {
+            // Expected.
+        }
+    }
+
+    /*
+     * Interpolate a straight line. <p> y = 2 x - 5 <p> Tolerances determined
by performing same calculation using
+     * Math.NET over ten runs of 100 random number draws for the same function over the same
span with the same number
+     * of elements
+     */
+    @Test
+    public void testInterpolateLine()
+    {
+        final int numberOfElements = 10;
+        final double minimumX = -10;
+        final double maximumX = 10;
+        final int numberOfSamples = 100;
+        final double interpolationTolerance = 1e-15;
+        final double maxTolerance = 1e-15;
+
+        UnivariateFunction f = new UnivariateFunction()
+        {
+            public double value( double x )
+            {
+                return 2 * x - 5;
+            }
+        };
+
+        testInterpolation( minimumX, maximumX, numberOfElements, numberOfSamples, f, interpolationTolerance,
+                           maxTolerance );
+    }
+
+    /*
+     * Interpolate a straight line. <p> y = 3 x<sup>2</sup> - 5 x + 7 <p>
Tolerances determined by performing same
+     * calculation using Math.NET over ten runs of 100 random number draws for the same function
over the same span with
+     * the same number of elements
+     */
+
+    @Test
+    public void testInterpolateParabola()
+    {
+        final int numberOfElements = 10;
+        final double minimumX = -10;
+        final double maximumX = 10;
+        final int numberOfSamples = 100;
+        final double interpolationTolerance = 7e-15;
+        final double maxTolerance = 6e-14;
+
+        UnivariateFunction f = new UnivariateFunction()
+        {
+            public double value( double x )
+            {
+                return ( 3 * x * x ) - ( 5 * x ) + 7;
+            }
+        };
+
+        testInterpolation( minimumX, maximumX, numberOfElements, numberOfSamples, f, interpolationTolerance,
+                           maxTolerance );
+    }
+
+    /*
+     * Interpolate a straight line. <p> y = 3 x<sup>3</sup> - 0.5 x<sup>2</sup>
+ x - 1 <p> Tolerances determined by
+     * performing same calculation using Math.NET over ten runs of 100 random number draws
for the same function over
+     * the same span with the same number of elements
+     */
+    @Test
+    public void testInterpolateCubic()
+    {
+        final int numberOfElements = 10;
+        final double minimumX = -3;
+        final double maximumX = 3;
+        final int numberOfSamples = 100;
+        final double interpolationTolerance = 0.37;
+        final double maxTolerance = 3.8;
+
+        UnivariateFunction f = new UnivariateFunction()
+        {
+            public double value( double x )
+            {
+                return ( 3 * x * x * x ) - ( 0.5 * x * x ) + ( 1 * x ) - 1;
+            }
+        };
+
+        testInterpolation( minimumX, maximumX, numberOfElements, numberOfSamples, f, interpolationTolerance,
+                           maxTolerance );
+    }
+
+    private void testInterpolation( double minimumX, double maximumX, int numberOfElements,
int numberOfSamples,
+                                    UnivariateFunction f, double tolerance, double maxTolerance
)
+    {
+        double expected;
+        double actual;
+        double currentX;
+        final double delta = ( maximumX - minimumX ) / ( (double) numberOfElements );
+        double xValues[] = new double[numberOfElements];
+        double yValues[] = new double[numberOfElements];
+
+        for ( int i = 0; i < numberOfElements; i++ )
+        {
+            xValues[i] = minimumX + delta * (double) i;
+            yValues[i] = f.value( xValues[i] );
+        }
+
+        UnivariateFunction interpolation = new AkimaSplineInterpolator().interpolate( xValues,
yValues );
+
+        for ( int i = 0; i < numberOfElements; i++ )
+        {
+            currentX = xValues[i];
+            expected = f.value( currentX );
+            actual = interpolation.value( currentX );
+            assertTrue( Precision.equals( expected, actual ) );
+        }
+
+        final RandomGenerator rng = new Well19937c( 1234567L ); // "tol" depends on the seed.
+        final UniformRealDistribution distX =
+            new UniformRealDistribution( rng, xValues[0], xValues[xValues.length - 1] );
+
+        double sumError = 0;
+        for ( int i = 0; i < numberOfSamples; i++ )
+        {
+            currentX = distX.sample();
+            expected = f.value( currentX );
+            actual = interpolation.value( currentX );
+            sumError += FastMath.abs( actual - expected );
+            assertEquals( expected, actual, maxTolerance );
+        }
+
+        assertEquals( 0.0, ( sumError / (double) numberOfSamples ), tolerance );
+    }
+}


Mime
View raw message