The instances can be built either in single-start or in + *

Minimization can be attempted either in single-start or in
* multi-start mode. Multi-start is a traditional way to try to avoid
- * beeing trapped in a local minimum and miss the global minimum of a
+ * being trapped in a local minimum and miss the global minimum of a
* function. It can also be used to verify the convergence of an
- * algorithm. In multi-start mode, the {@link #minimizes(CostFunction,
- * int, ConvergenceChecker, double[], double[]) minimizes}
- * method returns the best minimum found after all starts, and the
+ * algorithm. The various multi-start-enabled `minimizes`

+ * methods return the best minimum found after all starts, and the
* {@link #getMinima getMinima} method can be used to retrieve all
* minima from all starts (including the one already provided by the
* {@link #minimizes(CostFunction, int, ConvergenceChecker, double[],
@@ -87,7 +86,7 @@
* considered to represent two opposite vertices of a box parallel
* to the canonical axes of the space. The simplex is the subset of
* vertices encountered while going from vertexA to vertexB
- * travelling along the box edges only. This can be seen as a scaled
+ * traveling along the box edges only. This can be seen as a scaled
* regular simplex using the projected separation between the given
* points as the scaling factor along each coordinate axis.

The optimization is performed in single-start mode.

@@ -125,7 +124,7 @@ * considered to represent two opposite vertices of a box parallel * to the canonical axes of the space. The simplex is the subset of * vertices encountered while going from vertexA to vertexB - * travelling along the box edges only. This can be seen as a scaled + * traveling along the box edges only. This can be seen as a scaled * regular simplex using the projected separation between the given * points as the scaling factor along each coordinate axis. *The optimization is performed in multi-start mode.

@@ -154,12 +153,12 @@ int starts, long seed) throws CostException, ConvergenceException { - // set up the simplex travelling around the box + // set up the simplex traveling around the box buildSimplex(vertexA, vertexB); // we consider the simplex could have been produced by a generator // having its mean value at the center of the box, the standard - // deviation along each axe beeing the corresponding half size + // deviation along each axe being the corresponding half size double[] mean = new double[vertexA.length]; double[] standardDeviation = new double[vertexA.length]; for (int i = 0; i < vertexA.length; ++i) { @@ -343,7 +342,7 @@ *The two vertices are considered to represent two opposite * vertices of a box parallel to the canonical axes of the * space. The simplex is the subset of vertices encountered while - * going from vertexA to vertexB travelling along the box edges + * going from vertexA to vertexB traveling along the box edges * only. This can be seen as a scaled regular simplex using the * projected separation between the given points as the scaling * factor along each coordinate axis.

@@ -355,7 +354,7 @@ int n = vertexA.length; simplex = new PointCostPair[n + 1]; - // set up the simplex travelling around the box + // set up the simplex traveling around the box for (int i = 0; i <= n; ++i) { double[] vertex = new double[n]; if (i > 0) { @@ -441,7 +440,7 @@ * highest minimum cost, and null elements corresponding to the runs * that did not converge (all elements will be null if the {@link * #minimizes(CostFunction, int, ConvergenceChecker, double[], double[]) - * minimizes} method throwed a {@link ConvergenceException + * minimizes} method did throw a {@link ConvergenceException * ConvergenceException}). * @return array containing the minima, or null if {@link * #minimizes(CostFunction, int, ConvergenceChecker, double[], double[])