You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by er...@apache.org on 2021/08/07 13:36:00 UTC
[commons-math] 03/11: Move utility method "newPoint" to "Simplex"
class.
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 fd3313724e3834f3229e05be448950539d77c9d8
Author: Gilles Sadowski <gi...@gmail.com>
AuthorDate: Thu Jul 29 19:18:21 2021 +0200
Move utility method "newPoint" to "Simplex" class.
Reduce visibility of utility methods to "package-private".
---
.../scalar/noderiv/NelderMeadTransform.java | 65 ++++++----------------
.../optim/nonlinear/scalar/noderiv/Simplex.java | 53 +++++++++++++++++-
2 files changed, 67 insertions(+), 51 deletions(-)
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
index 1fbb88a..6933c6f 100644
--- 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
@@ -102,10 +102,10 @@ public class NelderMeadTransform
}
// Reflection.
- final PointValuePair reflected = newPoint(centroid,
- -alpha,
- xWorst,
- evaluationFunction);
+ final PointValuePair reflected = Simplex.newPoint(centroid,
+ -alpha,
+ xWorst,
+ evaluationFunction);
if (comparator.compare(reflected, secondWorst) < 0 &&
comparator.compare(best, reflected) <= 0) {
return newSimplex.withReplacement(n, reflected);
@@ -113,10 +113,10 @@ public class NelderMeadTransform
if (comparator.compare(reflected, best) < 0) {
// Expansion.
- final PointValuePair expanded = newPoint(centroid,
- -gamma,
- xWorst,
- evaluationFunction);
+ final PointValuePair expanded = Simplex.newPoint(centroid,
+ -gamma,
+ xWorst,
+ evaluationFunction);
if (comparator.compare(expanded, reflected) < 0) {
return newSimplex.withReplacement(n, expanded);
} else {
@@ -126,57 +126,26 @@ public class NelderMeadTransform
if (comparator.compare(reflected, worst) < 0) {
// Outside contraction.
- final PointValuePair contracted = newPoint(centroid,
- rho,
- reflected.getPoint(),
- evaluationFunction);
+ final PointValuePair contracted = Simplex.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);
+ final PointValuePair contracted = Simplex.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;
+ return newSimplex.shrink(sigma, evaluationFunction);
};
}
-
- /**
- * 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
index 63e6043..a2d4d4b 100644
--- 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
@@ -244,7 +244,7 @@ public final class Simplex implements OptimizationData {
* @throws DimensionMismatchException if the start point does not match
* simplex dimension.
*/
- public Simplex translate(final double[] point) {
+ /* package private */ Simplex translate(final double[] point) {
final int dim = getDimension();
if (dim != point.length) {
throw new DimensionMismatchException(dim, point.length);
@@ -275,8 +275,8 @@ public final class Simplex implements OptimizationData {
* @return a new instance.
* @throws IndexOutOfBoundsException if {@code index} is out of bounds.
*/
- public Simplex withReplacement(int index,
- PointValuePair point) {
+ /* package private */ Simplex withReplacement(int index,
+ PointValuePair point) {
final int len = points.size();
if (index < 0 ||
index >= len) {
@@ -299,4 +299,51 @@ public final class Simplex implements OptimizationData {
*/
public interface TransformFactory
extends BiFunction<MultivariateFunction, Comparator<PointValuePair>, UnaryOperator<Simplex>> {}
+
+ /**
+ * Utility for evaluating a point with coordinates \( a_i + s (b_i - a_i) \).
+ *
+ * @param a Cartesian coordinates.
+ * @param s Scaling factor.
+ * @param b Cartesian coordinates.
+ * @param function Evaluation function.
+ * @return a new point.
+ */
+ /* package private */ static PointValuePair newPoint(double[] a,
+ double s,
+ double[] b,
+ MultivariateFunction function) {
+ 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, function.value(r), false);
+ }
+
+ /**
+ * Utility for the "shrinking" a simplex: All the points will be transformed
+ * except the one at index 0.
+ *
+ * @param sigma Shrink factor.
+ * @param function Evaluation function.
+ * @return a new instance.
+ */
+ /* package private */ Simplex shrink(double sigma,
+ MultivariateFunction function) {
+ final int size = getSize();
+ final double[] xBest = get(0).getPoint();
+ Simplex newSimplex = this;
+ for (int i = 1; i < size; i++) {
+ final PointValuePair p = newPoint(xBest,
+ sigma,
+ get(i).getPoint(),
+ function);
+ newSimplex = newSimplex.withReplacement(i, p);
+ }
+
+ return newSimplex;
+ }
}