You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by er...@apache.org on 2010/11/25 17:22:01 UTC
svn commit: r1039083 [4/4] - in /commons/proper/math/trunk/src:
main/java/org/apache/commons/math/analysis/
main/java/org/apache/commons/math/analysis/polynomials/
main/java/org/apache/commons/math/analysis/solvers/
main/java/org/apache/commons/math/di...
Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/ode/nonstiff/HighamHall54IntegratorTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/ode/nonstiff/HighamHall54IntegratorTest.java?rev=1039083&r1=1039082&r2=1039083&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/ode/nonstiff/HighamHall54IntegratorTest.java (original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/ode/nonstiff/HighamHall54IntegratorTest.java Thu Nov 25 16:22:00 2010
@@ -20,8 +20,9 @@ package org.apache.commons.math.ode.nons
import junit.framework.TestCase;
import org.apache.commons.math.ConvergenceException;
-import org.apache.commons.math.exception.MathUserException;
import org.apache.commons.math.exception.util.LocalizedFormats;
+import org.apache.commons.math.exception.TooManyEvaluationsException;
+import org.apache.commons.math.exception.MathUserException;
import org.apache.commons.math.ode.FirstOrderDifferentialEquations;
import org.apache.commons.math.ode.FirstOrderIntegrator;
import org.apache.commons.math.ode.IntegratorException;
@@ -268,9 +269,8 @@ public class HighamHall54IntegratorTest
pb.getInitialTime(), pb.getInitialState(),
pb.getFinalTime(), new double[pb.getDimension()]);
fail("an exception should have been thrown");
- } catch (IntegratorException ie) {
- assertTrue(ie.getCause() != null);
- assertTrue(ie.getCause() instanceof ConvergenceException);
+ } catch (TooManyEvaluationsException tmee) {
+ // Expected.
}
}
Added: commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/CircleScalar.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/CircleScalar.java?rev=1039083&view=auto
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/CircleScalar.java (added)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/CircleScalar.java Thu Nov 25 16:22:00 2010
@@ -0,0 +1,97 @@
+/*
+ * 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.math.optimization.general;
+
+import java.awt.geom.Point2D;
+import java.util.ArrayList;
+import org.apache.commons.math.analysis.DifferentiableMultivariateRealFunction;
+import org.apache.commons.math.analysis.MultivariateRealFunction;
+import org.apache.commons.math.analysis.MultivariateVectorialFunction;
+
+/**
+ * Class used in the tests.
+ */
+class CircleScalar implements DifferentiableMultivariateRealFunction {
+ private ArrayList<Point2D.Double> points;
+
+ public CircleScalar() {
+ points = new ArrayList<Point2D.Double>();
+ }
+
+ public void addPoint(double px, double py) {
+ points.add(new Point2D.Double(px, py));
+ }
+
+ public double getRadius(Point2D.Double center) {
+ double r = 0;
+ for (Point2D.Double point : points) {
+ r += point.distance(center);
+ }
+ return r / points.size();
+ }
+
+ private double[] gradient(double[] point) {
+ // optimal radius
+ Point2D.Double center = new Point2D.Double(point[0], point[1]);
+ double radius = getRadius(center);
+
+ // gradient of the sum of squared residuals
+ double dJdX = 0;
+ double dJdY = 0;
+ for (Point2D.Double pk : points) {
+ double dk = pk.distance(center);
+ dJdX += (center.x - pk.x) * (dk - radius) / dk;
+ dJdY += (center.y - pk.y) * (dk - radius) / dk;
+ }
+ dJdX *= 2;
+ dJdY *= 2;
+
+ return new double[] { dJdX, dJdY };
+ }
+
+ public double value(double[] variables) {
+ Point2D.Double center = new Point2D.Double(variables[0], variables[1]);
+ double radius = getRadius(center);
+
+ double sum = 0;
+ for (Point2D.Double point : points) {
+ double di = point.distance(center) - radius;
+ sum += di * di;
+ }
+
+ return sum;
+ }
+
+ public MultivariateVectorialFunction gradient() {
+ return new MultivariateVectorialFunction() {
+ private static final long serialVersionUID = 3174909643301201710L;
+ public double[] value(double[] point) {
+ return gradient(point);
+ }
+ };
+ }
+
+ public MultivariateRealFunction partialDerivative(final int k) {
+ return new MultivariateRealFunction() {
+ private static final long serialVersionUID = 3073956364104833888L;
+ public double value(double[] point) {
+ return gradient(point)[k];
+ }
+ };
+ }
+}
Propchange: commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/CircleScalar.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/CircleVectorial.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/CircleVectorial.java?rev=1039083&view=auto
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/CircleVectorial.java (added)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/CircleVectorial.java Thu Nov 25 16:22:00 2010
@@ -0,0 +1,98 @@
+/*
+ * 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.math.optimization.general;
+
+import java.awt.geom.Point2D;
+import java.util.ArrayList;
+import org.apache.commons.math.analysis.DifferentiableMultivariateVectorialFunction;
+import org.apache.commons.math.analysis.MultivariateMatrixFunction;
+
+/**
+ * Class used in the tests.
+ */
+class CircleVectorial implements DifferentiableMultivariateVectorialFunction {
+ private ArrayList<Point2D.Double> points;
+
+ public CircleVectorial() {
+ points = new ArrayList<Point2D.Double>();
+ }
+
+ public void addPoint(double px, double py) {
+ points.add(new Point2D.Double(px, py));
+ }
+
+ public int getN() {
+ return points.size();
+ }
+
+ public double getRadius(Point2D.Double center) {
+ double r = 0;
+ for (Point2D.Double point : points) {
+ r += point.distance(center);
+ }
+ return r / points.size();
+ }
+
+ private double[][] jacobian(double[] point) {
+ int n = points.size();
+ Point2D.Double center = new Point2D.Double(point[0], point[1]);
+
+ // gradient of the optimal radius
+ double dRdX = 0;
+ double dRdY = 0;
+ for (Point2D.Double pk : points) {
+ double dk = pk.distance(center);
+ dRdX += (center.x - pk.x) / dk;
+ dRdY += (center.y - pk.y) / dk;
+ }
+ dRdX /= n;
+ dRdY /= n;
+
+ // jacobian of the radius residuals
+ double[][] jacobian = new double[n][2];
+ for (int i = 0; i < n; ++i) {
+ Point2D.Double pi = points.get(i);
+ double di = pi.distance(center);
+ jacobian[i][0] = (center.x - pi.x) / di - dRdX;
+ jacobian[i][1] = (center.y - pi.y) / di - dRdY;
+ }
+
+ return jacobian;
+ }
+
+ public double[] value(double[] variables) {
+ Point2D.Double center = new Point2D.Double(variables[0], variables[1]);
+ double radius = getRadius(center);
+
+ double[] residuals = new double[points.size()];
+ for (int i = 0; i < residuals.length; ++i) {
+ residuals[i] = points.get(i).distance(center) - radius;
+ }
+
+ return residuals;
+ }
+
+ public MultivariateMatrixFunction jacobian() {
+ return new MultivariateMatrixFunction() {
+ private static final long serialVersionUID = -4340046230875165095L;
+ public double[][] value(double[] point) {
+ return jacobian(point);
+ }
+ };
+ }
+}
Propchange: commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/CircleVectorial.java
------------------------------------------------------------------------------
svn:eol-style = native
Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/GaussNewtonOptimizerTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/GaussNewtonOptimizerTest.java?rev=1039083&r1=1039082&r2=1039083&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/GaussNewtonOptimizerTest.java (original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/GaussNewtonOptimizerTest.java Thu Nov 25 16:22:00 2010
@@ -368,7 +368,7 @@ extends TestCase {
}
public void testMaxEvaluations() throws Exception {
- Circle circle = new Circle();
+ CircleVectorial circle = new CircleVectorial();
circle.addPoint( 30.0, 68.0);
circle.addPoint( 50.0, -6.0);
circle.addPoint(110.0, -20.0);
@@ -388,7 +388,7 @@ extends TestCase {
}
public void testCircleFitting() throws MathUserException {
- Circle circle = new Circle();
+ CircleVectorial circle = new CircleVectorial();
circle.addPoint( 30.0, 68.0);
circle.addPoint( 50.0, -6.0);
circle.addPoint(110.0, -20.0);
@@ -409,7 +409,7 @@ extends TestCase {
}
public void testCircleFittingBadInit() throws MathUserException {
- Circle circle = new Circle();
+ CircleVectorial circle = new CircleVectorial();
double[][] points = new double[][] {
{-0.312967, 0.072366}, {-0.339248, 0.132965}, {-0.379780, 0.202724},
{-0.390426, 0.260487}, {-0.361212, 0.328325}, {-0.346039, 0.392619},
@@ -488,86 +488,5 @@ extends TestCase {
}
};
}
-
}
-
- private static class Circle implements DifferentiableMultivariateVectorialFunction, Serializable {
-
- private static final long serialVersionUID = -7165774454925027042L;
- private ArrayList<Point2D.Double> points;
-
- public Circle() {
- points = new ArrayList<Point2D.Double>();
- }
-
- public void addPoint(double px, double py) {
- points.add(new Point2D.Double(px, py));
- }
-
- public int getN() {
- return points.size();
- }
-
- public double getRadius(Point2D.Double center) {
- double r = 0;
- for (Point2D.Double point : points) {
- r += point.distance(center);
- }
- return r / points.size();
- }
-
- private double[][] jacobian(double[] variables) {
-
- int n = points.size();
- Point2D.Double center = new Point2D.Double(variables[0], variables[1]);
-
- // gradient of the optimal radius
- double dRdX = 0;
- double dRdY = 0;
- for (Point2D.Double pk : points) {
- double dk = pk.distance(center);
- dRdX += (center.x - pk.x) / dk;
- dRdY += (center.y - pk.y) / dk;
- }
- dRdX /= n;
- dRdY /= n;
-
- // jacobian of the radius residuals
- double[][] jacobian = new double[n][2];
- for (int i = 0; i < n; ++i) {
- Point2D.Double pi = points.get(i);
- double di = pi.distance(center);
- jacobian[i][0] = (center.x - pi.x) / di - dRdX;
- jacobian[i][1] = (center.y - pi.y) / di - dRdY;
- }
-
- return jacobian;
-
- }
-
- public double[] value(double[] variables) {
-
- Point2D.Double center = new Point2D.Double(variables[0], variables[1]);
- double radius = getRadius(center);
-
- double[] residuals = new double[points.size()];
- for (int i = 0; i < residuals.length; ++i) {
- residuals[i] = points.get(i).distance(center) - radius;
- }
-
- return residuals;
-
- }
-
- public MultivariateMatrixFunction jacobian() {
- return new MultivariateMatrixFunction() {
- private static final long serialVersionUID = -4340046230875165095L;
- public double[][] value(double[] point) {
- return jacobian(point);
- }
- };
- }
-
- }
-
}
Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/LevenbergMarquardtOptimizerTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/LevenbergMarquardtOptimizerTest.java?rev=1039083&r1=1039082&r2=1039083&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/LevenbergMarquardtOptimizerTest.java (original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/LevenbergMarquardtOptimizerTest.java Thu Nov 25 16:22:00 2010
@@ -25,20 +25,19 @@ import java.util.List;
import junit.framework.TestCase;
-import org.apache.commons.math.analysis.DifferentiableMultivariateVectorialFunction;
-import org.apache.commons.math.analysis.MultivariateMatrixFunction;
+import org.apache.commons.math.exception.SingularMatrixException;
import org.apache.commons.math.exception.ConvergenceException;
import org.apache.commons.math.exception.DimensionMismatchException;
-import org.apache.commons.math.exception.MathUserException;
-import org.apache.commons.math.exception.NumberIsTooSmallException;
-import org.apache.commons.math.exception.SingularMatrixException;
import org.apache.commons.math.exception.TooManyEvaluationsException;
+import org.apache.commons.math.exception.NumberIsTooSmallException;
+import org.apache.commons.math.analysis.DifferentiableMultivariateVectorialFunction;
+import org.apache.commons.math.analysis.MultivariateMatrixFunction;
import org.apache.commons.math.linear.BlockRealMatrix;
import org.apache.commons.math.linear.RealMatrix;
import org.apache.commons.math.optimization.SimpleVectorialValueChecker;
import org.apache.commons.math.optimization.VectorialPointValuePair;
-import org.apache.commons.math.util.FastMath;
import org.apache.commons.math.util.MathUtils;
+import org.apache.commons.math.util.FastMath;
/**
* <p>Some of the unit tests are re-implementations of the MINPACK <a
@@ -109,7 +108,7 @@ public class LevenbergMarquardtOptimizer
super(name);
}
- public void testTrivial() throws MathUserException {
+ public void testTrivial() {
LinearProblem problem =
new LinearProblem(new double[][] { { 2 } }, new double[] { 3 });
LevenbergMarquardtOptimizer optimizer = new LevenbergMarquardtOptimizer();
@@ -126,7 +125,7 @@ public class LevenbergMarquardtOptimizer
assertEquals(3.0, optimum.getValue()[0], 1.0e-10);
}
- public void testQRColumnsPermutation() throws MathUserException {
+ public void testQRColumnsPermutation() {
LinearProblem problem =
new LinearProblem(new double[][] { { 1.0, -1.0 }, { 0.0, 2.0 }, { 1.0, -2.0 } },
@@ -143,7 +142,7 @@ public class LevenbergMarquardtOptimizer
assertEquals(1.0, optimum.getValue()[2], 1.0e-10);
}
- public void testNoDependency() throws MathUserException {
+ public void testNoDependency() {
LinearProblem problem = new LinearProblem(new double[][] {
{ 2, 0, 0, 0, 0, 0 },
{ 0, 2, 0, 0, 0, 0 },
@@ -162,7 +161,7 @@ public class LevenbergMarquardtOptimizer
}
}
- public void testOneSet() throws MathUserException {
+ public void testOneSet() {
LinearProblem problem = new LinearProblem(new double[][] {
{ 1, 0, 0 },
@@ -178,7 +177,7 @@ public class LevenbergMarquardtOptimizer
assertEquals(3.0, optimum.getPoint()[2], 1.0e-10);
}
- public void testTwoSets() throws MathUserException {
+ public void testTwoSets() {
double epsilon = 1.0e-7;
LinearProblem problem = new LinearProblem(new double[][] {
{ 2, 1, 0, 4, 0, 0 },
@@ -202,7 +201,7 @@ public class LevenbergMarquardtOptimizer
assertEquals( 1.0 - epsilon, optimum.getPoint()[5], 1.0e-10);
}
- public void testNonInvertible() throws MathUserException {
+ public void testNonInvertible() {
LinearProblem problem = new LinearProblem(new double[][] {
{ 1, 2, -3 },
@@ -221,7 +220,7 @@ public class LevenbergMarquardtOptimizer
}
}
- public void testIllConditioned() throws MathUserException {
+ public void testIllConditioned() {
LinearProblem problem1 = new LinearProblem(new double[][] {
{ 10.0, 7.0, 8.0, 7.0 },
{ 7.0, 5.0, 6.0, 5.0 },
@@ -254,7 +253,7 @@ public class LevenbergMarquardtOptimizer
assertEquals( 22.0, optimum2.getPoint()[3], 1.0e-8);
}
- public void testMoreEstimatedParametersSimple() throws MathUserException {
+ public void testMoreEstimatedParametersSimple() {
LinearProblem problem = new LinearProblem(new double[][] {
{ 3.0, 2.0, 0.0, 0.0 },
@@ -268,7 +267,7 @@ public class LevenbergMarquardtOptimizer
assertEquals(0, optimizer.getRMS(), 1.0e-10);
}
- public void testMoreEstimatedParametersUnsorted() throws MathUserException {
+ public void testMoreEstimatedParametersUnsorted() {
LinearProblem problem = new LinearProblem(new double[][] {
{ 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 },
{ 0.0, 0.0, 1.0, 1.0, 1.0, 0.0 },
@@ -288,7 +287,7 @@ public class LevenbergMarquardtOptimizer
assertEquals(6.0, optimum.getPointRef()[5], 1.0e-10);
}
- public void testRedundantEquations() throws MathUserException {
+ public void testRedundantEquations() {
LinearProblem problem = new LinearProblem(new double[][] {
{ 1.0, 1.0 },
{ 1.0, -1.0 },
@@ -304,7 +303,7 @@ public class LevenbergMarquardtOptimizer
assertEquals(1.0, optimum.getPointRef()[1], 1.0e-10);
}
- public void testInconsistentEquations() throws MathUserException {
+ public void testInconsistentEquations() {
LinearProblem problem = new LinearProblem(new double[][] {
{ 1.0, 1.0 },
{ 1.0, -1.0 },
@@ -316,7 +315,7 @@ public class LevenbergMarquardtOptimizer
assertTrue(optimizer.getRMS() > 0.1);
}
- public void testInconsistentSizes() throws MathUserException {
+ public void testInconsistentSizes() {
LinearProblem problem =
new LinearProblem(new double[][] { { 1, 0 }, { 0, 1 } }, new double[] { -1, 1 });
LevenbergMarquardtOptimizer optimizer = new LevenbergMarquardtOptimizer();
@@ -346,8 +345,8 @@ public class LevenbergMarquardtOptimizer
}
}
- public void testControlParameters() throws MathUserException {
- Circle circle = new Circle();
+ public void testControlParameters() {
+ CircleVectorial circle = new CircleVectorial();
circle.addPoint( 30.0, 68.0);
circle.addPoint( 50.0, -6.0);
circle.addPoint(110.0, -20.0);
@@ -363,7 +362,7 @@ public class LevenbergMarquardtOptimizer
private void checkEstimate(DifferentiableMultivariateVectorialFunction problem,
double initialStepBoundFactor, int maxCostEval,
double costRelativeTolerance, double parRelativeTolerance,
- double orthoTolerance, boolean shouldFail) throws MathUserException {
+ double orthoTolerance, boolean shouldFail) {
try {
LevenbergMarquardtOptimizer optimizer
= new LevenbergMarquardtOptimizer(initialStepBoundFactor,
@@ -382,8 +381,8 @@ public class LevenbergMarquardtOptimizer
}
}
- public void testCircleFitting() throws MathUserException {
- Circle circle = new Circle();
+ public void testCircleFitting() {
+ CircleVectorial circle = new CircleVectorial();
circle.addPoint( 30.0, 68.0);
circle.addPoint( 50.0, -6.0);
circle.addPoint(110.0, -20.0);
@@ -430,8 +429,8 @@ public class LevenbergMarquardtOptimizer
assertEquals(0.004, errors[1], 0.001);
}
- public void testCircleFittingBadInit() throws MathUserException {
- Circle circle = new Circle();
+ public void testCircleFittingBadInit() {
+ CircleVectorial circle = new CircleVectorial();
double[][] points = new double[][] {
{-0.312967, 0.072366}, {-0.339248, 0.132965}, {-0.379780, 0.202724},
{-0.390426, 0.260487}, {-0.361212, 0.328325}, {-0.346039, 0.392619},
@@ -483,7 +482,7 @@ public class LevenbergMarquardtOptimizer
assertEquals( 0.2075001, center.y, 1.0e-6);
}
- public void testMath199() throws MathUserException {
+ public void testMath199() {
try {
QuadraticProblem problem = new QuadraticProblem();
problem.addPoint (0, -3.182591015485607);
@@ -527,83 +526,6 @@ public class LevenbergMarquardtOptimizer
}
}
- private static class Circle implements DifferentiableMultivariateVectorialFunction, Serializable {
-
- private static final long serialVersionUID = -4711170319243817874L;
-
- private ArrayList<Point2D.Double> points;
-
- public Circle() {
- points = new ArrayList<Point2D.Double>();
- }
-
- public void addPoint(double px, double py) {
- points.add(new Point2D.Double(px, py));
- }
-
- public int getN() {
- return points.size();
- }
-
- public double getRadius(Point2D.Double center) {
- double r = 0;
- for (Point2D.Double point : points) {
- r += point.distance(center);
- }
- return r / points.size();
- }
-
- private double[][] jacobian(double[] point) {
-
- int n = points.size();
- Point2D.Double center = new Point2D.Double(point[0], point[1]);
-
- // gradient of the optimal radius
- double dRdX = 0;
- double dRdY = 0;
- for (Point2D.Double pk : points) {
- double dk = pk.distance(center);
- dRdX += (center.x - pk.x) / dk;
- dRdY += (center.y - pk.y) / dk;
- }
- dRdX /= n;
- dRdY /= n;
-
- // jacobian of the radius residuals
- double[][] jacobian = new double[n][2];
- for (int i = 0; i < n; ++i) {
- Point2D.Double pi = points.get(i);
- double di = pi.distance(center);
- jacobian[i][0] = (center.x - pi.x) / di - dRdX;
- jacobian[i][1] = (center.y - pi.y) / di - dRdY;
- }
-
- return jacobian;
- }
-
- public double[] value(double[] variables) {
-
- Point2D.Double center = new Point2D.Double(variables[0], variables[1]);
- double radius = getRadius(center);
-
- double[] residuals = new double[points.size()];
- for (int i = 0; i < residuals.length; ++i) {
- residuals[i] = points.get(i).distance(center) - radius;
- }
-
- return residuals;
- }
-
- public MultivariateMatrixFunction jacobian() {
- return new MultivariateMatrixFunction() {
- private static final long serialVersionUID = -4340046230875165095L;
- public double[][] value(double[] point) {
- return jacobian(point);
- }
- };
- }
- }
-
private static class QuadraticProblem implements DifferentiableMultivariateVectorialFunction, Serializable {
private static final long serialVersionUID = 7072187082052755854L;
Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/NonLinearConjugateGradientOptimizerTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/NonLinearConjugateGradientOptimizerTest.java?rev=1039083&r1=1039082&r2=1039083&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/NonLinearConjugateGradientOptimizerTest.java (original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/optimization/general/NonLinearConjugateGradientOptimizerTest.java Thu Nov 25 16:22:00 2010
@@ -21,18 +21,18 @@ import java.awt.geom.Point2D;
import java.io.Serializable;
import java.util.ArrayList;
-import junit.framework.TestCase;
-
import org.apache.commons.math.analysis.DifferentiableMultivariateRealFunction;
import org.apache.commons.math.analysis.MultivariateRealFunction;
import org.apache.commons.math.analysis.MultivariateVectorialFunction;
+import org.apache.commons.math.analysis.solvers.UnivariateRealSolver;
import org.apache.commons.math.analysis.solvers.BrentSolver;
-import org.apache.commons.math.exception.MathUserException;
import org.apache.commons.math.linear.BlockRealMatrix;
import org.apache.commons.math.linear.RealMatrix;
import org.apache.commons.math.optimization.GoalType;
import org.apache.commons.math.optimization.RealPointValuePair;
import org.apache.commons.math.optimization.SimpleScalarValueChecker;
+import org.junit.Assert;
+import org.junit.Test;
/**
* <p>Some of the unit tests are re-implementations of the MINPACK <a
@@ -96,14 +96,9 @@ import org.apache.commons.math.optimizat
* @author Jorge J. More (original fortran minpack tests)
* @author Luc Maisonobe (non-minpack tests and minpack tests Java translation)
*/
-public class NonLinearConjugateGradientOptimizerTest
-extends TestCase {
-
- public NonLinearConjugateGradientOptimizerTest(String name) {
- super(name);
- }
-
- public void testTrivial() throws MathUserException {
+public class NonLinearConjugateGradientOptimizerTest {
+ @Test
+ public void testTrivial() {
LinearProblem problem =
new LinearProblem(new double[][] { { 2 } }, new double[] { 3 });
NonLinearConjugateGradientOptimizer optimizer =
@@ -112,12 +107,12 @@ extends TestCase {
optimizer.setConvergenceChecker(new SimpleScalarValueChecker(1.0e-6, 1.0e-6));
RealPointValuePair optimum =
optimizer.optimize(problem, GoalType.MINIMIZE, new double[] { 0 });
- assertEquals(1.5, optimum.getPoint()[0], 1.0e-10);
- assertEquals(0.0, optimum.getValue(), 1.0e-10);
+ Assert.assertEquals(1.5, optimum.getPoint()[0], 1.0e-10);
+ Assert.assertEquals(0.0, optimum.getValue(), 1.0e-10);
}
- public void testColumnsPermutation() throws MathUserException {
-
+ @Test
+ public void testColumnsPermutation() {
LinearProblem problem =
new LinearProblem(new double[][] { { 1.0, -1.0 }, { 0.0, 2.0 }, { 1.0, -2.0 } },
new double[] { 4.0, 6.0, 1.0 });
@@ -128,13 +123,14 @@ extends TestCase {
optimizer.setConvergenceChecker(new SimpleScalarValueChecker(1.0e-6, 1.0e-6));
RealPointValuePair optimum =
optimizer.optimize(problem, GoalType.MINIMIZE, new double[] { 0, 0 });
- assertEquals(7.0, optimum.getPoint()[0], 1.0e-10);
- assertEquals(3.0, optimum.getPoint()[1], 1.0e-10);
- assertEquals(0.0, optimum.getValue(), 1.0e-10);
+ Assert.assertEquals(7.0, optimum.getPoint()[0], 1.0e-10);
+ Assert.assertEquals(3.0, optimum.getPoint()[1], 1.0e-10);
+ Assert.assertEquals(0.0, optimum.getValue(), 1.0e-10);
}
- public void testNoDependency() throws MathUserException {
+ @Test
+ public void testNoDependency() {
LinearProblem problem = new LinearProblem(new double[][] {
{ 2, 0, 0, 0, 0, 0 },
{ 0, 2, 0, 0, 0, 0 },
@@ -150,12 +146,12 @@ extends TestCase {
RealPointValuePair optimum =
optimizer.optimize(problem, GoalType.MINIMIZE, new double[] { 0, 0, 0, 0, 0, 0 });
for (int i = 0; i < problem.target.length; ++i) {
- assertEquals(0.55 * i, optimum.getPoint()[i], 1.0e-10);
+ Assert.assertEquals(0.55 * i, optimum.getPoint()[i], 1.0e-10);
}
}
- public void testOneSet() throws MathUserException {
-
+ @Test
+ public void testOneSet() {
LinearProblem problem = new LinearProblem(new double[][] {
{ 1, 0, 0 },
{ -1, 1, 0 },
@@ -167,13 +163,14 @@ extends TestCase {
optimizer.setConvergenceChecker(new SimpleScalarValueChecker(1.0e-6, 1.0e-6));
RealPointValuePair optimum =
optimizer.optimize(problem, GoalType.MINIMIZE, new double[] { 0, 0, 0 });
- assertEquals(1.0, optimum.getPoint()[0], 1.0e-10);
- assertEquals(2.0, optimum.getPoint()[1], 1.0e-10);
- assertEquals(3.0, optimum.getPoint()[2], 1.0e-10);
+ Assert.assertEquals(1.0, optimum.getPoint()[0], 1.0e-10);
+ Assert.assertEquals(2.0, optimum.getPoint()[1], 1.0e-10);
+ Assert.assertEquals(3.0, optimum.getPoint()[2], 1.0e-10);
}
- public void testTwoSets() throws MathUserException {
+ @Test
+ public void testTwoSets() {
final double epsilon = 1.0e-7;
LinearProblem problem = new LinearProblem(new double[][] {
{ 2, 1, 0, 4, 0, 0 },
@@ -203,17 +200,17 @@ extends TestCase {
RealPointValuePair optimum =
optimizer.optimize(problem, GoalType.MINIMIZE, new double[] { 0, 0, 0, 0, 0, 0 });
- assertEquals( 3.0, optimum.getPoint()[0], 1.0e-10);
- assertEquals( 4.0, optimum.getPoint()[1], 1.0e-10);
- assertEquals(-1.0, optimum.getPoint()[2], 1.0e-10);
- assertEquals(-2.0, optimum.getPoint()[3], 1.0e-10);
- assertEquals( 1.0 + epsilon, optimum.getPoint()[4], 1.0e-10);
- assertEquals( 1.0 - epsilon, optimum.getPoint()[5], 1.0e-10);
+ Assert.assertEquals( 3.0, optimum.getPoint()[0], 1.0e-10);
+ Assert.assertEquals( 4.0, optimum.getPoint()[1], 1.0e-10);
+ Assert.assertEquals(-1.0, optimum.getPoint()[2], 1.0e-10);
+ Assert.assertEquals(-2.0, optimum.getPoint()[3], 1.0e-10);
+ Assert.assertEquals( 1.0 + epsilon, optimum.getPoint()[4], 1.0e-10);
+ Assert.assertEquals( 1.0 - epsilon, optimum.getPoint()[5], 1.0e-10);
}
- public void testNonInversible() throws MathUserException {
-
+ @Test
+ public void testNonInversible() {
LinearProblem problem = new LinearProblem(new double[][] {
{ 1, 2, -3 },
{ 2, 1, 3 },
@@ -225,10 +222,11 @@ extends TestCase {
optimizer.setConvergenceChecker(new SimpleScalarValueChecker(1.0e-6, 1.0e-6));
RealPointValuePair optimum =
optimizer.optimize(problem, GoalType.MINIMIZE, new double[] { 0, 0, 0 });
- assertTrue(optimum.getValue() > 0.5);
+ Assert.assertTrue(optimum.getValue() > 0.5);
}
- public void testIllConditioned() throws MathUserException {
+ @Test
+ public void testIllConditioned() {
LinearProblem problem1 = new LinearProblem(new double[][] {
{ 10.0, 7.0, 8.0, 7.0 },
{ 7.0, 5.0, 6.0, 5.0 },
@@ -239,16 +237,14 @@ extends TestCase {
new NonLinearConjugateGradientOptimizer(ConjugateGradientFormula.POLAK_RIBIERE);
optimizer.setMaxEvaluations(100);
optimizer.setConvergenceChecker(new SimpleScalarValueChecker(1.0e-13, 1.0e-13));
- BrentSolver solver = new BrentSolver();
- solver.setAbsoluteAccuracy(1.0e-15);
- solver.setRelativeAccuracy(1.0e-15);
+ BrentSolver solver = new BrentSolver(1e-15, 1e-15);
optimizer.setLineSearchSolver(solver);
RealPointValuePair optimum1 =
optimizer.optimize(problem1, GoalType.MINIMIZE, new double[] { 0, 1, 2, 3 });
- assertEquals(1.0, optimum1.getPoint()[0], 1.0e-5);
- assertEquals(1.0, optimum1.getPoint()[1], 1.0e-5);
- assertEquals(1.0, optimum1.getPoint()[2], 1.0e-5);
- assertEquals(1.0, optimum1.getPoint()[3], 1.0e-5);
+ Assert.assertEquals(1.0, optimum1.getPoint()[0], 1.0e-4);
+ Assert.assertEquals(1.0, optimum1.getPoint()[1], 1.0e-4);
+ Assert.assertEquals(1.0, optimum1.getPoint()[2], 1.0e-4);
+ Assert.assertEquals(1.0, optimum1.getPoint()[3], 1.0e-4);
LinearProblem problem2 = new LinearProblem(new double[][] {
{ 10.00, 7.00, 8.10, 7.20 },
@@ -258,16 +254,15 @@ extends TestCase {
}, new double[] { 32, 23, 33, 31 });
RealPointValuePair optimum2 =
optimizer.optimize(problem2, GoalType.MINIMIZE, new double[] { 0, 1, 2, 3 });
- assertEquals(-81.0, optimum2.getPoint()[0], 1.0e-1);
- assertEquals(137.0, optimum2.getPoint()[1], 1.0e-1);
- assertEquals(-34.0, optimum2.getPoint()[2], 1.0e-1);
- assertEquals( 22.0, optimum2.getPoint()[3], 1.0e-1);
+ Assert.assertEquals(-81.0, optimum2.getPoint()[0], 1.0e-1);
+ Assert.assertEquals(137.0, optimum2.getPoint()[1], 1.0e-1);
+ Assert.assertEquals(-34.0, optimum2.getPoint()[2], 1.0e-1);
+ Assert.assertEquals( 22.0, optimum2.getPoint()[3], 1.0e-1);
}
- public void testMoreEstimatedParametersSimple()
- throws MathUserException {
-
+ @Test
+ public void testMoreEstimatedParametersSimple() {
LinearProblem problem = new LinearProblem(new double[][] {
{ 3.0, 2.0, 0.0, 0.0 },
{ 0.0, 1.0, -1.0, 1.0 },
@@ -280,12 +275,12 @@ extends TestCase {
optimizer.setConvergenceChecker(new SimpleScalarValueChecker(1.0e-6, 1.0e-6));
RealPointValuePair optimum =
optimizer.optimize(problem, GoalType.MINIMIZE, new double[] { 7, 6, 5, 4 });
- assertEquals(0, optimum.getValue(), 1.0e-10);
+ Assert.assertEquals(0, optimum.getValue(), 1.0e-10);
}
- public void testMoreEstimatedParametersUnsorted()
- throws MathUserException {
+ @Test
+ public void testMoreEstimatedParametersUnsorted() {
LinearProblem problem = new LinearProblem(new double[][] {
{ 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 },
{ 0.0, 0.0, 1.0, 1.0, 1.0, 0.0 },
@@ -299,10 +294,11 @@ extends TestCase {
optimizer.setConvergenceChecker(new SimpleScalarValueChecker(1.0e-6, 1.0e-6));
RealPointValuePair optimum =
optimizer.optimize(problem, GoalType.MINIMIZE, new double[] { 2, 2, 2, 2, 2, 2 });
- assertEquals(0, optimum.getValue(), 1.0e-10);
+ Assert.assertEquals(0, optimum.getValue(), 1.0e-10);
}
- public void testRedundantEquations() throws MathUserException {
+ @Test
+ public void testRedundantEquations() {
LinearProblem problem = new LinearProblem(new double[][] {
{ 1.0, 1.0 },
{ 1.0, -1.0 },
@@ -315,12 +311,13 @@ extends TestCase {
optimizer.setConvergenceChecker(new SimpleScalarValueChecker(1.0e-6, 1.0e-6));
RealPointValuePair optimum =
optimizer.optimize(problem, GoalType.MINIMIZE, new double[] { 1, 1 });
- assertEquals(2.0, optimum.getPoint()[0], 1.0e-8);
- assertEquals(1.0, optimum.getPoint()[1], 1.0e-8);
+ Assert.assertEquals(2.0, optimum.getPoint()[0], 1.0e-8);
+ Assert.assertEquals(1.0, optimum.getPoint()[1], 1.0e-8);
}
- public void testInconsistentEquations() throws MathUserException {
+ @Test
+ public void testInconsistentEquations() {
LinearProblem problem = new LinearProblem(new double[][] {
{ 1.0, 1.0 },
{ 1.0, -1.0 },
@@ -333,12 +330,13 @@ extends TestCase {
optimizer.setConvergenceChecker(new SimpleScalarValueChecker(1.0e-6, 1.0e-6));
RealPointValuePair optimum =
optimizer.optimize(problem, GoalType.MINIMIZE, new double[] { 1, 1 });
- assertTrue(optimum.getValue() > 0.1);
+ Assert.assertTrue(optimum.getValue() > 0.1);
}
- public void testCircleFitting() throws MathUserException {
- Circle circle = new Circle();
+ @Test
+ public void testCircleFitting() {
+ CircleScalar circle = new CircleScalar();
circle.addPoint( 30.0, 68.0);
circle.addPoint( 50.0, -6.0);
circle.addPoint(110.0, -20.0);
@@ -348,16 +346,14 @@ extends TestCase {
new NonLinearConjugateGradientOptimizer(ConjugateGradientFormula.POLAK_RIBIERE);
optimizer.setMaxEvaluations(100);
optimizer.setConvergenceChecker(new SimpleScalarValueChecker(1.0e-30, 1.0e-30));
- BrentSolver solver = new BrentSolver();
- solver.setAbsoluteAccuracy(1.0e-13);
- solver.setRelativeAccuracy(1.0e-15);
+ UnivariateRealSolver solver = new BrentSolver(1e-15, 1e-13);
optimizer.setLineSearchSolver(solver);
RealPointValuePair optimum =
optimizer.optimize(circle, GoalType.MINIMIZE, new double[] { 98.680, 47.345 });
Point2D.Double center = new Point2D.Double(optimum.getPointRef()[0], optimum.getPointRef()[1]);
- assertEquals(69.960161753, circle.getRadius(center), 1.0e-8);
- assertEquals(96.075902096, center.x, 1.0e-8);
- assertEquals(48.135167894, center.y, 1.0e-8);
+ Assert.assertEquals(69.960161753, circle.getRadius(center), 1.0e-8);
+ Assert.assertEquals(96.075902096, center.x, 1.0e-8);
+ Assert.assertEquals(48.135167894, center.y, 1.0e-8);
}
private static class LinearProblem implements DifferentiableMultivariateRealFunction, Serializable {
@@ -382,7 +378,7 @@ extends TestCase {
return p;
}
- public double value(double[] variables) throws MathUserException {
+ public double value(double[] variables) {
double[] y = factors.operate(variables);
double sum = 0;
for (int i = 0; i < y.length; ++i) {
@@ -409,86 +405,5 @@ extends TestCase {
}
};
}
-
- }
-
- private static class Circle implements DifferentiableMultivariateRealFunction, Serializable {
-
- private static final long serialVersionUID = -4711170319243817874L;
-
- private ArrayList<Point2D.Double> points;
-
- public Circle() {
- points = new ArrayList<Point2D.Double>();
- }
-
- public void addPoint(double px, double py) {
- points.add(new Point2D.Double(px, py));
- }
-
- public double getRadius(Point2D.Double center) {
- double r = 0;
- for (Point2D.Double point : points) {
- r += point.distance(center);
- }
- return r / points.size();
- }
-
- private double[] gradient(double[] point) {
-
- // optimal radius
- Point2D.Double center = new Point2D.Double(point[0], point[1]);
- double radius = getRadius(center);
-
- // gradient of the sum of squared residuals
- double dJdX = 0;
- double dJdY = 0;
- for (Point2D.Double pk : points) {
- double dk = pk.distance(center);
- dJdX += (center.x - pk.x) * (dk - radius) / dk;
- dJdY += (center.y - pk.y) * (dk - radius) / dk;
- }
- dJdX *= 2;
- dJdY *= 2;
-
- return new double[] { dJdX, dJdY };
-
- }
-
- public double value(double[] variables)
- throws IllegalArgumentException, MathUserException {
-
- Point2D.Double center = new Point2D.Double(variables[0], variables[1]);
- double radius = getRadius(center);
-
- double sum = 0;
- for (Point2D.Double point : points) {
- double di = point.distance(center) - radius;
- sum += di * di;
- }
-
- return sum;
-
- }
-
- public MultivariateVectorialFunction gradient() {
- return new MultivariateVectorialFunction() {
- private static final long serialVersionUID = 3174909643301201710L;
- public double[] value(double[] point) {
- return gradient(point);
- }
- };
- }
-
- public MultivariateRealFunction partialDerivative(final int k) {
- return new MultivariateRealFunction() {
- private static final long serialVersionUID = 3073956364104833888L;
- public double value(double[] point) {
- return gradient(point)[k];
- }
- };
- }
-
}
-
}