This is an automated email from the ASF dual-hosted git repository.
erans pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-math.git
commit 46a0c3ae4140fd34cf8479362192bddb7b7b3e38
Author: Gilles Sadowski <gillese...@gmail.com>
AuthorDate: Sun Jul 11 02:10:11 2021 +0200
MATH-1614: Refactoring of "SimplexOptimizer".
Class "Simplex" supersedes "AbstractSimplex" whose subclasses are replaced
by implementations of the "Simplex.TransformFactory" interface.
The new classes are immutable.
Test suite has been updated.
It tries to assess correctness through randomization; however some standard
optimization problems entail systematic failures that were previously hidden
through using fixed seeds. [The corresponding unit tests are skipped, and
further work is needed in order to find out whether those problems are too
hard for the algorithm or the issue lies elsewhere.]
---
.../nonlinear/scalar/noderiv/AbstractSimplex.java | 345 ---------------------
.../scalar/noderiv/MultiDirectionalSimplex.java | 215 -------------
.../scalar/noderiv/MultiDirectionalTransform.java | 130 ++++++++
.../scalar/noderiv/NelderMeadSimplex.java | 280 -----------------
.../scalar/noderiv/NelderMeadTransform.java | 183 +++++++++++
.../optim/nonlinear/scalar/noderiv/Simplex.java | 304 ++++++++++++++++++
.../nonlinear/scalar/noderiv/SimplexOptimizer.java | 109 +++----
.../MultiStartMultivariateOptimizerTest.java | 7 +-
.../MultivariateFunctionMappingAdapterTest.java | 16 +-
.../MultivariateFunctionPenaltyAdapterTest.java | 26 +-
.../nonlinear/scalar/noderiv/OptimTestUtils.java | 46 ++-
.../SimplexOptimizerMultiDirectionalTest.java | 314 +++++++++----------
.../noderiv/SimplexOptimizerNelderMeadTest.java | 307 +++++++++---------
13 files changed, 1018 insertions(+), 1264 deletions(-)
diff --git
a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/AbstractSimplex.java
b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/AbstractSimplex.java
deleted file mode 100644
index bd1d555..0000000
---
a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/AbstractSimplex.java
+++ /dev/null
@@ -1,345 +0,0 @@
-/*
- * 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.math4.legacy.optim.nonlinear.scalar.noderiv;
-
-import java.util.Arrays;
-import java.util.Comparator;
-
-import org.apache.commons.math4.legacy.analysis.MultivariateFunction;
-import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
-import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
-import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
-import org.apache.commons.math4.legacy.exception.NullArgumentException;
-import org.apache.commons.math4.legacy.exception.OutOfRangeException;
-import org.apache.commons.math4.legacy.exception.ZeroException;
-import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.optim.OptimizationData;
-import org.apache.commons.math4.legacy.optim.PointValuePair;
-
-/**
- * This class implements the simplex concept.
- * It is intended to be used in conjunction with {@link SimplexOptimizer}.
- * <br>
- * The initial configuration of the simplex is set by the constructors
- * {@link #AbstractSimplex(double[])} or {@link #AbstractSimplex(double[][])}.
- * The other {@link #AbstractSimplex(int) constructor} will set all steps
- * to 1, thus building a default configuration from a unit hypercube.
- * <br>
- * Users <em>must</em> call the {@link #build(double[]) build} method in order
- * to create the data structure that will be acted on by the other methods of
- * this class.
- *
- * @see SimplexOptimizer
- * @since 3.0
- */
-public abstract class AbstractSimplex implements OptimizationData {
- /** Simplex. */
- private PointValuePair[] simplex;
- /** Start simplex configuration. */
- private double[][] startConfiguration;
- /** Simplex dimension (must be equal to {@code simplex.length - 1}). */
- private final int dimension;
-
- /**
- * Build a unit hypercube simplex.
- *
- * @param n Dimension of the simplex.
- */
- protected AbstractSimplex(int n) {
- this(n, 1d);
- }
-
- /**
- * Build a hypercube simplex with the given side length.
- *
- * @param n Dimension of the simplex.
- * @param sideLength Length of the sides of the hypercube.
- */
- protected AbstractSimplex(int n,
- double sideLength) {
- this(createHypercubeSteps(n, sideLength));
- }
-
- /**
- * The start configuration for simplex is built from a box parallel to
- * the canonical axes of the space. The simplex is the subset of vertices
- * of a box parallel to the canonical axes. It is built as the path
followed
- * while traveling from one vertex of the box to the diagonally opposite
- * vertex moving only along the box edges. The first vertex of the box will
- * be located at the start point of the optimization.
- * As an example, in dimension 3 a simplex has 4 vertices. Setting the
- * steps to (1, 10, 2) and the start point to (1, 1, 1) would imply the
- * start simplex would be: { (1, 1, 1), (2, 1, 1), (2, 11, 1), (2, 11, 3)
}.
- * The first vertex would be set to the start point at (1, 1, 1) and the
- * last vertex would be set to the diagonally opposite vertex at (2, 11,
3).
- *
- * @param steps Steps along the canonical axes representing box edges. They
- * may be negative but not zero.
- * @throws NullArgumentException if {@code steps} is {@code null}.
- * @throws ZeroException if one of the steps is zero.
- */
- protected AbstractSimplex(final double[] steps) {
- if (steps == null) {
- throw new NullArgumentException();
- }
- if (steps.length == 0) {
- throw new ZeroException();
- }
- dimension = steps.length;
-
- // Only the relative position of the n final vertices with respect
- // to the first one are stored.
- startConfiguration = new double[dimension][dimension];
- for (int i = 0; i < dimension; i++) {
- final double[] vertexI = startConfiguration[i];
- for (int j = 0; j < i + 1; j++) {
- if (steps[j] == 0) {
- throw new
ZeroException(LocalizedFormats.EQUAL_VERTICES_IN_SIMPLEX);
- }
- System.arraycopy(steps, 0, vertexI, 0, j + 1);
- }
- }
- }
-
- /**
- * The real initial simplex will be set up by moving the reference
- * simplex such that its first point is located at the start point of the
- * optimization.
- *
- * @param referenceSimplex Reference simplex.
- * @throws NotStrictlyPositiveException if the reference simplex does not
- * contain at least one point.
- * @throws DimensionMismatchException if there is a dimension mismatch
- * in the reference simplex.
- * @throws IllegalArgumentException if one of its vertices is duplicated.
- */
- protected AbstractSimplex(final double[][] referenceSimplex) {
- if (referenceSimplex.length <= 0) {
- throw new
NotStrictlyPositiveException(LocalizedFormats.SIMPLEX_NEED_ONE_POINT,
- referenceSimplex.length);
- }
- dimension = referenceSimplex.length - 1;
-
- // Only the relative position of the n final vertices with respect
- // to the first one are stored.
- startConfiguration = new double[dimension][dimension];
- final double[] ref0 = referenceSimplex[0];
-
- // Loop over vertices.
- for (int i = 0; i < referenceSimplex.length; i++) {
- final double[] refI = referenceSimplex[i];
-
- // Safety checks.
- if (refI.length != dimension) {
- throw new DimensionMismatchException(refI.length, dimension);
- }
- for (int j = 0; j < i; j++) {
- final double[] refJ = referenceSimplex[j];
- boolean allEquals = true;
- for (int k = 0; k < dimension; k++) {
- if (refI[k] != refJ[k]) {
- allEquals = false;
- break;
- }
- }
- if (allEquals) {
- throw new
MathIllegalArgumentException(LocalizedFormats.EQUAL_VERTICES_IN_SIMPLEX,
- i, j);
- }
- }
-
- // Store vertex i position relative to vertex 0 position.
- if (i > 0) {
- final double[] confI = startConfiguration[i - 1];
- for (int k = 0; k < dimension; k++) {
- confI[k] = refI[k] - ref0[k];
- }
- }
- }
- }
-
- /**
- * Get simplex dimension.
- *
- * @return the dimension of the simplex.
- */
- public int getDimension() {
- return dimension;
- }
-
- /**
- * Get simplex size.
- * After calling the {@link #build(double[]) build} method, this method
will
- * will be equivalent to {@code getDimension() + 1}.
- *
- * @return the size of the simplex.
- */
- public int getSize() {
- return simplex.length;
- }
-
- /**
- * Compute the next simplex of the algorithm.
- *
- * @param evaluationFunction Evaluation function.
- * @param comparator Comparator to use to sort simplex vertices from best
- * to worst.
- * @throws
org.apache.commons.math4.legacy.exception.TooManyEvaluationsException
- * if the algorithm fails to converge.
- */
- public abstract void iterate(MultivariateFunction evaluationFunction,
- Comparator<PointValuePair> comparator);
-
- /**
- * Build an initial simplex.
- *
- * @param startPoint First point of the simplex.
- * @throws DimensionMismatchException if the start point does not match
- * simplex dimension.
- */
- public void build(final double[] startPoint) {
- if (dimension != startPoint.length) {
- throw new DimensionMismatchException(dimension, startPoint.length);
- }
-
- // Set first vertex.
- simplex = new PointValuePair[dimension + 1];
- simplex[0] = new PointValuePair(startPoint, Double.NaN);
-
- // Set remaining vertices.
- for (int i = 0; i < dimension; i++) {
- final double[] confI = startConfiguration[i];
- final double[] vertexI = new double[dimension];
- for (int k = 0; k < dimension; k++) {
- vertexI[k] = startPoint[k] + confI[k];
- }
- simplex[i + 1] = new PointValuePair(vertexI, Double.NaN);
- }
- }
-
- /**
- * Evaluate all the non-evaluated points of the simplex.
- *
- * @param evaluationFunction Evaluation function.
- * @param comparator Comparator to use to sort simplex vertices from best
to worst.
- * @throws
org.apache.commons.math4.legacy.exception.TooManyEvaluationsException
- * if the maximal number of evaluations is exceeded.
- */
- public void evaluate(final MultivariateFunction evaluationFunction,
- final Comparator<PointValuePair> comparator) {
- // Evaluate the objective function at all non-evaluated simplex points.
- for (int i = 0; i < simplex.length; i++) {
- final PointValuePair vertex = simplex[i];
- final double[] point = vertex.getPointRef();
- if (Double.isNaN(vertex.getValue())) {
- simplex[i] = new PointValuePair(point,
evaluationFunction.value(point), false);
- }
- }
-
- // Sort the simplex from best to worst.
- Arrays.sort(simplex, comparator);
- }
-
- /**
- * Replace the worst point of the simplex by a new point.
- *
- * @param pointValuePair Point to insert.
- * @param comparator Comparator to use for sorting the simplex vertices
- * from best to worst.
- */
- protected void replaceWorstPoint(PointValuePair pointValuePair,
- final Comparator<PointValuePair>
comparator) {
- for (int i = 0; i < dimension; i++) {
- if (comparator.compare(simplex[i], pointValuePair) > 0) {
- PointValuePair tmp = simplex[i];
- simplex[i] = pointValuePair;
- pointValuePair = tmp;
- }
- }
- simplex[dimension] = pointValuePair;
- }
-
- /**
- * Get the points of the simplex.
- *
- * @return all the simplex points.
- */
- public PointValuePair[] getPoints() {
- final PointValuePair[] copy = new PointValuePair[simplex.length];
- System.arraycopy(simplex, 0, copy, 0, simplex.length);
- return copy;
- }
-
- /**
- * Get the simplex point stored at the requested {@code index}.
- *
- * @param index Location.
- * @return the point at location {@code index}.
- */
- public PointValuePair getPoint(int index) {
- if (index < 0 ||
- index >= simplex.length) {
- throw new OutOfRangeException(index, 0, simplex.length - 1);
- }
- return simplex[index];
- }
-
- /**
- * Store a new point at location {@code index}.
- * Note that no deep-copy of {@code point} is performed.
- *
- * @param index Location.
- * @param point New value.
- */
- protected void setPoint(int index, PointValuePair point) {
- if (index < 0 ||
- index >= simplex.length) {
- throw new OutOfRangeException(index, 0, simplex.length - 1);
- }
- simplex[index] = point;
- }
-
- /**
- * Replace all points.
- * Note that no deep-copy of {@code points} is performed.
- *
- * @param points New Points.
- */
- protected void setPoints(PointValuePair[] points) {
- if (points.length != simplex.length) {
- throw new DimensionMismatchException(points.length,
simplex.length);
- }
- simplex = points;
- }
-
- /**
- * Create steps for a unit hypercube.
- *
- * @param n Dimension of the hypercube.
- * @param sideLength Length of the sides of the hypercube.
- * @return the steps.
- */
- private static double[] createHypercubeSteps(int n,
- double sideLength) {
- final double[] steps = new double[n];
- for (int i = 0; i < n; i++) {
- steps[i] = sideLength;
- }
- return steps;
- }
-}
diff --git
a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/MultiDirectionalSimplex.java
b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/MultiDirectionalSimplex.java
deleted file mode 100644
index da47eaa..0000000
---
a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/MultiDirectionalSimplex.java
+++ /dev/null
@@ -1,215 +0,0 @@
-/*
- * 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.math4.legacy.optim.nonlinear.scalar.noderiv;
-
-import java.util.Comparator;
-
-import org.apache.commons.math4.legacy.analysis.MultivariateFunction;
-import org.apache.commons.math4.legacy.optim.PointValuePair;
-
-/**
- * This class implements the multi-directional direct search method.
- *
- * @since 3.0
- */
-public class MultiDirectionalSimplex extends AbstractSimplex {
- /** Default value for {@link #khi}: {@value}. */
- private static final double DEFAULT_KHI = 2;
- /** Default value for {@link #gamma}: {@value}. */
- private static final double DEFAULT_GAMMA = 0.5;
- /** Expansion coefficient. */
- private final double khi;
- /** Contraction coefficient. */
- private final double gamma;
-
- /**
- * Build a multi-directional simplex with default coefficients.
- * The default values are 2.0 for khi and 0.5 for gamma.
- *
- * @param n Dimension of the simplex.
- */
- public MultiDirectionalSimplex(final int n) {
- this(n, 1d);
- }
-
- /**
- * Build a multi-directional simplex with default coefficients.
- * The default values are 2.0 for khi and 0.5 for gamma.
- *
- * @param n Dimension of the simplex.
- * @param sideLength Length of the sides of the default (hypercube)
- * simplex. See {@link AbstractSimplex#AbstractSimplex(int,double)}.
- */
- public MultiDirectionalSimplex(final int n, double sideLength) {
- this(n, sideLength, DEFAULT_KHI, DEFAULT_GAMMA);
- }
-
- /**
- * Build a multi-directional simplex with specified coefficients.
- *
- * @param n Dimension of the simplex. See
- * {@link AbstractSimplex#AbstractSimplex(int,double)}.
- * @param khi Expansion coefficient.
- * @param gamma Contraction coefficient.
- */
- public MultiDirectionalSimplex(final int n,
- final double khi, final double gamma) {
- this(n, 1d, khi, gamma);
- }
-
- /**
- * Build a multi-directional simplex with specified coefficients.
- *
- * @param n Dimension of the simplex. See
- * {@link AbstractSimplex#AbstractSimplex(int,double)}.
- * @param sideLength Length of the sides of the default (hypercube)
- * simplex. See {@link AbstractSimplex#AbstractSimplex(int,double)}.
- * @param khi Expansion coefficient.
- * @param gamma Contraction coefficient.
- */
- public MultiDirectionalSimplex(final int n, double sideLength,
- final double khi, final double gamma) {
- super(n, sideLength);
-
- this.khi = khi;
- this.gamma = gamma;
- }
-
- /**
- * Build a multi-directional simplex with default coefficients.
- * The default values are 2.0 for khi and 0.5 for gamma.
- *
- * @param steps Steps along the canonical axes representing box edges.
- * They may be negative but not zero. See
- */
- public MultiDirectionalSimplex(final double[] steps) {
- this(steps, DEFAULT_KHI, DEFAULT_GAMMA);
- }
-
- /**
- * Build a multi-directional simplex with specified coefficients.
- *
- * @param steps Steps along the canonical axes representing box edges.
- * They may be negative but not zero. See
- * {@link AbstractSimplex#AbstractSimplex(double[])}.
- * @param khi Expansion coefficient.
- * @param gamma Contraction coefficient.
- */
- public MultiDirectionalSimplex(final double[] steps,
- final double khi, final double gamma) {
- super(steps);
-
- this.khi = khi;
- this.gamma = gamma;
- }
-
- /**
- * Build a multi-directional simplex with default coefficients.
- * The default values are 2.0 for khi and 0.5 for gamma.
- *
- * @param referenceSimplex Reference simplex. See
- * {@link AbstractSimplex#AbstractSimplex(double[][])}.
- */
- public MultiDirectionalSimplex(final double[][] referenceSimplex) {
- this(referenceSimplex, DEFAULT_KHI, DEFAULT_GAMMA);
- }
-
- /**
- * Build a multi-directional simplex with specified coefficients.
- *
- * @param referenceSimplex Reference simplex. See
- * {@link AbstractSimplex#AbstractSimplex(double[][])}.
- * @param khi Expansion coefficient.
- * @param gamma Contraction coefficient.
- * @throws
org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException
- * if the reference simplex does not contain at least one point.
- * @throws
org.apache.commons.math4.legacy.exception.DimensionMismatchException
- * if there is a dimension mismatch in the reference simplex.
- */
- public MultiDirectionalSimplex(final double[][] referenceSimplex,
- final double khi, final double gamma) {
- super(referenceSimplex);
-
- this.khi = khi;
- this.gamma = gamma;
- }
-
- /** {@inheritDoc} */
- @Override
- public void iterate(final MultivariateFunction evaluationFunction,
- final Comparator<PointValuePair> comparator) {
- // Save the original simplex.
- final PointValuePair[] original = getPoints();
- final PointValuePair best = original[0];
-
- // Perform a reflection step.
- final PointValuePair reflected = evaluateNewSimplex(evaluationFunction,
- original, 1,
comparator);
- if (comparator.compare(reflected, best) < 0) {
- // Compute the expanded simplex.
- final PointValuePair[] reflectedSimplex = getPoints();
- final PointValuePair expanded =
evaluateNewSimplex(evaluationFunction,
- original,
khi, comparator);
- if (comparator.compare(reflected, expanded) <= 0) {
- // Keep the reflected simplex.
- setPoints(reflectedSimplex);
- }
- // Keep the expanded simplex.
- return;
- }
-
- // Compute the contracted simplex.
- evaluateNewSimplex(evaluationFunction, original, gamma, comparator);
-
- }
-
- /**
- * Compute and evaluate a new simplex.
- *
- * @param evaluationFunction Evaluation function.
- * @param original Original simplex (to be preserved).
- * @param coeff Linear coefficient.
- * @param comparator Comparator to use to sort simplex vertices from best
- * to poorest.
- * @return the best point in the transformed simplex.
- * @throws
org.apache.commons.math4.legacy.exception.TooManyEvaluationsException
- * if the maximal number of evaluations is exceeded.
- */
- private PointValuePair evaluateNewSimplex(final MultivariateFunction
evaluationFunction,
- final PointValuePair[]
original,
- final double coeff,
- final
Comparator<PointValuePair> comparator) {
- final double[] xSmallest = original[0].getPointRef();
- // Perform a linear transformation on all the simplex points,
- // except the first one.
- setPoint(0, original[0]);
- final int dim = getDimension();
- for (int i = 1; i < getSize(); i++) {
- final double[] xOriginal = original[i].getPointRef();
- final double[] xTransformed = new double[dim];
- for (int j = 0; j < dim; j++) {
- xTransformed[j] = xSmallest[j] + coeff * (xSmallest[j] -
xOriginal[j]);
- }
- setPoint(i, new PointValuePair(xTransformed, Double.NaN, false));
- }
-
- // Evaluate the simplex.
- evaluate(evaluationFunction, comparator);
-
- return getPoint(0);
- }
-}
diff --git
a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/MultiDirectionalTransform.java
b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/MultiDirectionalTransform.java
new file mode 100644
index 0000000..4cceb72
--- /dev/null
+++
b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/MultiDirectionalTransform.java
@@ -0,0 +1,130 @@
+/*
+ * 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.math4.legacy.optim.nonlinear.scalar.noderiv;
+
+import java.util.Comparator;
+import java.util.function.BiFunction;
+import java.util.function.UnaryOperator;
+
+import org.apache.commons.math4.legacy.analysis.MultivariateFunction;
+import org.apache.commons.math4.legacy.optim.PointValuePair;
+import org.apache.commons.math4.legacy.optim.OptimizationData;
+
+/**
+ * Multi-directional search method.
+ */
+public class MultiDirectionalTransform
+ implements Simplex.TransformFactory,
+ OptimizationData {
+ /** Default value for {@link #gamma}: {@value}. */
+ private static final double DEFAULT_GAMMA = 2;
+ /** Default value for {@link #rho}: {@value}. */
+ private static final double DEFAULT_RHO = 0.5;
+ /** Expansion coefficient. */
+ private final double gamma;
+ /** Contraction coefficient. */
+ private final double rho;
+
+ /**
+ * @param gamma Expansion coefficient.
+ * @param rho Contraction coefficient.
+ */
+ public MultiDirectionalTransform(double gamma,
+ double rho) {
+ this.gamma = gamma;
+ this.rho = rho;
+ }
+
+ /**
+ * Transform with default values.
+ */
+ public MultiDirectionalTransform() {
+ this(DEFAULT_GAMMA,
+ DEFAULT_RHO);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public UnaryOperator<Simplex> apply(final MultivariateFunction
evaluationFunction,
+ final Comparator<PointValuePair>
comparator) {
+ return (original) -> {
+ final PointValuePair best = original.get(0);
+
+ // Perform a reflection step.
+ final Simplex reflectedSimplex = transform(evaluationFunction,
+ original,
+ 1,
+ comparator);
+ final PointValuePair reflectedBest = reflectedSimplex.get(0);
+
+ if (comparator.compare(reflectedBest, best) < 0) {
+ // Compute the expanded simplex.
+ final Simplex expandedSimplex = transform(evaluationFunction,
+ original,
+ gamma,
+ comparator);
+ final PointValuePair expandedBest = expandedSimplex.get(0);
+
+ return comparator.compare(reflectedBest, expandedBest) <= 0 ?
+ reflectedSimplex :
+ expandedSimplex;
+ } else {
+ // Compute the contracted simplex.
+ return transform(evaluationFunction,
+ original,
+ rho,
+ comparator);
+ }
+ };
+ }
+
+ /**
+ * Computes and evaluates a new simplex.
+ *
+ * @param evaluationFunction Evaluation function.
+ * @param original Original simplex.
+ * @param coeff Linear coefficient.
+ * @param comparator Comparator for sorting vertices from best to worst.
+ * @return the transformed simplex.
+ * @throws
org.apache.commons.math4.legacy.exception.TooManyEvaluationsException
+ * if the maximal number of evaluations is exceeded.
+ */
+ private Simplex transform(MultivariateFunction evaluationFunction,
+ Simplex original,
+ double coeff,
+ Comparator<PointValuePair> comparator) {
+ // Transformed simplex is the result a linear transformation on all
+ // points except the first one.
+ final int dim = original.getDimension();
+ final int len = original.getSize();
+ final double[][] simplex = new double[len][];
+
+ simplex[0] = original.get(0).getPoint();
+ final double[] xSmallest = simplex[0];
+
+ for (int i = 1; i < len; i++) {
+ final double[] xOriginal = original.get(i).getPoint();
+ final double[] xTransformed = new double[dim];
+ for (int j = 0; j < dim; j++) {
+ xTransformed[j] = xSmallest[j] + coeff * (xSmallest[j] -
xOriginal[j]);
+ }
+ simplex[i] = xTransformed;
+ }
+
+ return Simplex.of(simplex);
+ }
+}
diff --git
a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/NelderMeadSimplex.java
b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/NelderMeadSimplex.java
deleted file mode 100644
index bc923fa..0000000
---
a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/NelderMeadSimplex.java
+++ /dev/null
@@ -1,280 +0,0 @@
-/*
- * 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.math4.legacy.optim.nonlinear.scalar.noderiv;
-
-import java.util.Comparator;
-
-import org.apache.commons.math4.legacy.analysis.MultivariateFunction;
-import org.apache.commons.math4.legacy.optim.PointValuePair;
-
-/**
- * This class implements the Nelder-Mead simplex algorithm.
- *
- * @since 3.0
- */
-public class NelderMeadSimplex extends AbstractSimplex {
- /** Default value for {@link #rho}: {@value}. */
- private static final double DEFAULT_RHO = 1;
- /** Default value for {@link #khi}: {@value}. */
- private static final double DEFAULT_KHI = 2;
- /** Default value for {@link #gamma}: {@value}. */
- private static final double DEFAULT_GAMMA = 0.5;
- /** Default value for {@link #sigma}: {@value}. */
- private static final double DEFAULT_SIGMA = 0.5;
- /** Reflection coefficient. */
- private final double rho;
- /** Expansion coefficient. */
- private final double khi;
- /** Contraction coefficient. */
- private final double gamma;
- /** Shrinkage coefficient. */
- private final double sigma;
-
- /**
- * Build a Nelder-Mead simplex with default coefficients.
- * The default coefficients are 1.0 for rho, 2.0 for khi and 0.5
- * for both gamma and sigma.
- *
- * @param n Dimension of the simplex.
- */
- public NelderMeadSimplex(final int n) {
- this(n, 1d);
- }
-
- /**
- * Build a Nelder-Mead simplex with default coefficients.
- * The default coefficients are 1.0 for rho, 2.0 for khi and 0.5
- * for both gamma and sigma.
- *
- * @param n Dimension of the simplex.
- * @param sideLength Length of the sides of the default (hypercube)
- * simplex. See {@link AbstractSimplex#AbstractSimplex(int,double)}.
- */
- public NelderMeadSimplex(final int n, double sideLength) {
- this(n, sideLength,
- DEFAULT_RHO, DEFAULT_KHI, DEFAULT_GAMMA, DEFAULT_SIGMA);
- }
-
- /**
- * Build a Nelder-Mead simplex with specified coefficients.
- *
- * @param n Dimension of the simplex. See
- * {@link AbstractSimplex#AbstractSimplex(int,double)}.
- * @param sideLength Length of the sides of the default (hypercube)
- * simplex. See {@link AbstractSimplex#AbstractSimplex(int,double)}.
- * @param rho Reflection coefficient.
- * @param khi Expansion coefficient.
- * @param gamma Contraction coefficient.
- * @param sigma Shrinkage coefficient.
- */
- public NelderMeadSimplex(final int n, double sideLength,
- final double rho, final double khi,
- final double gamma, final double sigma) {
- super(n, sideLength);
-
- this.rho = rho;
- this.khi = khi;
- this.gamma = gamma;
- this.sigma = sigma;
- }
-
- /**
- * Build a Nelder-Mead simplex with specified coefficients.
- *
- * @param n Dimension of the simplex. See
- * {@link AbstractSimplex#AbstractSimplex(int)}.
- * @param rho Reflection coefficient.
- * @param khi Expansion coefficient.
- * @param gamma Contraction coefficient.
- * @param sigma Shrinkage coefficient.
- */
- public NelderMeadSimplex(final int n,
- final double rho, final double khi,
- final double gamma, final double sigma) {
- this(n, 1d, rho, khi, gamma, sigma);
- }
-
- /**
- * Build a Nelder-Mead simplex with default coefficients.
- * The default coefficients are 1.0 for rho, 2.0 for khi and 0.5
- * for both gamma and sigma.
- *
- * @param steps Steps along the canonical axes representing box edges.
- * They may be negative but not zero. See
- */
- public NelderMeadSimplex(final double[] steps) {
- this(steps, DEFAULT_RHO, DEFAULT_KHI, DEFAULT_GAMMA, DEFAULT_SIGMA);
- }
-
- /**
- * Build a Nelder-Mead simplex with specified coefficients.
- *
- * @param steps Steps along the canonical axes representing box edges.
- * They may be negative but not zero. See
- * {@link AbstractSimplex#AbstractSimplex(double[])}.
- * @param rho Reflection coefficient.
- * @param khi Expansion coefficient.
- * @param gamma Contraction coefficient.
- * @param sigma Shrinkage coefficient.
- * @throws IllegalArgumentException if one of the steps is zero.
- */
- public NelderMeadSimplex(final double[] steps,
- final double rho, final double khi,
- final double gamma, final double sigma) {
- super(steps);
-
- this.rho = rho;
- this.khi = khi;
- this.gamma = gamma;
- this.sigma = sigma;
- }
-
- /**
- * Build a Nelder-Mead simplex with default coefficients.
- * The default coefficients are 1.0 for rho, 2.0 for khi and 0.5
- * for both gamma and sigma.
- *
- * @param referenceSimplex Reference simplex. See
- * {@link AbstractSimplex#AbstractSimplex(double[][])}.
- */
- public NelderMeadSimplex(final double[][] referenceSimplex) {
- this(referenceSimplex, DEFAULT_RHO, DEFAULT_KHI, DEFAULT_GAMMA,
DEFAULT_SIGMA);
- }
-
- /**
- * Build a Nelder-Mead simplex with specified coefficients.
- *
- * @param referenceSimplex Reference simplex. See
- * {@link AbstractSimplex#AbstractSimplex(double[][])}.
- * @param rho Reflection coefficient.
- * @param khi Expansion coefficient.
- * @param gamma Contraction coefficient.
- * @param sigma Shrinkage coefficient.
- * @throws
org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException
- * if the reference simplex does not contain at least one point.
- * @throws
org.apache.commons.math4.legacy.exception.DimensionMismatchException
- * if there is a dimension mismatch in the reference simplex.
- */
- public NelderMeadSimplex(final double[][] referenceSimplex,
- final double rho, final double khi,
- final double gamma, final double sigma) {
- super(referenceSimplex);
-
- this.rho = rho;
- this.khi = khi;
- this.gamma = gamma;
- this.sigma = sigma;
- }
-
- /** {@inheritDoc} */
- @Override
- public void iterate(final MultivariateFunction evaluationFunction,
- final Comparator<PointValuePair> comparator) {
- // The simplex has n + 1 points if dimension is n.
- final int n = getDimension();
-
- // Interesting values.
- final PointValuePair best = getPoint(0);
- final PointValuePair secondBest = getPoint(n - 1);
- final PointValuePair worst = getPoint(n);
- final double[] xWorst = worst.getPointRef();
-
- // Compute the centroid of the best vertices (dismissing the worst
- // point at index n).
- final double[] centroid = new double[n];
- for (int i = 0; i < n; i++) {
- final double[] x = getPoint(i).getPointRef();
- for (int j = 0; j < n; j++) {
- centroid[j] += x[j];
- }
- }
- final double scaling = 1.0 / n;
- for (int j = 0; j < n; j++) {
- centroid[j] *= scaling;
- }
-
- // compute the reflection point
- final double[] xR = new double[n];
- for (int j = 0; j < n; j++) {
- xR[j] = centroid[j] + rho * (centroid[j] - xWorst[j]);
- }
- final PointValuePair reflected
- = new PointValuePair(xR, evaluationFunction.value(xR), false);
-
- if (comparator.compare(best, reflected) <= 0 &&
- comparator.compare(reflected, secondBest) < 0) {
- // Accept the reflected point.
- replaceWorstPoint(reflected, comparator);
- } else if (comparator.compare(reflected, best) < 0) {
- // Compute the expansion point.
- final double[] xE = new double[n];
- for (int j = 0; j < n; j++) {
- xE[j] = centroid[j] + khi * (xR[j] - centroid[j]);
- }
- final PointValuePair expanded
- = new PointValuePair(xE, evaluationFunction.value(xE), false);
-
- if (comparator.compare(expanded, reflected) < 0) {
- // Accept the expansion point.
- replaceWorstPoint(expanded, comparator);
- } else {
- // Accept the reflected point.
- replaceWorstPoint(reflected, comparator);
- }
- } else {
- if (comparator.compare(reflected, worst) < 0) {
- // Perform an outside contraction.
- final double[] xC = new double[n];
- for (int j = 0; j < n; j++) {
- xC[j] = centroid[j] + gamma * (xR[j] - centroid[j]);
- }
- final PointValuePair outContracted
- = new PointValuePair(xC, evaluationFunction.value(xC),
false);
- if (comparator.compare(outContracted, reflected) <= 0) {
- // Accept the contraction point.
- replaceWorstPoint(outContracted, comparator);
- return;
- }
- } else {
- // Perform an inside contraction.
- final double[] xC = new double[n];
- for (int j = 0; j < n; j++) {
- xC[j] = centroid[j] - gamma * (centroid[j] - xWorst[j]);
- }
- final PointValuePair inContracted
- = new PointValuePair(xC, evaluationFunction.value(xC),
false);
-
- if (comparator.compare(inContracted, worst) < 0) {
- // Accept the contraction point.
- replaceWorstPoint(inContracted, comparator);
- return;
- }
- }
-
- // Perform a shrink.
- final double[] xSmallest = getPoint(0).getPointRef();
- for (int i = 1; i <= n; i++) {
- final double[] x = getPoint(i).getPoint();
- for (int j = 0; j < n; j++) {
- x[j] = xSmallest[j] + sigma * (x[j] - xSmallest[j]);
- }
- setPoint(i, new PointValuePair(x, Double.NaN, false));
- }
- evaluate(evaluationFunction, comparator);
- }
- }
-}
diff --git
a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/NelderMeadTransform.java
b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/NelderMeadTransform.java
new file mode 100644
index 0000000..b188327
--- /dev/null
+++
b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/NelderMeadTransform.java
@@ -0,0 +1,183 @@
+/*
+ * 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.math4.legacy.optim.nonlinear.scalar.noderiv;
+
+import java.util.Comparator;
+import java.util.function.BiFunction;
+import java.util.function.UnaryOperator;
+
+import org.apache.commons.math4.legacy.analysis.MultivariateFunction;
+import org.apache.commons.math4.legacy.optim.PointValuePair;
+import org.apache.commons.math4.legacy.optim.OptimizationData;
+
+/**
+ * <a
href="https://en.wikipedia.org/wiki/Nelder%E2%80%93Mead_method";>Nelder-Mead
method</a>.
+ */
+public class NelderMeadTransform
+ implements Simplex.TransformFactory,
+ OptimizationData {
+ /** Default value for {@link #alpha}: {@value}. */
+ private static final double DEFAULT_ALPHA = 1;
+ /** Default value for {@link #gamma}: {@value}. */
+ private static final double DEFAULT_GAMMA = 2;
+ /** Default value for {@link #rho}: {@value}. */
+ private static final double DEFAULT_RHO = 0.5;
+ /** Default value for {@link #sigma}: {@value}. */
+ private static final double DEFAULT_SIGMA = 0.5;
+ /** Reflection coefficient. */
+ private final double alpha;
+ /** Expansion coefficient. */
+ private final double gamma;
+ /** Contraction coefficient. */
+ private final double rho;
+ /** Shrinkage coefficient. */
+ private final double sigma;
+
+ /**
+ * @param alpha Reflection coefficient.
+ * @param gamma Expansion coefficient.
+ * @param rho Contraction coefficient.
+ * @param sigma Shrinkage coefficient.
+ */
+ public NelderMeadTransform(double alpha,
+ double gamma,
+ double rho,
+ double sigma) {
+ this.alpha = alpha;
+ this.gamma = gamma;
+ this.rho = rho;
+ this.sigma = sigma;
+ }
+
+ /**
+ * Transform with default values.
+ */
+ public NelderMeadTransform() {
+ this(DEFAULT_ALPHA,
+ DEFAULT_GAMMA,
+ DEFAULT_RHO,
+ DEFAULT_SIGMA);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public UnaryOperator<Simplex> apply(final MultivariateFunction
evaluationFunction,
+ final Comparator<PointValuePair>
comparator) {
+ return (original) -> {
+ Simplex newSimplex = original;
+
+ // The simplex has n + 1 points if dimension is n.
+ final int n = newSimplex.getDimension();
+
+ // Interesting values.
+ final PointValuePair best = newSimplex.get(0);
+ final PointValuePair secondWorst = newSimplex.get(n - 1);
+ final PointValuePair worst = newSimplex.get(n);
+ final double[] xWorst = worst.getPoint();
+
+ // Centroid of the best vertices, dismissing the worst point (at
index n).
+ final double[] centroid = new double[n];
+ for (int i = 0; i < n; i++) {
+ final double[] x = newSimplex.get(i).getPoint();
+ for (int j = 0; j < n; j++) {
+ centroid[j] += x[j];
+ }
+ }
+ final double scaling = 1d / n;
+ for (int j = 0; j < n; j++) {
+ centroid[j] *= scaling;
+ }
+
+ // Reflection.
+ final PointValuePair reflected = newPoint(centroid,
+ -alpha,
+ xWorst,
+ evaluationFunction);
+ if (comparator.compare(reflected, secondWorst) < 0 &&
+ comparator.compare(best, reflected) <= 0) {
+ return newSimplex.withReplacement(n, reflected);
+ }
+
+ if (comparator.compare(reflected, best) < 0) {
+ // Expansion.
+ final PointValuePair expanded = newPoint(centroid,
+ -gamma,
+ xWorst,
+ evaluationFunction);
+ if (comparator.compare(expanded, reflected) < 0) {
+ return newSimplex.withReplacement(n, expanded);
+ } else {
+ return newSimplex.withReplacement(n, reflected);
+ }
+ }
+
+ if (comparator.compare(reflected, worst) < 0) {
+ // Outside contraction.
+ final PointValuePair contracted = newPoint(centroid,
+ rho,
+
reflected.getPoint(),
+ evaluationFunction);
+ if (comparator.compare(contracted, reflected) < 0) {
+ return newSimplex.withReplacement(n, contracted); //
Accept contracted point.
+ }
+ } else {
+ // Inside contraction.
+ final PointValuePair contracted = newPoint(centroid,
+ rho,
+ xWorst,
+ evaluationFunction);
+ if (comparator.compare(contracted, worst) < 0) {
+ return newSimplex.withReplacement(n, contracted); //
Accept contracted point.
+ }
+ }
+
+ // Shrink.
+ final int len = newSimplex.getSize();
+ final double[] xBest = best.getPoint();
+ for (int i = 1; i < len; i++) {
+ newSimplex = newSimplex.withReplacement(i, newPoint(xBest,
+ sigma,
+
newSimplex.get(i).getPoint(),
+
evaluationFunction));
+ }
+ return newSimplex;
+ };
+ }
+
+ /**
+ * Evaluates point with coordinates \( a_i + s (b_i - a_i) \).
+ *
+ * @param a Cartesian coordinates.
+ * @param s Scaling factor.
+ * @param b Cartesian coordinates.
+ * @param eval Evaluation function.
+ * @return a new point.
+ */
+ private static PointValuePair newPoint(double[] a,
+ double s,
+ double[] b,
+ MultivariateFunction eval) {
+ final int dim = a.length;
+ final double[] r = new double[dim];
+ for (int i = 0; i < dim; i++) {
+ final double m = a[i];
+ r[i] = m + s * (b[i] - m);
+ }
+
+ return new PointValuePair(r, eval.value(r), false);
+ }
+}
diff --git
a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/Simplex.java
b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/Simplex.java
new file mode 100644
index 0000000..46345c3
--- /dev/null
+++
b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/Simplex.java
@@ -0,0 +1,304 @@
+/*
+ * 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.math4.legacy.optim.nonlinear.scalar.noderiv;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Collections;
+import java.util.function.BiFunction;
+import java.util.function.UnaryOperator;
+
+import org.apache.commons.math4.legacy.analysis.MultivariateFunction;
+import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
+import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
+import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
+import org.apache.commons.math4.legacy.exception.NullArgumentException;
+import org.apache.commons.math4.legacy.exception.OutOfRangeException;
+import org.apache.commons.math4.legacy.exception.ZeroException;
+import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
+import org.apache.commons.math4.legacy.optim.OptimizationData;
+import org.apache.commons.math4.legacy.optim.PointValuePair;
+
+/**
+ * Represents a simplex.
+ *
+ * @see SimplexOptimizer
+ * @see MultiDirectionalTransform
+ * @see NelderMeadTransform
+ */
+public final class Simplex implements OptimizationData {
+ /** Coordinates. */
+ private final List<PointValuePair> simplex;
+
+ /**
+ * Builds from a given set of coordinates.
+ *
+ * @param coordinate Reference simplex.
+ * @throws NotStrictlyPositiveException if the reference simplex does not
+ * contain at least one point.
+ * @throws DimensionMismatchException if there is a dimension mismatch
+ * in the reference simplex.
+ * @throws IllegalArgumentException if one of its vertices is duplicated.
+ */
+ private Simplex(double[][] referenceSimplex) {
+ if (referenceSimplex.length <= 0) {
+ throw new
NotStrictlyPositiveException(LocalizedFormats.SIMPLEX_NEED_ONE_POINT,
+ referenceSimplex.length);
+ }
+ final int len = referenceSimplex.length;
+ simplex = new ArrayList<>(len);
+
+ final int dim = len - 1;
+
+ // Loop over vertices.
+ for (int i = 0; i < len; i++) {
+ final double[] refI = referenceSimplex[i];
+
+ // Safety checks.
+ if (refI.length != dim) {
+ throw new DimensionMismatchException(refI.length, dim);
+ }
+ for (int j = 1; j < i; j++) {
+ final double[] refJ = referenceSimplex[j];
+ boolean allEquals = true;
+ for (int k = 0; k < dim; k++) {
+ if (refI[k] != refJ[k]) {
+ allEquals = false;
+ break;
+ }
+ }
+ if (allEquals) {
+ throw new
MathIllegalArgumentException(LocalizedFormats.EQUAL_VERTICES_IN_SIMPLEX,
+ i, j);
+ }
+ }
+
+ simplex.add(new PointValuePair(refI, Double.NaN));
+ }
+ }
+
+ /**
+ * Builds from an existing simplex.
+ *
+ * @param simplex Simplex data. Reference will be stored in the newly
+ * constructed instance.
+ */
+ private Simplex(List<PointValuePair> simplex) {
+ this.simplex = simplex;
+ }
+
+ /**
+ * Builds from a given set of coordinates.
+ *
+ * @param simplex Reference simplex.
+ * @return a new instance.
+ * @throws NotStrictlyPositiveException if the reference simplex does not
+ * contain at least one point.
+ * @throws DimensionMismatchException if there is a dimension mismatch
+ * in the reference simplex.
+ * @throws IllegalArgumentException if one of its vertices is duplicated.
+ */
+ public static Simplex of(double[][] simplex) {
+ return new Simplex(simplex);
+ }
+
+ /**
+ * Builds a unit hypercube simplex.
+ *
+ * @param n Dimension of the simplex.
+ * @return a new instance.
+ */
+ public static Simplex of(int n) {
+ return of(n, 1d);
+ }
+
+ /**
+ * Builds a hypercube simplex with the given side length.
+ *
+ * @param n Dimension of the simplex.
+ * @param sideLength Length of the sides of the hypercube.
+ * @return a new instance.
+ */
+ public static Simplex of(int n,
+ double sideLength) {
+ final double[] steps = new double[n];
+ Arrays.fill(steps, sideLength);
+ return of(steps);
+ }
+
+ /**
+ * The start configuration for simplex is built from a box parallel to
+ * the canonical axes of the space. The simplex is the subset of vertices
+ * of a box parallel to the canonical axes. It is built as the path
followed
+ * while traveling from one vertex of the box to the diagonally opposite
+ * vertex moving only along the box edges. The first vertex of the box will
+ * be located at the start point of the optimization.
+ * As an example, in dimension 3 a simplex has 4 vertices. Setting the
+ * steps to (1, 10, 2) and the start point to (1, 1, 1) would imply the
+ * start simplex would be: { (1, 1, 1), (2, 1, 1), (2, 11, 1), (2, 11, 3)
}.
+ * The first vertex would be set to the start point at (1, 1, 1) and the
+ * last vertex would be set to the diagonally opposite vertex at (2, 11,
3).
+ *
+ * @param steps Steps along the canonical axes representing box edges.
+ * They may be negative but not zero.
+ * @throws ZeroException if one of the steps is zero.
+ * @return a new instance.
+ */
+ public static Simplex of(double[] steps) {
+ if (steps.length == 0) {
+ throw new ZeroException();
+ }
+ final int dim = steps.length;
+ final int len = dim + 1;
+
+ // Only the relative position of the n final vertices with respect
+ // to the first one are stored.
+ final double[][] simplex = new double[len][dim];
+ for (int i = 1; i < len; i++) { // First point is the origin (zero).
+ final double[] vertexI = simplex[i];
+ for (int j = 0; j < i; j++) {
+ if (steps[j] == 0) {
+ throw new
ZeroException(LocalizedFormats.EQUAL_VERTICES_IN_SIMPLEX);
+ }
+ System.arraycopy(steps, 0, vertexI, 0, j + 1);
+ }
+ }
+
+ return new Simplex(simplex);
+ }
+
+ /**
+ * Returns the space dimension.
+ *
+ * @return the dimension of the simplex.
+ */
+ public int getDimension() {
+ return simplex.size() - 1;
+ }
+
+ /**
+ * Returns the number of vertices.
+ *
+ * @return the size of the simplex.
+ */
+ public int getSize() {
+ return simplex.size();
+ }
+
+ /**
+ * Evaluates the (non-evaluated) simplex points and returns a new instance
+ * with vertices sorted from best to worst.
+ *
+ * @param function Evaluation function.
+ * @param comparator Comparator for sorting vertices, from best to worst.
+ * @return a new instance in which the vertices are sorted according to
+ * the given {@code comparator}.
+ */
+ public Simplex evaluate(MultivariateFunction function,
+ Comparator<PointValuePair> comparator) {
+ final List<PointValuePair> newSimplex = new
ArrayList<>(simplex.size());
+ for (PointValuePair pv : simplex) {
+ final double[] coord = pv.getPoint();
+ final double value = Double.isNaN(pv.getValue()) ?
+ function.value(coord) :
+ pv.getValue();
+
+ newSimplex.add(new PointValuePair(coord, value, false));
+ }
+
+ Collections.sort(newSimplex, comparator);
+ return new Simplex(newSimplex);
+ }
+
+ /**
+ * Retrieves a copy of the simplex point stored at {@code index}.
+ *
+ * @param index Location.
+ * @return the point at location {@code index}.
+ */
+ public PointValuePair get(int index) {
+ final PointValuePair p = simplex.get(index);
+ return new PointValuePair(p.getPoint(), p.getValue());
+ }
+
+ /**
+ * Translates the simplex such that its first point is at the given {@code
point}.
+ *
+ * @param point Coordinates of the new simplex's first point.
+ * @return a new instance.
+ * @throws DimensionMismatchException if the start point does not match
+ * simplex dimension.
+ */
+ public Simplex translate(final double[] point) {
+ final int dim = getDimension();
+ if (dim != point.length) {
+ throw new DimensionMismatchException(dim, point.length);
+ }
+
+ final int len = simplex.size();
+ final double[][] coordinates = new double[len][dim];
+ final double[] current0 = simplex.get(0).getPoint(); // Current first
point.
+
+ // Set new vertices.
+ for (int i = 0; i < len; i++) {
+ final double[] currentI = simplex.get(i).getPoint();
+ final double[] newI = coordinates[i];
+ for (int k = 0; k < dim; k++) {
+ newI[k] = point[k] + currentI[k] - current0[k];
+ }
+ }
+
+ return of(coordinates);
+ }
+
+ /**
+ * Builds a new simplex where the given {@code point} replaces the
+ * one at {@code index} in this instance.
+ *
+ * @param index Index of the point to replace.
+ * @param point Replacement for the point currently at {@code index}.
+ * @return a new instance.
+ * @throws IndexOutOfBoundsException if {@code index} is out of bounds.
+ */
+ public Simplex withReplacement(int index,
+ PointValuePair point) {
+ final int len = simplex.size();
+ if (index < 0 ||
+ index >= len) {
+ throw new IndexOutOfBoundsException("index: " + index);
+ }
+
+ final List<PointValuePair> newSimplex = new ArrayList<>(len);
+ for (int i = 0; i < len; i++) {
+ final PointValuePair pv = i == index ?
+ point :
+ simplex.get(i);
+ newSimplex.add(new PointValuePair(pv.getPoint(), pv.getValue(),
false));
+ }
+
+ return new Simplex(newSimplex);
+ }
+
+ /**
+ * Generator of simplex transform.
+ */
+ public interface TransformFactory
+ extends BiFunction<MultivariateFunction, Comparator<PointValuePair>,
UnaryOperator<Simplex>> {}
+}
diff --git
a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/SimplexOptimizer.java
b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/SimplexOptimizer.java
index 48aaafd..d95123d 100644
---
a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/SimplexOptimizer.java
+++
b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/SimplexOptimizer.java
@@ -17,6 +17,7 @@
package org.apache.commons.math4.legacy.optim.nonlinear.scalar.noderiv;
import java.util.Comparator;
+import java.util.function.UnaryOperator;
import org.apache.commons.math4.legacy.analysis.MultivariateFunction;
import
org.apache.commons.math4.legacy.exception.MathUnsupportedOperationException;
@@ -52,9 +53,9 @@ import
org.apache.commons.math4.legacy.optim.nonlinear.scalar.MultivariateOptimi
* steps.
* </p>
* <p>
- * The simplex update procedure ({@link NelderMeadSimplex} or
- * {@link MultiDirectionalSimplex}) must be passed to the
- * {@code optimize} method.
+ * The simplex update procedure ({@link NelderMeadTransform} or
+ * {@link MultiDirectionalTransform}) must be passed to the
+ * {@code optimize} method.
* </p>
* <p>
* Each call to {@code optimize} will re-use the start configuration of
@@ -70,25 +71,17 @@ import
org.apache.commons.math4.legacy.optim.nonlinear.scalar.MultivariateOptimi
* ones.
* </p>
* <p>
- * This simplex optimizer implementation does not directly support constrained
- * optimization with simple bounds; so, for such optimizations, either a more
- * dedicated algorithm must be used like
- * {@link CMAESOptimizer} or {@link BOBYQAOptimizer}, or the objective
- * function must be wrapped in an adapter like
- * {@link
org.apache.commons.math4.legacy.optim.nonlinear.scalar.MultivariateFunctionMappingAdapter
- * MultivariateFunctionMappingAdapter} or
- * {@link
org.apache.commons.math4.legacy.optim.nonlinear.scalar.MultivariateFunctionPenaltyAdapter
- * MultivariateFunctionPenaltyAdapter}.
- * <br>
+ * This implementation does not directly support constrained optimization
+ * with simple bounds.
* The call to {@link #optimize(OptimizationData[]) optimize} will throw
* {@link MathUnsupportedOperationException} if bounds are passed to it.
* </p>
- *
- * @since 3.0
*/
public class SimplexOptimizer extends MultivariateOptimizer {
- /** Simplex update rule. */
- private AbstractSimplex simplex;
+ /** Simplex update function factory. */
+ private Simplex.TransformFactory updateRule;
+ /** Current simplex. */
+ private Simplex simplex;
/**
* @param checker Convergence checker.
@@ -101,7 +94,8 @@ public class SimplexOptimizer extends MultivariateOptimizer {
* @param rel Relative threshold.
* @param abs Absolute threshold.
*/
- public SimplexOptimizer(double rel, double abs) {
+ public SimplexOptimizer(double rel,
+ double abs) {
this(new SimpleValueChecker(rel, abs));
}
@@ -112,7 +106,8 @@ public class SimplexOptimizer extends MultivariateOptimizer
{
* {@link MultivariateOptimizer#parseOptimizationData(OptimizationData[])
* MultivariateOptimizer}, this method will register the following data:
* <ul>
- * <li>{@link AbstractSimplex}</li>
+ * <li>{@link Simplex}</li>
+ * <li>{@link Simplex.TransformFactory}</li>
* </ul>
* @return {@inheritDoc}
*/
@@ -131,31 +126,32 @@ public class SimplexOptimizer extends
MultivariateOptimizer {
// evaluations counter.
final MultivariateFunction evalFunc
= new MultivariateFunction() {
- /** {@inheritDoc} */
- @Override
- public double value(double[] point) {
- return computeObjectiveValue(point);
- }
- };
+ /** {@inheritDoc} */
+ @Override
+ public double value(double[] point) {
+ return computeObjectiveValue(point);
+ }
+ };
final boolean isMinim = getGoalType() == GoalType.MINIMIZE;
final Comparator<PointValuePair> comparator
= new Comparator<PointValuePair>() {
- /** {@inheritDoc} */
- @Override
- public int compare(final PointValuePair o1,
- final PointValuePair o2) {
- final double v1 = o1.getValue();
- final double v2 = o2.getValue();
- return isMinim ? Double.compare(v1, v2) : Double.compare(v2,
v1);
- }
- };
+ /** {@inheritDoc} */
+ @Override
+ public int compare(final PointValuePair o1,
+ final PointValuePair o2) {
+ final double v1 = o1.getValue();
+ final double v2 = o2.getValue();
+ return isMinim ? Double.compare(v1, v2) :
Double.compare(v2, v1);
+ }
+ };
+
+ final UnaryOperator<Simplex> update = updateRule.apply(evalFunc,
comparator);
// Initialize search.
- simplex.build(getStartPoint());
- simplex.evaluate(evalFunc, comparator);
+ simplex = simplex.translate(getStartPoint()).evaluate(evalFunc,
comparator);
- PointValuePair[] previous = null;
+ Simplex previous = null;
int iteration = 0;
final ConvergenceChecker<PointValuePair> checker =
getConvergenceChecker();
while (true) {
@@ -163,9 +159,9 @@ public class SimplexOptimizer extends MultivariateOptimizer
{
if (iteration > 0) {
boolean converged = true;
for (int i = 0; i < simplex.getSize(); i++) {
- PointValuePair prev = previous[i];
+ PointValuePair prev = previous.get(i);
converged = converged &&
- checker.converged(iteration, prev,
simplex.getPoint(i));
+ checker.converged(iteration, prev, simplex.get(i));
if (!converged) {
// Short circuit, since "converged" will stay "false".
@@ -174,13 +170,13 @@ public class SimplexOptimizer extends
MultivariateOptimizer {
}
if (converged) {
// We have found an optimum.
- return simplex.getPoint(0);
+ return simplex.get(0);
}
}
// We still need to search.
- previous = simplex.getPoints();
- simplex.iterate(evalFunc, comparator);
+ previous = simplex;
+ simplex = update.apply(simplex).evaluate(evalFunc, comparator);
incrementIterationCount();
}
@@ -193,7 +189,8 @@ public class SimplexOptimizer extends MultivariateOptimizer
{
* @param optData Optimization data.
* The following data will be looked for:
* <ul>
- * <li>{@link AbstractSimplex}</li>
+ * <li>{@link Simplex}</li>
+ * <li>{@link Simplex.TransformFactory}</li>
* </ul>
*/
@Override
@@ -201,14 +198,17 @@ public class SimplexOptimizer extends
MultivariateOptimizer {
// Allow base class to register its own data.
super.parseOptimizationData(optData);
- // The existing values (as set by the previous call) are reused if
- // not provided in the argument list.
+ // The existing values (as set by the previous call) are reused
+ // if not provided in the argument list.
for (OptimizationData data : optData) {
- if (data instanceof AbstractSimplex) {
- simplex = (AbstractSimplex) data;
- // If more data must be parsed, this statement _must_ be
- // changed to "continue".
- break;
+ if (data instanceof Simplex) {
+ simplex = (Simplex) data;
+ continue;
+ }
+
+ if (data instanceof Simplex.TransformFactory) {
+ updateRule = (Simplex.TransformFactory) data;
+ continue;
}
}
}
@@ -216,12 +216,15 @@ public class SimplexOptimizer extends
MultivariateOptimizer {
/**
* @throws MathUnsupportedOperationException if bounds were passed to the
* {@link #optimize(OptimizationData[]) optimize} method.
- * @throws NullArgumentException if no initial simplex was passed to the
- * {@link #optimize(OptimizationData[]) optimize} method.
+ * @throws NullPointerException if no initial simplex or no transform rule
+ * was passed to the {@link #optimize(OptimizationData[]) optimize} method.
*/
private void checkParameters() {
+ if (updateRule == null) {
+ throw new NullPointerException("No update rule");
+ }
if (simplex == null) {
- throw new NullArgumentException();
+ throw new NullPointerException("No initial simplex");
}
if (getLowerBound() != null ||
getUpperBound() != null) {
diff --git
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultiStartMultivariateOptimizerTest.java
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultiStartMultivariateOptimizerTest.java
index f324c38..a431635 100644
---
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultiStartMultivariateOptimizerTest.java
+++
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultiStartMultivariateOptimizerTest.java
@@ -25,8 +25,9 @@ import org.apache.commons.math4.legacy.optim.PointValuePair;
import org.apache.commons.math4.legacy.optim.SimpleValueChecker;
import
org.apache.commons.math4.legacy.optim.nonlinear.scalar.gradient.CircleScalar;
import
org.apache.commons.math4.legacy.optim.nonlinear.scalar.gradient.NonLinearConjugateGradientOptimizer;
-import
org.apache.commons.math4.legacy.optim.nonlinear.scalar.noderiv.NelderMeadSimplex;
+import
org.apache.commons.math4.legacy.optim.nonlinear.scalar.noderiv.NelderMeadTransform;
import
org.apache.commons.math4.legacy.optim.nonlinear.scalar.noderiv.SimplexOptimizer;
+import org.apache.commons.math4.legacy.optim.nonlinear.scalar.noderiv.Simplex;
import org.apache.commons.rng.UniformRandomProvider;
import org.apache.commons.rng.simple.RandomSource;
import org.apache.commons.rng.sampling.distribution.GaussianSampler;
@@ -59,6 +60,7 @@ public class MultiStartMultivariateOptimizerTest {
= optimizer.optimize(new MaxEval(1000),
circle.getObjectiveFunction(),
circle.getObjectiveFunctionGradient(),
+ new NelderMeadTransform(),
GoalType.MINIMIZE,
new InitialGuess(new double[] { 98.680,
47.345 }));
Assert.assertEquals(1000, optimizer.getMaxEvaluations());
@@ -83,7 +85,7 @@ public class MultiStartMultivariateOptimizerTest {
Rosenbrock rosenbrock = new Rosenbrock();
SimplexOptimizer underlying
= new SimplexOptimizer(new SimpleValueChecker(-1, 1e-3));
- NelderMeadSimplex simplex = new NelderMeadSimplex(new double[][] {
+ final Simplex simplex = Simplex.of(new double[][] {
{ -1.2, 1.0 },
{ 0.9, 1.2 } ,
{ 3.5, -2.3 }
@@ -99,6 +101,7 @@ public class MultiStartMultivariateOptimizerTest {
new ObjectiveFunction(rosenbrock),
GoalType.MINIMIZE,
simplex,
+ new NelderMeadTransform(),
new InitialGuess(new double[] { -1.2, 1.0 }));
Assert.assertEquals(nbStarts, optimizer.getOptima().length);
diff --git
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultivariateFunctionMappingAdapterTest.java
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultivariateFunctionMappingAdapterTest.java
index b79508b..ecc0617 100644
---
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultivariateFunctionMappingAdapterTest.java
+++
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultivariateFunctionMappingAdapterTest.java
@@ -20,9 +20,9 @@ import
org.apache.commons.math4.legacy.analysis.MultivariateFunction;
import org.apache.commons.math4.legacy.optim.InitialGuess;
import org.apache.commons.math4.legacy.optim.MaxEval;
import org.apache.commons.math4.legacy.optim.PointValuePair;
-import
org.apache.commons.math4.legacy.optim.nonlinear.scalar.noderiv.AbstractSimplex;
-import
org.apache.commons.math4.legacy.optim.nonlinear.scalar.noderiv.NelderMeadSimplex;
import
org.apache.commons.math4.legacy.optim.nonlinear.scalar.noderiv.SimplexOptimizer;
+import org.apache.commons.math4.legacy.optim.nonlinear.scalar.noderiv.Simplex;
+import
org.apache.commons.math4.legacy.optim.nonlinear.scalar.noderiv.NelderMeadTransform;
import org.junit.Assert;
import org.junit.Test;
@@ -36,7 +36,7 @@ public class MultivariateFunctionMappingAdapterTest {
biQuadratic.getUpper());
SimplexOptimizer optimizer = new SimplexOptimizer(1e-10, 1e-30);
- final AbstractSimplex simplex = new NelderMeadSimplex(new double[][] {
+ final Simplex simplex = Simplex.of(new double[][] {
wrapped.boundedToUnbounded(new double[] { 1.5, 2.75 }),
wrapped.boundedToUnbounded(new double[] { 1.5, 2.95 }),
wrapped.boundedToUnbounded(new double[] { 1.7, 2.90 })
@@ -46,6 +46,7 @@ public class MultivariateFunctionMappingAdapterTest {
= optimizer.optimize(new MaxEval(300),
new ObjectiveFunction(wrapped),
simplex,
+ new NelderMeadTransform(),
GoalType.MINIMIZE,
new
InitialGuess(wrapped.boundedToUnbounded(new double[] { 1.5, 2.25 })));
final double[] bounded =
wrapped.unboundedToBounded(optimum.getPoint());
@@ -63,7 +64,7 @@ public class MultivariateFunctionMappingAdapterTest {
biQuadratic.getUpper());
SimplexOptimizer optimizer = new SimplexOptimizer(1e-10, 1e-30);
- final AbstractSimplex simplex = new NelderMeadSimplex(new double[][] {
+ final Simplex simplex = Simplex.of(new double[][] {
wrapped.boundedToUnbounded(new double[] { 1.5, 2.75 }),
wrapped.boundedToUnbounded(new double[] { 1.5, 2.95 }),
wrapped.boundedToUnbounded(new double[] { 1.7, 2.90 })
@@ -73,6 +74,7 @@ public class MultivariateFunctionMappingAdapterTest {
= optimizer.optimize(new MaxEval(100),
new ObjectiveFunction(wrapped),
simplex,
+ new NelderMeadTransform(),
GoalType.MINIMIZE,
new
InitialGuess(wrapped.boundedToUnbounded(new double[] { 1.5, 2.25 })));
final double[] bounded =
wrapped.unboundedToBounded(optimum.getPoint());
@@ -92,7 +94,7 @@ public class MultivariateFunctionMappingAdapterTest {
biQuadratic.getUpper());
SimplexOptimizer optimizer = new SimplexOptimizer(1e-10, 1e-30);
- final AbstractSimplex simplex = new NelderMeadSimplex(new double[][] {
+ final Simplex simplex = Simplex.of(new double[][] {
wrapped.boundedToUnbounded(new double[] { 1.5, 2.75 }),
wrapped.boundedToUnbounded(new double[] { 1.5, 2.95 }),
wrapped.boundedToUnbounded(new double[] { 1.7, 2.90 })
@@ -102,6 +104,7 @@ public class MultivariateFunctionMappingAdapterTest {
= optimizer.optimize(new MaxEval(300),
new ObjectiveFunction(wrapped),
simplex,
+ new NelderMeadTransform(),
GoalType.MINIMIZE,
new
InitialGuess(wrapped.boundedToUnbounded(new double[] { 1.5, 2.25 })));
final double[] bounded =
wrapped.unboundedToBounded(optimum.getPoint());
@@ -121,7 +124,7 @@ public class MultivariateFunctionMappingAdapterTest {
biQuadratic.getUpper());
SimplexOptimizer optimizer = new SimplexOptimizer(1e-13, 1e-30);
- final AbstractSimplex simplex = new NelderMeadSimplex(new double[][] {
+ final Simplex simplex = Simplex.of(new double[][] {
wrapped.boundedToUnbounded(new double[] { 1.5, 2.75 }),
wrapped.boundedToUnbounded(new double[] { 1.5, 2.95 }),
wrapped.boundedToUnbounded(new double[] { 1.7, 2.90 })
@@ -131,6 +134,7 @@ public class MultivariateFunctionMappingAdapterTest {
= optimizer.optimize(new MaxEval(200),
new ObjectiveFunction(wrapped),
simplex,
+ new NelderMeadTransform(),
GoalType.MINIMIZE,
new
InitialGuess(wrapped.boundedToUnbounded(new double[] { 1.5, 2.25 })));
final double[] bounded =
wrapped.unboundedToBounded(optimum.getPoint());
diff --git
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultivariateFunctionPenaltyAdapterTest.java
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultivariateFunctionPenaltyAdapterTest.java
index 26ceb21..01ac256 100644
---
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultivariateFunctionPenaltyAdapterTest.java
+++
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultivariateFunctionPenaltyAdapterTest.java
@@ -21,9 +21,9 @@ import org.apache.commons.math4.legacy.optim.InitialGuess;
import org.apache.commons.math4.legacy.optim.MaxEval;
import org.apache.commons.math4.legacy.optim.PointValuePair;
import org.apache.commons.math4.legacy.optim.SimplePointChecker;
-import
org.apache.commons.math4.legacy.optim.nonlinear.scalar.noderiv.AbstractSimplex;
-import
org.apache.commons.math4.legacy.optim.nonlinear.scalar.noderiv.NelderMeadSimplex;
import
org.apache.commons.math4.legacy.optim.nonlinear.scalar.noderiv.SimplexOptimizer;
+import org.apache.commons.math4.legacy.optim.nonlinear.scalar.noderiv.Simplex;
+import
org.apache.commons.math4.legacy.optim.nonlinear.scalar.noderiv.NelderMeadTransform;
import org.junit.Assert;
import org.junit.Test;
@@ -38,12 +38,12 @@ public class MultivariateFunctionPenaltyAdapterTest {
1000.0, new double[] {
100.0, 100.0 });
SimplexOptimizer optimizer = new SimplexOptimizer(1e-10, 1e-30);
- final AbstractSimplex simplex = new NelderMeadSimplex(new double[] {
1.0, 0.5 });
final PointValuePair optimum
= optimizer.optimize(new MaxEval(300),
new ObjectiveFunction(wrapped),
- simplex,
+ Simplex.of(new double[] { 1.0, 0.5 }),
+ new NelderMeadTransform(),
GoalType.MINIMIZE,
new InitialGuess(new double[] { 1.5, 2.25 }));
@@ -61,12 +61,12 @@ public class MultivariateFunctionPenaltyAdapterTest {
1000.0, new double[] {
100.0, 100.0 });
SimplexOptimizer optimizer = new SimplexOptimizer(1e-10, 1e-30);
- final AbstractSimplex simplex = new NelderMeadSimplex(new double[] {
1.0, 0.5 });
final PointValuePair optimum
= optimizer.optimize(new MaxEval(300),
new ObjectiveFunction(wrapped),
- simplex,
+ Simplex.of(new double[] { 1.0, 0.5 }),
+ new NelderMeadTransform(),
GoalType.MINIMIZE,
new InitialGuess(new double[] { -1.5, 4.0 }));
@@ -84,12 +84,12 @@ public class MultivariateFunctionPenaltyAdapterTest {
1000.0, new double[] {
100.0, 100.0 });
SimplexOptimizer optimizer = new SimplexOptimizer(new
SimplePointChecker<PointValuePair>(1.0e-11, 1.0e-20));
- final AbstractSimplex simplex = new NelderMeadSimplex(new double[] {
1.0, 0.5 });
final PointValuePair optimum
= optimizer.optimize(new MaxEval(600),
new ObjectiveFunction(wrapped),
- simplex,
+ Simplex.of(new double[] { 1.0, 0.5 }),
+ new NelderMeadTransform(),
GoalType.MINIMIZE,
new InitialGuess(new double[] { -1.5, 4.0 }));
@@ -109,12 +109,12 @@ public class MultivariateFunctionPenaltyAdapterTest {
1000.0, new double[] {
100.0, 100.0 });
SimplexOptimizer optimizer = new SimplexOptimizer(1e-10, 1e-30);
- final AbstractSimplex simplex = new NelderMeadSimplex(new double[] {
1.0, 0.5 });
final PointValuePair optimum
= optimizer.optimize(new MaxEval(300),
new ObjectiveFunction(wrapped),
- simplex,
+ Simplex.of(new double[] { 1.0, 0.5 }),
+ new NelderMeadTransform(),
GoalType.MINIMIZE,
new InitialGuess(new double[] { -1.5, 4.0 }));
@@ -134,12 +134,12 @@ public class MultivariateFunctionPenaltyAdapterTest {
1000.0, new double[] {
100.0, 100.0 });
SimplexOptimizer optimizer = new SimplexOptimizer(new
SimplePointChecker<PointValuePair>(1.0e-10, 1.0e-20));
- final AbstractSimplex simplex = new NelderMeadSimplex(new double[] {
1.0, 0.5 });
final PointValuePair optimum
= optimizer.optimize(new MaxEval(400),
new ObjectiveFunction(wrapped),
- simplex,
+ Simplex.of(new double[] { 1.0, 0.5 }),
+ new NelderMeadTransform(),
GoalType.MINIMIZE,
new InitialGuess(new double[] { -1.5, 4.0 }));
@@ -197,7 +197,5 @@ public class MultivariateFunctionPenaltyAdapterTest {
public double getBoundedYOptimum() {
return (yOptimum < yMin) ? yMin : ((yOptimum > yMax) ? yMax :
yOptimum);
}
-
}
-
}
diff --git
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/OptimTestUtils.java
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/OptimTestUtils.java
index 5739e55..2f5d9cb 100644
---
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/OptimTestUtils.java
+++
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/OptimTestUtils.java
@@ -238,32 +238,17 @@ final class OptimTestUtils {
}
}
+ // https://www.sfu.ca/~ssurjano/rastr.html
static class Rastrigin implements MultivariateFunction {
- private double axisratio;
- private double amplitude;
-
- Rastrigin() {
- this(1, 10);
- }
-
- Rastrigin(double axisratio, double amplitude) {
- this.axisratio = axisratio;
- this.amplitude = amplitude;
- }
-
+ private static final double A = 10;
@Override
public double value(double[] x) {
- double f = 0;
- double fac;
- for (int i = 0; i < x.length; ++i) {
- fac = AccurateMath.pow(axisratio, (i - 1.) / (x.length - 1.));
- if (i == 0 && x[i] < 0) {
- fac *= 1.;
- }
- f += fac * fac * x[i] * x[i] + amplitude
- * (1. - AccurateMath.cos(2. * AccurateMath.PI * fac *
x[i]));
+ double sum = 0;
+ for (int i = 0; i < x.length; i++) {
+ final double xi = x[i];
+ sum += xi * xi - A * AccurateMath.cos(2 * Math.PI * xi);
}
- return f;
+ return A * x.length + sum;
}
}
@@ -347,12 +332,23 @@ final class OptimTestUtils {
static double[] point(int n,
double value,
double jitter) {
+ final double[] ds = new double[n];
+ Arrays.fill(ds, value);
+ return point(ds, jitter);
+ }
+
+ /**
+ * @param point Point.
+ * @param jitter Random noise to add to each {@code value} element.
+ */
+ static double[] point(double[] value,
+ double jitter) {
final ContinuousUniformSampler s = new ContinuousUniformSampler(rng(),
-jitter,
jitter);
- final double[] ds = new double[n];
- for (int i = 0; i < n; i++) {
- ds[i] = value + s.sample();
+ final double[] ds = new double[value.length];
+ for (int i = 0; i < value.length; i++) {
+ ds[i] = value[i] + s.sample();
}
return ds;
}
diff --git
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/SimplexOptimizerMultiDirectionalTest.java
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/SimplexOptimizerMultiDirectionalTest.java
index 4b16492..644b042 100644
---
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/SimplexOptimizerMultiDirectionalTest.java
+++
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/SimplexOptimizerMultiDirectionalTest.java
@@ -17,6 +17,7 @@
package org.apache.commons.math4.legacy.optim.nonlinear.scalar.noderiv;
+import java.util.Arrays;
import org.apache.commons.math4.legacy.analysis.MultivariateFunction;
import
org.apache.commons.math4.legacy.exception.MathUnsupportedOperationException;
import org.apache.commons.math4.legacy.optim.InitialGuess;
@@ -29,6 +30,7 @@ import
org.apache.commons.math4.legacy.optim.nonlinear.scalar.ObjectiveFunction;
import org.apache.commons.math4.legacy.core.MathArrays;
import org.junit.Assert;
import org.junit.Test;
+import org.junit.Ignore;
public class SimplexOptimizerMultiDirectionalTest {
private static final int DIM = 13;
@@ -42,139 +44,22 @@ public class SimplexOptimizerMultiDirectionalTest {
new ObjectiveFunction(fourExtrema),
GoalType.MINIMIZE,
new InitialGuess(new double[] { -3, 0 }),
- new NelderMeadSimplex(new double[] { 0.2, 0.2 }),
+ Simplex.of(new double[] { 0.2, 0.2 }),
+ new MultiDirectionalTransform(),
new SimpleBounds(new double[] { -5, -1 },
new double[] { 5, 1 }));
}
@Test
- public void testMinimize1() {
- SimplexOptimizer optimizer = new SimplexOptimizer(1e-11, 1e-30);
- final OptimTestUtils.FourExtrema fourExtrema = new
OptimTestUtils.FourExtrema();
-
- final PointValuePair optimum
- = optimizer.optimize(new MaxEval(200),
- new ObjectiveFunction(fourExtrema),
- GoalType.MINIMIZE,
- new InitialGuess(new double[] { -3, 0 }),
- new MultiDirectionalSimplex(new double[] {
0.2, 0.2 }));
- Assert.assertEquals(fourExtrema.xM, optimum.getPoint()[0], 4e-6);
- Assert.assertEquals(fourExtrema.yP, optimum.getPoint()[1], 3e-6);
- Assert.assertEquals(fourExtrema.valueXmYp, optimum.getValue(), 8e-13);
- Assert.assertTrue(optimizer.getEvaluations() > 120);
- Assert.assertTrue(optimizer.getEvaluations() < 150);
-
- // Check that the number of iterations is updated (MATH-949).
- Assert.assertTrue(optimizer.getIterations() > 0);
- }
-
- @Test
- public void testMinimize2() {
- SimplexOptimizer optimizer = new SimplexOptimizer(1e-11, 1e-30);
- final OptimTestUtils.FourExtrema fourExtrema = new
OptimTestUtils.FourExtrema();
-
- final PointValuePair optimum
- = optimizer.optimize(new MaxEval(200),
- new ObjectiveFunction(fourExtrema),
- GoalType.MINIMIZE,
- new InitialGuess(new double[] { 1, 0 }),
- new MultiDirectionalSimplex(new double[] {
0.2, 0.2 }));
- Assert.assertEquals(fourExtrema.xP, optimum.getPoint()[0], 2e-8);
- Assert.assertEquals(fourExtrema.yM, optimum.getPoint()[1], 3e-6);
- Assert.assertEquals(fourExtrema.valueXpYm, optimum.getValue(), 2e-12);
- Assert.assertTrue(optimizer.getEvaluations() > 120);
- Assert.assertTrue(optimizer.getEvaluations() < 150);
-
- // Check that the number of iterations is updated (MATH-949).
- Assert.assertTrue(optimizer.getIterations() > 0);
- }
-
- @Test
- public void testMaximize1() {
- SimplexOptimizer optimizer = new SimplexOptimizer(1e-11, 1e-30);
- final OptimTestUtils.FourExtrema fourExtrema = new
OptimTestUtils.FourExtrema();
-
- final PointValuePair optimum
- = optimizer.optimize(new MaxEval(200),
- new ObjectiveFunction(fourExtrema),
- GoalType.MAXIMIZE,
- new InitialGuess(new double[] { -3.0, 0.0 }),
- new MultiDirectionalSimplex(new double[] {
0.2, 0.2 }));
- Assert.assertEquals(fourExtrema.xM, optimum.getPoint()[0], 7e-7);
- Assert.assertEquals(fourExtrema.yM, optimum.getPoint()[1], 3e-7);
- Assert.assertEquals(fourExtrema.valueXmYm, optimum.getValue(), 2e-14);
- Assert.assertTrue(optimizer.getEvaluations() > 120);
- Assert.assertTrue(optimizer.getEvaluations() < 150);
-
- // Check that the number of iterations is updated (MATH-949).
- Assert.assertTrue(optimizer.getIterations() > 0);
- }
-
- @Test
- public void testMaximize2() {
- SimplexOptimizer optimizer = new SimplexOptimizer(new
SimpleValueChecker(1e-15, 1e-30));
- final OptimTestUtils.FourExtrema fourExtrema = new
OptimTestUtils.FourExtrema();
-
- final PointValuePair optimum
- = optimizer.optimize(new MaxEval(200),
- new ObjectiveFunction(fourExtrema),
- GoalType.MAXIMIZE,
- new InitialGuess(new double[] { 1, 0 }),
- new MultiDirectionalSimplex(new double[] {
0.2, 0.2 }));
- Assert.assertEquals(fourExtrema.xP, optimum.getPoint()[0], 2e-8);
- Assert.assertEquals(fourExtrema.yP, optimum.getPoint()[1], 3e-6);
- Assert.assertEquals(fourExtrema.valueXpYp, optimum.getValue(), 2e-12);
- Assert.assertTrue(optimizer.getEvaluations() > 180);
- Assert.assertTrue(optimizer.getEvaluations() < 220);
-
- // Check that the number of iterations is updated (MATH-949).
- Assert.assertTrue(optimizer.getIterations() > 0);
- }
-
- @Test
- public void testRosenbrock() {
- final OptimTestUtils.Rosenbrock rosenbrock = new
OptimTestUtils.Rosenbrock();
- SimplexOptimizer optimizer = new SimplexOptimizer(-1, 1e-3);
- PointValuePair optimum
- = optimizer.optimize(new MaxEval(100),
- new ObjectiveFunction(rosenbrock),
- GoalType.MINIMIZE,
- new InitialGuess(new double[] { -1.2, 1 }),
- new MultiDirectionalSimplex(new double[][] {
- { -1.2, 1.0 },
- { 0.9, 1.2 },
- { 3.5, -2.3 } }));
- Assert.assertTrue(optimizer.getEvaluations() > 50);
- Assert.assertTrue(optimizer.getEvaluations() < 100);
- Assert.assertTrue(optimum.getValue() > 1e-2);
- }
-
- @Test
- public void testPowell() {
- final OptimTestUtils.Powell powell = new OptimTestUtils.Powell();
- SimplexOptimizer optimizer = new SimplexOptimizer(-1, 1e-3);
- PointValuePair optimum
- = optimizer.optimize(new MaxEval(1000),
- new ObjectiveFunction(powell),
- GoalType.MINIMIZE,
- new InitialGuess(new double[] { 3, -1, 0, 1
}),
- new MultiDirectionalSimplex(4));
- Assert.assertTrue(optimizer.getEvaluations() > 800);
- Assert.assertTrue(optimizer.getEvaluations() < 900);
- Assert.assertTrue(optimum.getValue() > 1e-2);
- }
-
- @Test
public void testMath283() {
- // fails because MultiDirectional.iterateSimplex is looping forever
- // the while(true) should be replaced with a convergence check
SimplexOptimizer optimizer = new SimplexOptimizer(1e-14, 1e-14);
final OptimTestUtils.Gaussian2D function = new
OptimTestUtils.Gaussian2D(0, 0, 1);
PointValuePair estimate = optimizer.optimize(new MaxEval(1000),
new
ObjectiveFunction(function),
GoalType.MAXIMIZE,
new
InitialGuess(function.getMaximumPosition()),
- new
MultiDirectionalSimplex(2));
+ Simplex.of(2),
+ new
MultiDirectionalTransform());
final double EPSILON = 1e-5;
final double expectedMaximum = function.getMaximum();
final double actualMaximum = estimate.getValue();
@@ -187,91 +72,156 @@ public class SimplexOptimizerMultiDirectionalTest {
}
@Test
+ public void testFourExtremaMinimize1() {
+ final OptimTestUtils.FourExtrema f = new OptimTestUtils.FourExtrema();
+ doTest(f,
+ OptimTestUtils.point(new double[] {-3, 0}, 1e-1),
+ GoalType.MINIMIZE,
+ 105,
+ Simplex.of(OptimTestUtils.point(2, 0.2, 1e-2)),
+ new PointValuePair(new double[] {f.xM, f.yP}, f.valueXmYp),
+ 1e-6);
+ }
+ @Test
+ public void testFourExtremaMaximize1() {
+ final OptimTestUtils.FourExtrema f = new OptimTestUtils.FourExtrema();
+ doTest(f,
+ OptimTestUtils.point(new double[] {-3, 0}, 1e-1),
+ GoalType.MAXIMIZE,
+ 100,
+ Simplex.of(OptimTestUtils.point(2, 0.2, 1e-2)),
+ new PointValuePair(new double[] {f.xM, f.yM}, f.valueXmYm),
+ 1e-6);
+ }
+ @Test
+ public void testFourExtremaMinimize2() {
+ final OptimTestUtils.FourExtrema f = new OptimTestUtils.FourExtrema();
+ doTest(f,
+ OptimTestUtils.point(new double[] {1, 0}, 1e-1),
+ GoalType.MINIMIZE,
+ 100,
+ Simplex.of(OptimTestUtils.point(2, 0.2, 1e-2)),
+ new PointValuePair(new double[] {f.xP, f.yM}, f.valueXpYm),
+ 1e-6);
+ }
+ @Test
+ public void testFourExtremaMaximize2() {
+ final OptimTestUtils.FourExtrema f = new OptimTestUtils.FourExtrema();
+ doTest(f,
+ OptimTestUtils.point(new double[] {1, 0}, 1e-1),
+ GoalType.MAXIMIZE,
+ 110,
+ Simplex.of(OptimTestUtils.point(2, 0.2, 1e-2)),
+ new PointValuePair(new double[] {f.xP, f.yP}, f.valueXpYp),
+ 1e-6);
+ }
+
+ @Test
+ public void testRosenbrock() {
+ doTest(new OptimTestUtils.Rosenbrock(),
+ OptimTestUtils.point(new double[] { -1.2, 1 }, 1e-1),
+ GoalType.MINIMIZE,
+ 190,
+ new PointValuePair(OptimTestUtils.point(2, 1.0), 0.0),
+ 1e-4);
+ }
+
+ @Test
+ public void testPowell() {
+ doTest(new OptimTestUtils.Powell(),
+ OptimTestUtils.point(new double[] { 3, -1, 0, 1 }, 1e-1),
+ GoalType.MINIMIZE,
+ 420,
+ new PointValuePair(OptimTestUtils.point(4, 0.0), 0.0),
+ 2e-4);
+ }
+
+ @Test
public void testRosen() {
doTest(new OptimTestUtils.Rosen(),
OptimTestUtils.point(DIM, 0.1),
GoalType.MINIMIZE,
- 183861,
+ 186915,
new PointValuePair(OptimTestUtils.point(DIM, 1.0), 0.0),
1e-4);
}
- @Test
+ @Ignore@Test
public void testEllipse() {
doTest(new OptimTestUtils.Elli(),
- OptimTestUtils.point(DIM, 1.0),
+ OptimTestUtils.point(DIM, 1.0, 1e-1),
GoalType.MINIMIZE,
- 873,
+ 911,
new PointValuePair(OptimTestUtils.point(DIM, 0.0), 0.0),
- 1e-14);
+ 1e-9);
}
- @Test
+ @Ignore@Test
public void testElliRotated() {
doTest(new OptimTestUtils.ElliRotated(),
- OptimTestUtils.point(DIM, 1.0),
+ OptimTestUtils.point(DIM, 1.0, 1e-1),
GoalType.MINIMIZE,
- 873,
+ 911,
new PointValuePair(OptimTestUtils.point(DIM, 0.0), 0.0),
- 1e-14);
+ 1e-9);
}
@Test
public void testCigar() {
doTest(new OptimTestUtils.Cigar(),
- OptimTestUtils.point(DIM, 1.0),
+ OptimTestUtils.point(DIM, 1.0, 1e-1),
GoalType.MINIMIZE,
- 925,
+ 7000,
new PointValuePair(OptimTestUtils.point(DIM,0.0), 0.0),
- 1e-14);
+ 1e-6);
}
- @Test
+ @Ignore@Test
public void testTwoAxes() {
doTest(new OptimTestUtils.TwoAxes(),
- OptimTestUtils.point(DIM, 1.0),
+ OptimTestUtils.point(DIM, 1.0, 1e-1),
GoalType.MINIMIZE,
- 1159,
+ 1219,
new PointValuePair(OptimTestUtils.point(DIM, 0.0), 0.0),
- 1e-14);
+ 1e-12);
}
- @Test
+ @Ignore@Test
public void testCigTab() {
doTest(new OptimTestUtils.CigTab(),
- OptimTestUtils.point(DIM, 1.0),
+ OptimTestUtils.point(DIM, 1.0, 1e-1),
GoalType.MINIMIZE,
- 795,
+ 827,
new PointValuePair(OptimTestUtils.point(DIM, 0.0), 0.0),
- 1e-14);
+ 1e-8);
}
@Test
public void testSphere() {
doTest(new OptimTestUtils.Sphere(),
- OptimTestUtils.point(DIM, 1.0),
+ OptimTestUtils.point(DIM, 1.0, 1e-1),
GoalType.MINIMIZE,
- 665,
+ 2580,
new PointValuePair(OptimTestUtils.point(DIM, 0.0), 0.0),
- 1e-14);
+ 1e-6);
}
- @Test
+ @Ignore@Test
public void testTablet() {
doTest(new OptimTestUtils.Tablet(),
- OptimTestUtils.point(DIM, 1.0),
+ OptimTestUtils.point(DIM, 1.0, 1e-1),
GoalType.MINIMIZE,
- 873,
+ 911,
new PointValuePair(OptimTestUtils.point(DIM, 0.0), 0.0),
- 1e-14);
+ 1e-9);
}
- @Test
+ @Ignore@Test
public void testDiffPow() {
doTest(new OptimTestUtils.DiffPow(),
- OptimTestUtils.point(DIM, 1.0),
+ OptimTestUtils.point(DIM, 1.0, 1e-1),
GoalType.MINIMIZE,
- 1000,
+ 631,
new PointValuePair(OptimTestUtils.point(DIM, 0.0), 0.0),
1e-14);
}
@@ -281,27 +231,27 @@ public class SimplexOptimizerMultiDirectionalTest {
doTest(new OptimTestUtils.SsDiffPow(),
OptimTestUtils.point(DIM / 2, 1.0, 1e-1),
GoalType.MINIMIZE,
- 5000,
+ 4000,
new PointValuePair(OptimTestUtils.point(DIM / 2, 0.0), 0.0),
1e-3);
}
- @Test
+ @Ignore@Test
public void testAckley() {
doTest(new OptimTestUtils.Ackley(),
OptimTestUtils.point(DIM, 1.0, 1e-1),
GoalType.MINIMIZE,
- 7500,
+ 7900,
new PointValuePair(OptimTestUtils.point(DIM, 0.0), 0d),
1e-11);
}
- @Test
+ @Ignore@Test
public void testRastrigin() {
doTest(new OptimTestUtils.Rastrigin(),
- OptimTestUtils.point(DIM, 1.0, 1e-1),
+ OptimTestUtils.point(DIM, 1.0, 2e-1),
GoalType.MINIMIZE,
- 5000,
+ 4600,
new PointValuePair(OptimTestUtils.point(DIM, 0.0), 0d),
1e-6);
}
@@ -320,15 +270,53 @@ public class SimplexOptimizerMultiDirectionalTest {
int maxEvaluations,
PointValuePair expected,
double tol) {
- final int dim = startPoint.length;
- final SimplexOptimizer optim = new SimplexOptimizer(1e-10, 1e-12);
- final PointValuePair result = optim.optimize(new
MaxEval(maxEvaluations),
+ doTest(func,
+ startPoint,
+ goal,
+ maxEvaluations,
+ Simplex.of(startPoint.length, 1),
+ expected,
+ tol);
+ }
+
+ /**
+ * @param func Function to optimize.
+ * @param startPoint Starting point.
+ * @param goal Minimization or maximization.
+ * @param maxEvaluations Maximum number of evaluations.
+ * @param simplexSteps Initial simplex.
+ * @param expected Expected optimum.
+ * @param tol Tolerance for checking that the optimum is correct.
+ */
+ private void doTest(MultivariateFunction func,
+ double[] startPoint,
+ GoalType goal,
+ int maxEvaluations,
+ Simplex simplex,
+ PointValuePair expected,
+ double tol) {
+ final int maxEval = Math.max(maxEvaluations, 12000);
+ final SimplexOptimizer optim = new SimplexOptimizer(1e-13, 1e-14);
+ final PointValuePair result = optim.optimize(new MaxEval(maxEval),
new
ObjectiveFunction(func),
goal,
new
InitialGuess(startPoint),
- new
MultiDirectionalSimplex(dim, 1));
+ simplex,
+ new
NelderMeadTransform());
+ final String name = func.getClass().getSimpleName();
+
+ final double[] endPoint = result.getPoint();
+ final double funcValue = result.getValue();
+ Assert.assertEquals(name + ": value at " + Arrays.toString(endPoint),
+ expected.getValue(),
+ funcValue, 1e-2);
+
final double dist = MathArrays.distance(expected.getPoint(),
- result.getPoint());
- Assert.assertEquals(0d, dist, tol);
+ endPoint);
+ Assert.assertEquals(name + ": distance to optimum", 0d, dist, tol);
+
+ final int nEval = optim.getEvaluations();
+ Assert.assertTrue(name + ": nEval=" + nEval,
+ nEval < maxEvaluations);
}
}
diff --git
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/SimplexOptimizerNelderMeadTest.java
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/SimplexOptimizerNelderMeadTest.java
index 42d3d99..e619c32 100644
---
a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/SimplexOptimizerNelderMeadTest.java
+++
b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/SimplexOptimizerNelderMeadTest.java
@@ -17,7 +17,7 @@
package org.apache.commons.math4.legacy.optim.nonlinear.scalar.noderiv;
-
+import java.util.Arrays;
import org.apache.commons.math4.legacy.analysis.MultivariateFunction;
import org.apache.commons.math4.legacy.analysis.MultivariateVectorFunction;
import
org.apache.commons.math4.legacy.exception.MathUnsupportedOperationException;
@@ -48,130 +48,13 @@ public class SimplexOptimizerNelderMeadTest {
new ObjectiveFunction(fourExtrema),
GoalType.MINIMIZE,
new InitialGuess(new double[] { -3, 0 }),
- new NelderMeadSimplex(new double[] { 0.2, 0.2 }),
+ Simplex.of(new double[] { 0.2, 0.2 }),
+ new NelderMeadTransform(),
new SimpleBounds(new double[] { -5, -1 },
new double[] { 5, 1 }));
}
@Test
- public void testMinimize1() {
- SimplexOptimizer optimizer = new SimplexOptimizer(1e-10, 1e-30);
- final OptimTestUtils.FourExtrema fourExtrema = new
OptimTestUtils.FourExtrema();
-
- final PointValuePair optimum
- = optimizer.optimize(new MaxEval(100),
- new ObjectiveFunction(fourExtrema),
- GoalType.MINIMIZE,
- new InitialGuess(new double[] { -3, 0 }),
- new NelderMeadSimplex(new double[] { 0.2, 0.2
}));
- Assert.assertEquals(fourExtrema.xM, optimum.getPoint()[0], 2e-7);
- Assert.assertEquals(fourExtrema.yP, optimum.getPoint()[1], 2e-5);
- Assert.assertEquals(fourExtrema.valueXmYp, optimum.getValue(), 6e-12);
- Assert.assertTrue(optimizer.getEvaluations() > 60);
- Assert.assertTrue(optimizer.getEvaluations() < 90);
-
- // Check that the number of iterations is updated (MATH-949).
- Assert.assertTrue(optimizer.getIterations() > 0);
- }
-
- @Test
- public void testMinimize2() {
- SimplexOptimizer optimizer = new SimplexOptimizer(1e-10, 1e-30);
- final OptimTestUtils.FourExtrema fourExtrema = new
OptimTestUtils.FourExtrema();
-
- final PointValuePair optimum
- = optimizer.optimize(new MaxEval(100),
- new ObjectiveFunction(fourExtrema),
- GoalType.MINIMIZE,
- new InitialGuess(new double[] { 1, 0 }),
- new NelderMeadSimplex(new double[] { 0.2, 0.2
}));
- Assert.assertEquals(fourExtrema.xP, optimum.getPoint()[0], 5e-6);
- Assert.assertEquals(fourExtrema.yM, optimum.getPoint()[1], 6e-6);
- Assert.assertEquals(fourExtrema.valueXpYm, optimum.getValue(), 1e-11);
- Assert.assertTrue(optimizer.getEvaluations() > 60);
- Assert.assertTrue(optimizer.getEvaluations() < 90);
-
- // Check that the number of iterations is updated (MATH-949).
- Assert.assertTrue(optimizer.getIterations() > 0);
- }
-
- @Test
- public void testMaximize1() {
- SimplexOptimizer optimizer = new SimplexOptimizer(1e-10, 1e-30);
- final OptimTestUtils.FourExtrema fourExtrema = new
OptimTestUtils.FourExtrema();
-
- final PointValuePair optimum
- = optimizer.optimize(new MaxEval(100),
- new ObjectiveFunction(fourExtrema),
- GoalType.MAXIMIZE,
- new InitialGuess(new double[] { -3, 0 }),
- new NelderMeadSimplex(new double[] { 0.2, 0.2
}));
- Assert.assertEquals(fourExtrema.xM, optimum.getPoint()[0], 1e-5);
- Assert.assertEquals(fourExtrema.yM, optimum.getPoint()[1], 3e-6);
- Assert.assertEquals(fourExtrema.valueXmYm, optimum.getValue(), 3e-12);
- Assert.assertTrue(optimizer.getEvaluations() > 60);
- Assert.assertTrue(optimizer.getEvaluations() < 90);
-
- // Check that the number of iterations is updated (MATH-949).
- Assert.assertTrue(optimizer.getIterations() > 0);
- }
-
- @Test
- public void testMaximize2() {
- SimplexOptimizer optimizer = new SimplexOptimizer(1e-10, 1e-30);
- final OptimTestUtils.FourExtrema fourExtrema = new
OptimTestUtils.FourExtrema();
-
- final PointValuePair optimum
- = optimizer.optimize(new MaxEval(100),
- new ObjectiveFunction(fourExtrema),
- GoalType.MAXIMIZE,
- new InitialGuess(new double[] { 1, 0 }),
- new NelderMeadSimplex(new double[] { 0.2, 0.2
}));
- Assert.assertEquals(fourExtrema.xP, optimum.getPoint()[0], 4e-6);
- Assert.assertEquals(fourExtrema.yP, optimum.getPoint()[1], 5e-6);
- Assert.assertEquals(fourExtrema.valueXpYp, optimum.getValue(), 7e-12);
- Assert.assertTrue(optimizer.getEvaluations() > 60);
- Assert.assertTrue(optimizer.getEvaluations() < 90);
-
- // Check that the number of iterations is updated (MATH-949).
- Assert.assertTrue(optimizer.getIterations() > 0);
- }
-
- @Test
- public void testRosenbrock() {
-
- OptimTestUtils.Rosenbrock rosenbrock = new OptimTestUtils.Rosenbrock();
- SimplexOptimizer optimizer = new SimplexOptimizer(-1, 1e-3);
- PointValuePair optimum
- = optimizer.optimize(new MaxEval(100),
- new ObjectiveFunction(rosenbrock),
- GoalType.MINIMIZE,
- new InitialGuess(new double[] { -1.2, 1 }),
- new NelderMeadSimplex(new double[][] {
- { -1.2, 1 },
- { 0.9, 1.2 },
- { 3.5, -2.3 } }));
- Assert.assertTrue(optimizer.getEvaluations() > 40);
- Assert.assertTrue(optimizer.getEvaluations() < 50);
- Assert.assertTrue(optimum.getValue() < 8e-4);
- }
-
- @Test
- public void testPowell() {
- OptimTestUtils.Powell powell = new OptimTestUtils.Powell();
- SimplexOptimizer optimizer = new SimplexOptimizer(-1, 1e-3);
- PointValuePair optimum =
- optimizer.optimize(new MaxEval(200),
- new ObjectiveFunction(powell),
- GoalType.MINIMIZE,
- new InitialGuess(new double[] { 3, -1, 0, 1 }),
- new NelderMeadSimplex(4));
- Assert.assertTrue(optimizer.getEvaluations() > 110);
- Assert.assertTrue(optimizer.getEvaluations() < 130);
- Assert.assertTrue(optimum.getValue() < 2e-3);
- }
-
- @Test
public void testLeastSquares1() {
final RealMatrix factors
= new Array2DRowRealMatrix(new double[][] {
@@ -190,11 +73,13 @@ public class SimplexOptimizerNelderMeadTest {
new ObjectiveFunction(ls),
GoalType.MINIMIZE,
new InitialGuess(new double[] { 10, 10 }),
- new NelderMeadSimplex(2));
- Assert.assertEquals( 2, optimum.getPointRef()[0], 3e-5);
+ Simplex.of(2),
+ new NelderMeadTransform());
+ Assert.assertEquals( 2, optimum.getPointRef()[0], 1e-3);
Assert.assertEquals(-3, optimum.getPointRef()[1], 4e-4);
- Assert.assertTrue(optimizer.getEvaluations() > 60);
- Assert.assertTrue(optimizer.getEvaluations() < 80);
+ final int nEval = optimizer.getEvaluations();
+ Assert.assertTrue("nEval=" + nEval, nEval > 60);
+ Assert.assertTrue("nEval=" + nEval, nEval < 80);
Assert.assertTrue(optimum.getValue() < 1.0e-6);
}
@@ -217,11 +102,13 @@ public class SimplexOptimizerNelderMeadTest {
new ObjectiveFunction(ls),
GoalType.MINIMIZE,
new InitialGuess(new double[] { 10, 10 }),
- new NelderMeadSimplex(2));
- Assert.assertEquals( 2, optimum.getPointRef()[0], 5e-5);
+ Simplex.of(2),
+ new NelderMeadTransform());
+ Assert.assertEquals( 2, optimum.getPointRef()[0], 1e-4);
Assert.assertEquals(-3, optimum.getPointRef()[1], 8e-4);
- Assert.assertTrue(optimizer.getEvaluations() > 60);
- Assert.assertTrue(optimizer.getEvaluations() < 80);
+ final int nEval = optimizer.getEvaluations();
+ Assert.assertTrue("nEval=" + nEval, nEval > 70);
+ Assert.assertTrue("nEval=" + nEval, nEval < 85);
Assert.assertTrue(optimum.getValue() < 1e-6);
}
@@ -246,11 +133,13 @@ public class SimplexOptimizerNelderMeadTest {
new ObjectiveFunction(ls),
GoalType.MINIMIZE,
new InitialGuess(new double[] { 10, 10 }),
- new NelderMeadSimplex(2));
- Assert.assertEquals( 2, optimum.getPointRef()[0], 2e-3);
- Assert.assertEquals(-3, optimum.getPointRef()[1], 8e-4);
- Assert.assertTrue(optimizer.getEvaluations() > 60);
- Assert.assertTrue(optimizer.getEvaluations() < 80);
+ Simplex.of(2),
+ new NelderMeadTransform());
+ Assert.assertEquals( 2, optimum.getPointRef()[0], 1e-2);
+ Assert.assertEquals(-3, optimum.getPointRef()[1], 1e-2);
+ final int nEval = optimizer.getEvaluations();
+ Assert.assertTrue("nEval=" + nEval, nEval > 60);
+ Assert.assertTrue("nEval=" + nEval, nEval < 80);
Assert.assertTrue(optimum.getValue() < 1e-6);
}
@@ -262,7 +151,73 @@ public class SimplexOptimizerNelderMeadTest {
new ObjectiveFunction(powell),
GoalType.MINIMIZE,
new InitialGuess(new double[] { 3, -1, 0, 1 }),
- new NelderMeadSimplex(4));
+ Simplex.of(4),
+ new NelderMeadTransform());
+ }
+
+ @Test
+ public void testFourExtremaMinimize1() {
+ final OptimTestUtils.FourExtrema f = new OptimTestUtils.FourExtrema();
+ doTest(f,
+ OptimTestUtils.point(new double[] {-3, 0}, 1e-1),
+ GoalType.MINIMIZE,
+ 105,
+ Simplex.of(OptimTestUtils.point(2, 0.2, 1e-2)),
+ new PointValuePair(new double[] {f.xM, f.yP}, f.valueXmYp),
+ 1e-6);
+ }
+ @Test
+ public void testFourExtremaMaximize1() {
+ final OptimTestUtils.FourExtrema f = new OptimTestUtils.FourExtrema();
+ doTest(f,
+ OptimTestUtils.point(new double[] {-3, 0}, 1e-1),
+ GoalType.MAXIMIZE,
+ 100,
+ Simplex.of(OptimTestUtils.point(2, 0.2, 1e-2)),
+ new PointValuePair(new double[] {f.xM, f.yM}, f.valueXmYm),
+ 1e-6);
+ }
+ @Test
+ public void testFourExtremaMinimize2() {
+ final OptimTestUtils.FourExtrema f = new OptimTestUtils.FourExtrema();
+ doTest(f,
+ OptimTestUtils.point(new double[] {1, 0}, 1e-1),
+ GoalType.MINIMIZE,
+ 100,
+ Simplex.of(OptimTestUtils.point(2, 0.2, 1e-2)),
+ new PointValuePair(new double[] {f.xP, f.yM}, f.valueXpYm),
+ 1e-6);
+ }
+ @Test
+ public void testFourExtremaMaximize2() {
+ final OptimTestUtils.FourExtrema f = new OptimTestUtils.FourExtrema();
+ doTest(f,
+ OptimTestUtils.point(new double[] {1, 0}, 1e-1),
+ GoalType.MAXIMIZE,
+ 110,
+ Simplex.of(OptimTestUtils.point(2, 0.2, 1e-2)),
+ new PointValuePair(new double[] {f.xP, f.yP}, f.valueXpYp),
+ 1e-6);
+ }
+
+ @Test
+ public void testRosenbrock() {
+ doTest(new OptimTestUtils.Rosenbrock(),
+ OptimTestUtils.point(new double[] { -1.2, 1 }, 1e-1),
+ GoalType.MINIMIZE,
+ 180,
+ new PointValuePair(OptimTestUtils.point(2, 1.0), 0.0),
+ 1e-4);
+ }
+
+ @Test
+ public void testPowell() {
+ doTest(new OptimTestUtils.Powell(),
+ OptimTestUtils.point(new double[] { 3, -1, 0, 1 }, 1e-1),
+ GoalType.MINIMIZE,
+ 420,
+ new PointValuePair(OptimTestUtils.point(4, 0.0), 0.0),
+ 2e-4);
}
@Test
@@ -275,19 +230,17 @@ public class SimplexOptimizerNelderMeadTest {
1e-6);
}
- @Ignore
- @Test
+ @Ignore@Test
public void testEllipse() {
doTest(new OptimTestUtils.Elli(),
OptimTestUtils.point(DIM, 1.0, 2e-1),
GoalType.MINIMIZE,
- 12000,
+ 15000,
new PointValuePair(OptimTestUtils.point(DIM, 0.0), 0.0),
1e-6);
- }
+ }
- @Ignore
- @Test
+ @Ignore@Test
public void testElliRotated() {
doTest(new OptimTestUtils.ElliRotated(),
OptimTestUtils.point(DIM, 1.0, 1e-1),
@@ -307,8 +260,7 @@ public class SimplexOptimizerNelderMeadTest {
1e-6);
}
- @Ignore
- @Test
+ @Ignore@Test
public void testTwoAxes() {
doTest(new OptimTestUtils.TwoAxes(),
OptimTestUtils.point(DIM, 1.0, 1e-1),
@@ -316,10 +268,9 @@ public class SimplexOptimizerNelderMeadTest {
3451,
new PointValuePair(OptimTestUtils.point(DIM, 0.0), 0.0),
1e-14);
- }
+ }
- @Ignore
- @Test
+ @Ignore@Test
public void testCigTab() {
doTest(new OptimTestUtils.CigTab(),
OptimTestUtils.point(DIM, 1.0, 1e-1),
@@ -327,7 +278,7 @@ public class SimplexOptimizerNelderMeadTest {
7000,
new PointValuePair(OptimTestUtils.point(DIM, 0.0), 0.0),
1e-4);
- }
+ }
@Test
public void testSphere() {
@@ -339,8 +290,7 @@ public class SimplexOptimizerNelderMeadTest {
1e-6);
}
- @Ignore
- @Test
+ @Ignore@Test
public void testTablet() {
doTest(new OptimTestUtils.Tablet(),
OptimTestUtils.point(DIM, 1.0, 1e-1),
@@ -350,8 +300,7 @@ public class SimplexOptimizerNelderMeadTest {
1e-14);
}
- @Ignore
- @Test
+ @Ignore@Test
public void testDiffPow() {
doTest(new OptimTestUtils.DiffPow(),
OptimTestUtils.point(DIM, 1.0, 2e-1),
@@ -371,24 +320,22 @@ public class SimplexOptimizerNelderMeadTest {
1e-3);
}
- @Ignore
- @Test
+ @Ignore@Test
public void testAckley() {
doTest(new OptimTestUtils.Ackley(),
OptimTestUtils.point(DIM, 1.0, 2e-1),
GoalType.MINIMIZE,
- 10000,
+ 7900,
new PointValuePair(OptimTestUtils.point(DIM, 0.0), 0.0),
1e-11);
}
- @Ignore
- @Test
+ @Ignore@Test
public void testRastrigin() {
doTest(new OptimTestUtils.Rastrigin(),
OptimTestUtils.point(DIM, 1.0, 2e-1),
GoalType.MINIMIZE,
- 10000,
+ 4600,
new PointValuePair(OptimTestUtils.point(DIM, 0.0), 0.0),
0);
}
@@ -407,15 +354,53 @@ public class SimplexOptimizerNelderMeadTest {
int maxEvaluations,
PointValuePair expected,
double tol) {
- final int dim = startPoint.length;
+ doTest(func,
+ startPoint,
+ goal,
+ maxEvaluations,
+ Simplex.of(startPoint.length, 1),
+ expected,
+ tol);
+ }
+
+ /**
+ * @param func Function to optimize.
+ * @param startPoint Starting point.
+ * @param goal Minimization or maximization.
+ * @param maxEvaluations Maximum number of evaluations.
+ * @param simplexSteps Initial simplex.
+ * @param expected Expected optimum.
+ * @param tol Tolerance for checking that the optimum is correct.
+ */
+ private void doTest(MultivariateFunction func,
+ double[] startPoint,
+ GoalType goal,
+ int maxEvaluations,
+ Simplex simplex,
+ PointValuePair expected,
+ double tol) {
+ final int maxEval = Math.max(maxEvaluations, 12000);
final SimplexOptimizer optim = new SimplexOptimizer(1e-13, 1e-14);
- final PointValuePair result = optim.optimize(new
MaxEval(maxEvaluations),
+ final PointValuePair result = optim.optimize(new MaxEval(maxEval),
new
ObjectiveFunction(func),
goal,
new
InitialGuess(startPoint),
- new
NelderMeadSimplex(dim, 1));
+ simplex,
+ new
NelderMeadTransform());
+ final String name = func.getClass().getSimpleName();
+
+ final double[] endPoint = result.getPoint();
+ final double funcValue = result.getValue();
+ Assert.assertEquals(name + ": value at " + Arrays.toString(endPoint),
+ expected.getValue(),
+ funcValue, 1e-2);
+
final double dist = MathArrays.distance(expected.getPoint(),
- result.getPoint());
- Assert.assertEquals(0d, dist, tol);
+ endPoint);
+ Assert.assertEquals(name + ": distance to optimum", 0d, dist, tol);
+
+ final int nEval = optim.getEvaluations();
+ Assert.assertTrue(name + ": nEval=" + nEval,
+ nEval < maxEvaluations);
}
}
