Author: luc
Date: Mon Sep 10 00:38:55 2007
New Revision: 574159
URL: http://svn.apache.org/viewvc?rev=574159&view=rev
Log:
fixed javadoc
Modified:
commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/DirectSearchOptimizer.java
Modified: commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/DirectSearchOptimizer.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/DirectSearchOptimizer.java?rev=574159&r1=574158&r2=574159&view=diff
==============================================================================
 commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/DirectSearchOptimizer.java
(original)
+++ commons/proper/math/trunk/src/java/org/apache/commons/math/optimization/DirectSearchOptimizer.java
Mon Sep 10 00:38:55 2007
@@ 53,13 +53,12 @@
* set of n+1 points in dimension n) that is updated by the algorithms
* steps.</p>
 * <p>The instances can be built either in singlestart or in
+ * <p>Minimization can be attempted either in singlestart or in
* multistart mode. Multistart 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 multistart mode, the {@link #minimizes(CostFunction,
 * int, ConvergenceChecker, double[], double[]) minimizes}
 * method returns the best minimum found after all starts, and the
+ * algorithm. The various multistartenabled <code>minimizes</code>
+ * 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.</p>
* <p>The optimization is performed in singlestart mode.</p>
@@ 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.</p>
* <p>The optimization is performed in multistart mode.</p>
@@ 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 @@
* <p>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.</p>
@@ 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}).</p>
* @return array containing the minima, or null if {@link
* #minimizes(CostFunction, int, ConvergenceChecker, double[], double[])
