fixed missing space in package-info.java due to a script error

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/math/trunk@1178163 13f79535-47bb-0310-9956-ffa450edef68

src/main/java/org/apache/commons/math/analysis/function/package-info.java

@@ -21,6 +21,6 @@
  *      methods contained in {@link java.lang.Math}, as well as common
  *      mathematical functions such as the gaussian and sinc functions.
  *    </p>
- *  
+ *
  */
 package org.apache.commons.math.analysis.function;

src/main/java/org/apache/commons/math/analysis/integration/package-info.java

@@ -17,6 +17,6 @@
 /**
  *
  *     Numerical integration (quadrature) algorithms for univariate real functions.
- *    
+ *
  */
 package org.apache.commons.math.analysis.integration;

src/main/java/org/apache/commons/math/analysis/interpolation/package-info.java

@@ -17,6 +17,6 @@
 /**
  *
  *     Univariate real functions interpolation algorithms.
- *    
+ *
  */
 package org.apache.commons.math.analysis.interpolation;

src/main/java/org/apache/commons/math/analysis/package-info.java

@@ -28,6 +28,6 @@
  *      function to find their roots, or integrate them, or ... Functions can be multivariate
  *      or univariate, real vectorial or matrix valued, and they can be differentiable or not.
  *    </p>
- *  
+ *
  */
 package org.apache.commons.math.analysis;

src/main/java/org/apache/commons/math/analysis/polynomials/package-info.java

@@ -18,6 +18,6 @@
  *
  *     Univariate real polynomials implementations, seen as differentiable
  *     univariate real functions.
- *    
+ *
  */
 package org.apache.commons.math.analysis.polynomials;

src/main/java/org/apache/commons/math/analysis/solvers/package-info.java

@@ -17,6 +17,6 @@
 /**
  *
  *     Root finding algorithms, for univariate real functions.
- *    
+ *
  */
 package org.apache.commons.math.analysis.solvers;

src/main/java/org/apache/commons/math/complex/package-info.java

@@ -18,6 +18,6 @@
  *
  *     Complex number type and implementations of complex transcendental
  *     functions.
- *    
+ *
  */
 package org.apache.commons.math.complex;

src/main/java/org/apache/commons/math/dfp/package-info.java

@@ -16,13 +16,13 @@
  */
 /**
  *
- *Decimal floating point library for Java
+ * Decimal floating point library for Java
  *
- *<p>Another floating point class.  This one is built using radix 10000
- *which is 10<sup>4</sup>, so its almost decimal.</p>
+ * <p>Another floating point class.  This one is built using radix 10000
+ * which is 10<sup>4</sup>, so its almost decimal.</p>
  *
- *<p>The design goals here are:
- *<ol>
+ * <p>The design goals here are:
+ * <ol>
  *  <li>Decimal math, or close to it</li>
  *  <li>Settable precision (but no mix between numbers using different settings)</li>
  *  <li>Portability.  Code should be keep as portable as possible.</li>
@@ -31,58 +31,58 @@
  *       algebraic operation</li>
  *  <li>Comply with IEEE 854-1987 as much as possible.
  *       (See IEEE 854-1987 notes below)</li>
- *</ol></p>
+ * </ol></p>
  *
- *<p>Trade offs:
- *<ol>
+ * <p>Trade offs:
+ * <ol>
  *  <li>Memory foot print.  I'm using more memory than necessary to
  *       represent numbers to get better performance.</li>
  *  <li>Digits are bigger, so rounding is a greater loss.  So, if you
  *       really need 12 decimal digits, better use 4 base 10000 digits
  *       there can be one partially filled.</li>
- *</ol></p>
+ * </ol></p>
  *
- *<p>Numbers are represented  in the following form:
- *<pre>
- *n  =  sign &times; mant &times; (radix)<sup>exp</sup>;</p>
- *</pre>
- *where sign is &plusmn;1, mantissa represents a fractional number between
- *zero and one.  mant[0] is the least significant digit.
- *exp is in the range of -32767 to 32768</p>
+ * <p>Numbers are represented  in the following form:
+ * <pre>
+ * n  =  sign &times; mant &times; (radix)<sup>exp</sup>;</p>
+ * </pre>
+ * where sign is &plusmn;1, mantissa represents a fractional number between
+ * zero and one.  mant[0] is the least significant digit.
+ * exp is in the range of -32767 to 32768</p>
  *
- *<p>IEEE 854-1987  Notes and differences</p>
+ * <p>IEEE 854-1987  Notes and differences</p>
  *
- *<p>IEEE 854 requires the radix to be either 2 or 10.  The radix here is
- *10000, so that requirement is not met, but  it is possible that a
- *subclassed can be made to make it behave as a radix 10
- *number.  It is my opinion that if it looks and behaves as a radix
- *10 number then it is one and that requirement would be met.</p>
+ * <p>IEEE 854 requires the radix to be either 2 or 10.  The radix here is
+ * 10000, so that requirement is not met, but  it is possible that a
+ * subclassed can be made to make it behave as a radix 10
+ * number.  It is my opinion that if it looks and behaves as a radix
+ * 10 number then it is one and that requirement would be met.</p>
  *
- *<p>The radix of 10000 was chosen because it should be faster to operate
- *on 4 decimal digits at once instead of one at a time.  Radix 10 behavior
- *can be realized by add an additional rounding step to ensure that
- *the number of decimal digits represented is constant.</p>
+ * <p>The radix of 10000 was chosen because it should be faster to operate
+ * on 4 decimal digits at once instead of one at a time.  Radix 10 behavior
+ * can be realized by add an additional rounding step to ensure that
+ * the number of decimal digits represented is constant.</p>
  *
- *<p>The IEEE standard specifically leaves out internal data encoding,
- *so it is reasonable to conclude that such a subclass of this radix
- *10000 system is merely an encoding of a radix 10 system.</p>
+ * <p>The IEEE standard specifically leaves out internal data encoding,
+ * so it is reasonable to conclude that such a subclass of this radix
+ * 10000 system is merely an encoding of a radix 10 system.</p>
  *
- *<p>IEEE 854 also specifies the existence of "sub-normal" numbers.  This
- *class does not contain any such entities.  The most significant radix
- *10000 digit is always non-zero.  Instead, we support "gradual underflow"
- *by raising the underflow flag for numbers less with exponent less than
- *expMin, but don't flush to zero until the exponent reaches MIN_EXP-digits.
- *Thus the smallest number we can represent would be:
- *1E(-(MIN_EXP-digits-1)&lowast;4),  eg, for digits=5, MIN_EXP=-32767, that would
- *be 1e-131092.</p>
+ * <p>IEEE 854 also specifies the existence of "sub-normal" numbers.  This
+ * class does not contain any such entities.  The most significant radix
+ * 10000 digit is always non-zero.  Instead, we support "gradual underflow"
+ * by raising the underflow flag for numbers less with exponent less than
+ * expMin, but don't flush to zero until the exponent reaches MIN_EXP-digits.
+ * Thus the smallest number we can represent would be:
+ * 1E(-(MIN_EXP-digits-1)&lowast;4),  eg, for digits=5, MIN_EXP=-32767, that would
+ * be 1e-131092.</p>
+ *
+ * <p>IEEE 854 defines that the implied radix point lies just to the right
+ * of the most significant digit and to the left of the remaining digits.
+ * This implementation puts the implied radix point to the left of all
+ * digits including the most significant one.  The most significant digit
+ * here is the one just to the right of the radix point.  This is a fine
+ * detail and is really only a matter of definition.  Any side effects of
+ * this can be rendered invisible by a subclass.</p>
  *
- *<p>IEEE 854 defines that the implied radix point lies just to the right
- *of the most significant digit and to the left of the remaining digits.
- *This implementation puts the implied radix point to the left of all
- *digits including the most significant one.  The most significant digit
- *here is the one just to the right of the radix point.  This is a fine
- *detail and is really only a matter of definition.  Any side effects of
- *this can be rendered invisible by a subclass.</p>
- *    
  */
 package org.apache.commons.math.dfp;

src/main/java/org/apache/commons/math/distribution/package-info.java

@@ -15,6 +15,6 @@
  * limitations under the License.
  */
 /**
- *Implementations of common discrete and continuous distributions.
+ * Implementations of common discrete and continuous distributions.
  */
 package org.apache.commons.math.distribution;

src/main/java/org/apache/commons/math/exception/package-info.java

@@ -18,6 +18,6 @@
  *
  *     Specialized exceptions for algorithms errors. The exceptions can be localized
  *     using simple java properties.
- *    
+ *
  */
 package org.apache.commons.math.exception;

src/main/java/org/apache/commons/math/exception/util/package-info.java

@@ -17,6 +17,6 @@
 /**
  *
  *    Classes supporting exception localization.
- *  
+ *
  */
 package org.apache.commons.math.exception.util;

src/main/java/org/apache/commons/math/filter/package-info.java

@@ -15,6 +15,6 @@
  * limitations under the License.
  */
 /**
- *Implementations of common discrete-time linear filters.
+ * Implementations of common discrete-time linear filters.
  */
 package org.apache.commons.math.filter;

src/main/java/org/apache/commons/math/fraction/package-info.java

@@ -17,6 +17,6 @@
 /**
  *
  *    Fraction number type and fraction number formatting.
- *  
+ *
  */
 package org.apache.commons.math.fraction;

src/main/java/org/apache/commons/math/genetics/package-info.java

@@ -16,9 +16,9 @@
  */
 /**
  *
- *<p>
- *This package provides Genetic Algorithms components and implementations.
- *</p>
+ * <p>
+ * This package provides Genetic Algorithms components and implementations.
+ * </p>
  *
  */
 package org.apache.commons.math.genetics;

src/main/java/org/apache/commons/math/geometry/euclidean/oned/package-info.java

@@ -16,9 +16,9 @@
  */
 /**
  *
- *<p>
- *This package provides basic 1D geometry components.
- *</p>
+ * <p>
+ * This package provides basic 1D geometry components.
+ * </p>
  *
  */
 package org.apache.commons.math.geometry.euclidean.oned;

src/main/java/org/apache/commons/math/geometry/euclidean/threed/package-info.java

@@ -16,9 +16,9 @@
  */
 /**
  *
- *<p>
- *This package provides basic 3D geometry components.
- *</p>
+ * <p>
+ * This package provides basic 3D geometry components.
+ * </p>
  *
  */
 package org.apache.commons.math.geometry.euclidean.threed;

src/main/java/org/apache/commons/math/geometry/euclidean/twod/package-info.java

@@ -16,9 +16,9 @@
  */
 /**
  *
- *<p>
- *This package provides basic 2D geometry components.
- *</p>
+ * <p>
+ * This package provides basic 2D geometry components.
+ * </p>
  *
  */
 package org.apache.commons.math.geometry.euclidean.twod;

src/main/java/org/apache/commons/math/geometry/package-info.java

@@ -16,10 +16,10 @@
  */
 /**
  *
- *<p>
- *This package is the top level package for geometry. It provides only a few interfaces
- *related to vectorial/affine spaces that are implemented in sub-packages.
- *</p>
+ * <p>
+ * This package is the top level package for geometry. It provides only a few interfaces
+ * related to vectorial/affine spaces that are implemented in sub-packages.
+ * </p>
  *
  */
 package org.apache.commons.math.geometry;

src/main/java/org/apache/commons/math/geometry/partitioning/package-info.java

@@ -16,92 +16,92 @@
  */
 /**
  *
- *This package provides classes to implement Binary Space Partition trees.
+ * This package provides classes to implement Binary Space Partition trees.
  *
- *<p>
- *{@link org.apache.commons.math.geometry.partitioning.BSPTree BSP trees}
- *are an efficient way to represent parts of space and in particular
- *polytopes (line segments in 1D, polygons in 2D and polyhedrons in 3D)
- *and to operate on them. The main principle is to recursively subdivide
- *the space using simple hyperplanes (points in 1D, lines in 2D, planes
- *in 3D).
- *</p>
+ * <p>
+ * {@link org.apache.commons.math.geometry.partitioning.BSPTree BSP trees}
+ * are an efficient way to represent parts of space and in particular
+ * polytopes (line segments in 1D, polygons in 2D and polyhedrons in 3D)
+ * and to operate on them. The main principle is to recursively subdivide
+ * the space using simple hyperplanes (points in 1D, lines in 2D, planes
+ * in 3D).
+ * </p>
  *
- *<p>
- *We start with a tree composed of a single node without any cut
- *hyperplane: it represents the complete space, which is a convex
- *part. If we add a cut hyperplane to this node, this represents a
- *partition with the hyperplane at the node level and two half spaces at
- *each side of the cut hyperplane. These half-spaces are represented by
- *two child nodes without any cut hyperplanes associated, the plus child
- *which represents the half space on the plus side of the cut hyperplane
- *and the minus child on the other side. Continuing the subdivisions, we
- *end up with a tree having internal nodes that are associated with a
- *cut hyperplane and leaf nodes without any hyperplane which correspond
- *to convex parts.
- *</p>
+ * <p>
+ * We start with a tree composed of a single node without any cut
+ * hyperplane: it represents the complete space, which is a convex
+ * part. If we add a cut hyperplane to this node, this represents a
+ * partition with the hyperplane at the node level and two half spaces at
+ * each side of the cut hyperplane. These half-spaces are represented by
+ * two child nodes without any cut hyperplanes associated, the plus child
+ * which represents the half space on the plus side of the cut hyperplane
+ * and the minus child on the other side. Continuing the subdivisions, we
+ * end up with a tree having internal nodes that are associated with a
+ * cut hyperplane and leaf nodes without any hyperplane which correspond
+ * to convex parts.
+ * </p>
  *
- *<p>
- *When BSP trees are used to represent polytopes, the convex parts are
- *known to be completely inside or outside the polytope as long as there
- *is no facet in the part (which is obviously the case if the cut
- *hyperplanes have been chosen as the underlying hyperplanes of the
- *facets (this is called an autopartition) and if the subdivision
- *process has been continued until all facets have been processed. It is
- *important to note that the polytope is <em>not</em> defined by a
- *single part, but by several convex ones. This is the property that
- *allows BSP-trees to represent non-convex polytopes despites all parts
- *are convex. The {@link
- *org.apache.commons.math.geometry.partitioning.Region Region} class is
- *devoted to this representation, it is build on top of the {@link
- *org.apache.commons.math.geometry.partitioning.BSPTree BSPTree} class using
- *boolean objects as the leaf nodes attributes to represent the
- *inside/outside property of each leaf part, and also adds various
- *methods dealing with boundaries (i.e. the separation between the
- *inside and the outside parts).
- *</p>
+ * <p>
+ * When BSP trees are used to represent polytopes, the convex parts are
+ * known to be completely inside or outside the polytope as long as there
+ * is no facet in the part (which is obviously the case if the cut
+ * hyperplanes have been chosen as the underlying hyperplanes of the
+ * facets (this is called an autopartition) and if the subdivision
+ * process has been continued until all facets have been processed. It is
+ * important to note that the polytope is <em>not</em> defined by a
+ * single part, but by several convex ones. This is the property that
+ * allows BSP-trees to represent non-convex polytopes despites all parts
+ * are convex. The {@link
+ * org.apache.commons.math.geometry.partitioning.Region Region} class is
+ * devoted to this representation, it is build on top of the {@link
+ * org.apache.commons.math.geometry.partitioning.BSPTree BSPTree} class using
+ * boolean objects as the leaf nodes attributes to represent the
+ * inside/outside property of each leaf part, and also adds various
+ * methods dealing with boundaries (i.e. the separation between the
+ * inside and the outside parts).
+ * </p>
  *
- *<p>
- *Rather than simply associating the internal nodes with an hyperplane,
- *we consider <em>sub-hyperplanes</em> which correspond to the part of
- *the hyperplane that is inside the convex part defined by all the
- *parent nodes (this implies that the sub-hyperplane at root node is in
- *fact a complete hyperplane, because there is no parent to bound
- *it). Since the parts are convex, the sub-hyperplanes are convex, in
- *3D the convex parts are convex polyhedrons, and the sub-hyperplanes
- *are convex polygons that cut these polyhedrons in two
- *sub-polyhedrons. Using this definition, a BSP tree completely
- *partitions the space. Each point either belongs to one of the
- *sub-hyperplanes in an internal node or belongs to one of the leaf
- *convex parts.
- *</p>
+ * <p>
+ * Rather than simply associating the internal nodes with an hyperplane,
+ * we consider <em>sub-hyperplanes</em> which correspond to the part of
+ * the hyperplane that is inside the convex part defined by all the
+ * parent nodes (this implies that the sub-hyperplane at root node is in
+ * fact a complete hyperplane, because there is no parent to bound
+ * it). Since the parts are convex, the sub-hyperplanes are convex, in
+ * 3D the convex parts are convex polyhedrons, and the sub-hyperplanes
+ * are convex polygons that cut these polyhedrons in two
+ * sub-polyhedrons. Using this definition, a BSP tree completely
+ * partitions the space. Each point either belongs to one of the
+ * sub-hyperplanes in an internal node or belongs to one of the leaf
+ * convex parts.
+ * </p>
  *
- *<p>
- *In order to determine where a point is, it is sufficient to check its
- *position with respect to the root cut hyperplane, to select the
- *corresponding child tree and to repeat the procedure recursively,
- *until either the point appears to be exactly on one of the hyperplanes
- *in the middle of the tree or to be in one of the leaf parts. For
- *this operation, it is sufficient to consider the complete hyperplanes,
- *there is no need to check the points with the boundary of the
- *sub-hyperplanes, because this check has in fact already been realized
- *by the recursive descent in the tree. This is very easy to do and very
- *efficient, especially if the tree is well balanced (the cost is
- *<code>O(log(n))</code> where <code>n</code> is the number of facets)
- *or if the first tree levels close to the root discriminate large parts
- *of the total space.
- *</p>
+ * <p>
+ * In order to determine where a point is, it is sufficient to check its
+ * position with respect to the root cut hyperplane, to select the
+ * corresponding child tree and to repeat the procedure recursively,
+ * until either the point appears to be exactly on one of the hyperplanes
+ * in the middle of the tree or to be in one of the leaf parts. For
+ * this operation, it is sufficient to consider the complete hyperplanes,
+ * there is no need to check the points with the boundary of the
+ * sub-hyperplanes, because this check has in fact already been realized
+ * by the recursive descent in the tree. This is very easy to do and very
+ * efficient, especially if the tree is well balanced (the cost is
+ * <code>O(log(n))</code> where <code>n</code> is the number of facets)
+ * or if the first tree levels close to the root discriminate large parts
+ * of the total space.
+ * </p>
  *
- *<p>
- *One of the main sources for the development of this package was Bruce
- *Naylor, John Amanatides and William Thibault paper <a
- *href="http://www.cs.yorku.ca/~amana/research/bsptSetOp.pdf">Merging
- *BSP Trees Yields Polyhedral Set Operations</a> Proc. Siggraph '90,
- *Computer Graphics 24(4), August 1990, pp 115-124, published by the
- *Association for Computing Machinery (ACM). The same paper can also be
- *found <a
- *href="http://www.cs.utexas.edu/users/fussell/courses/cs384g/bsp_treemerge.pdf">here</a>.
- *</p>
+ * <p>
+ * One of the main sources for the development of this package was Bruce
+ * Naylor, John Amanatides and William Thibault paper <a
+ * href="http://www.cs.yorku.ca/~amana/research/bsptSetOp.pdf">Merging
+ * BSP Trees Yields Polyhedral Set Operations</a> Proc. Siggraph '90,
+ * Computer Graphics 24(4), August 1990, pp 115-124, published by the
+ * Association for Computing Machinery (ACM). The same paper can also be
+ * found <a
+ * href="http://www.cs.utexas.edu/users/fussell/courses/cs384g/bsp_treemerge.pdf">here</a>.
+ * </p>
  *
  *
  */

src/main/java/org/apache/commons/math/geometry/partitioning/utilities/package-info.java

@@ -16,9 +16,9 @@
  */
 /**
  *
- *<p>
- *This package provides multidimensional ordering features for partitioning.
- *</p>
+ * <p>
+ * This package provides multidimensional ordering features for partitioning.
+ * </p>
  *
  */
 package org.apache.commons.math.geometry.partitioning.utilities;

src/main/java/org/apache/commons/math/linear/package-info.java

@@ -15,6 +15,6 @@
  * limitations under the License.
  */
 /**
- *Linear algebra support.
+ * Linear algebra support.
  */
 package org.apache.commons.math.linear;

src/main/java/org/apache/commons/math/ode/events/package-info.java

@@ -16,38 +16,38 @@
  */
 /**
  *
- *<p>
- *This package provides classes to handle discrete events occurring during
- *Ordinary Differential Equations integration.
- *</p>
+ * <p>
+ * This package provides classes to handle discrete events occurring during
+ * Ordinary Differential Equations integration.
+ * </p>
  *
- *<p>
- *Discrete events detection is based on switching functions. The user provides
- *a simple {@link org.apache.commons.math.ode.events.EventHandler#g g(t, y)}
- *function depending on the current time and state. The integrator will monitor
- *the value of the function throughout integration range and will trigger the
- *event when its sign changes. The magnitude of the value is almost irrelevant,
- *it should however be continuous (but not necessarily smooth) for the sake of
- *root finding. The steps are shortened as needed to ensure the events occur
- *at step boundaries (even if the integrator is a fixed-step integrator).
- *</p>
+ * <p>
+ * Discrete events detection is based on switching functions. The user provides
+ * a simple {@link org.apache.commons.math.ode.events.EventHandler#g g(t, y)}
+ * function depending on the current time and state. The integrator will monitor
+ * the value of the function throughout integration range and will trigger the
+ * event when its sign changes. The magnitude of the value is almost irrelevant,
+ * it should however be continuous (but not necessarily smooth) for the sake of
+ * root finding. The steps are shortened as needed to ensure the events occur
+ * at step boundaries (even if the integrator is a fixed-step integrator).
+ * </p>
  *
- *<p>
- *When an event is triggered, several different options are available:
- *</p>
- *<ul>
+ * <p>
+ * When an event is triggered, several different options are available:
+ * </p>
+ * <ul>
  *  <li>integration can be stopped (this is called a G-stop facility),</li>
  *  <li>the state vector or the derivatives can be changed,</li>
  *  <li>or integration can simply go on.</li>
- *</ul>
+ * </ul>
  *
- *<p>
- *The first case, G-stop, is the most common one. A typical use case is when an
- *ODE must be solved up to some target state is reached, with a known value of
- *the state but an unknown occurrence time. As an example, if we want to monitor
- *a chemical reaction up to some predefined concentration for the first substance,
- *we can use the following switching function setting:
- *<pre>
+ * <p>
+ * The first case, G-stop, is the most common one. A typical use case is when an
+ * ODE must be solved up to some target state is reached, with a known value of
+ * the state but an unknown occurrence time. As an example, if we want to monitor
+ * a chemical reaction up to some predefined concentration for the first substance,
+ * we can use the following switching function setting:
+ * <pre>
  *  public double g(double t, double[] y) {
  *    return y[0] - targetConcentration;
  *  }
@@ -55,18 +55,18 @@
  *  public int eventOccurred(double t, double[] y) {
  *    return STOP;
  *  }
- *</pre>
- *</p>
+ * </pre>
+ * </p>
  *
- *<p>
- *The second case, change state vector or derivatives is encountered when dealing
- *with discontinuous dynamical models. A typical case would be the motion of a
- *spacecraft when thrusters are fired for orbital maneuvers. The acceleration is
- *smooth as long as no maneuver are performed, depending only on gravity, drag,
- *third body attraction, radiation pressure. Firing a thruster introduces a
- *discontinuity that must be handled appropriately by the integrator. In such a case,
- *we would use a switching function setting similar to this:
- *<pre>
+ * <p>
+ * The second case, change state vector or derivatives is encountered when dealing
+ * with discontinuous dynamical models. A typical case would be the motion of a
+ * spacecraft when thrusters are fired for orbital maneuvers. The acceleration is
+ * smooth as long as no maneuver are performed, depending only on gravity, drag,
+ * third body attraction, radiation pressure. Firing a thruster introduces a
+ * discontinuity that must be handled appropriately by the integrator. In such a case,
+ * we would use a switching function setting similar to this:
+ * <pre>
  *  public double g(double t, double[] y) {
  *    return (t - tManeuverStart) &lowast; (t - tManeuverStop);
  *  }
@@ -74,12 +74,12 @@
  *  public int eventOccurred(double t, double[] y) {
  *    return RESET_DERIVATIVES;
  *  }
- *</pre>
- *</p>
+ * </pre>
+ * </p>
  *
- *<p>
- *The third case is useful mainly for monitoring purposes, a simple example is:
- *<pre>
+ * <p>
+ * The third case is useful mainly for monitoring purposes, a simple example is:
+ * <pre>
  *  public double g(double t, double[] y) {
  *    return y[0] - y[1];
  *  }
@@ -88,8 +88,8 @@
  *    logger.log("y0(t) and y1(t) curves cross at t = " + t);
  *    return CONTINUE;
  *  }
- *</pre>
- *</p>
+ * </pre>
+ * </p>
  *
  *
  */

src/main/java/org/apache/commons/math/ode/nonstiff/package-info.java

@@ -16,9 +16,9 @@
  */
 /**
  *
- *<p>
- *This package provides classes to solve non-stiff Ordinary Differential Equations problems.
- *</p>
+ * <p>
+ * This package provides classes to solve non-stiff Ordinary Differential Equations problems.
+ * </p>
  *
  *
  */

src/main/java/org/apache/commons/math/ode/package-info.java

@@ -16,147 +16,147 @@
  */
 /**
  *
- *<p>
- *This package provides classes to solve Ordinary Differential Equations problems.
- *</p>
+ * <p>
+ * This package provides classes to solve Ordinary Differential Equations problems.
+ * </p>
  *
- *<p>
- *This package solves Initial Value Problems of the form
- *<code>y'=f(t,y)</code> with <code>t<sub>0</sub></code> and
- *<code>y(t<sub>0</sub>)=y<sub>0</sub></code> known. The provided
- *integrators compute an estimate of <code>y(t)</code> from
- *<code>t=t<sub>0</sub></code> to <code>t=t<sub>1</sub></code>.
- *It is also possible to get thederivatives with respect to the initial state
- *<code>dy(t)/dy(t<sub>0</sub>)</code> or the derivatives with
- *respect to some ODE parameters <code>dy(t)/dp</code>.
- *</p>
+ * <p>
+ * This package solves Initial Value Problems of the form
+ * <code>y'=f(t,y)</code> with <code>t<sub>0</sub></code> and
+ * <code>y(t<sub>0</sub>)=y<sub>0</sub></code> known. The provided
+ * integrators compute an estimate of <code>y(t)</code> from
+ * <code>t=t<sub>0</sub></code> to <code>t=t<sub>1</sub></code>.
+ * It is also possible to get thederivatives with respect to the initial state
+ * <code>dy(t)/dy(t<sub>0</sub>)</code> or the derivatives with
+ * respect to some ODE parameters <code>dy(t)/dp</code>.
+ * </p>
  *
- *<p>
- *All integrators provide dense output. This means that besides
- *computing the state vector at discrete times, they also provide a
- *cheap mean to get the state between the time steps. They do so through
- *classes extending the {@link
- *org.apache.commons.math.ode.sampling.StepInterpolator StepInterpolator}
- *abstract class, which are made available to the user at the end of
- *each step.
- *</p>
+ * <p>
+ * All integrators provide dense output. This means that besides
+ * computing the state vector at discrete times, they also provide a
+ * cheap mean to get the state between the time steps. They do so through
+ * classes extending the {@link
+ * org.apache.commons.math.ode.sampling.StepInterpolator StepInterpolator}
+ * abstract class, which are made available to the user at the end of
+ * each step.
+ * </p>
  *
- *<p>
- *All integrators handle multiple discrete events detection based on switching
- *functions. This means that the integrator can be driven by user specified
- *discrete events. The steps are shortened as needed to ensure the events occur
- *at step boundaries (even if the integrator is a fixed-step
- *integrator). When the events are triggered, integration can be stopped
- *(this is called a G-stop facility), the state vector can be changed,
- *or integration can simply go on. The latter case is useful to handle
- *discontinuities in the differential equations gracefully and get
- *accurate dense output even close to the discontinuity.
- *</p>
+ * <p>
+ * All integrators handle multiple discrete events detection based on switching
+ * functions. This means that the integrator can be driven by user specified
+ * discrete events. The steps are shortened as needed to ensure the events occur
+ * at step boundaries (even if the integrator is a fixed-step
+ * integrator). When the events are triggered, integration can be stopped
+ * (this is called a G-stop facility), the state vector can be changed,
+ * or integration can simply go on. The latter case is useful to handle
+ * discontinuities in the differential equations gracefully and get
+ * accurate dense output even close to the discontinuity.
+ * </p>
  *
- *<p>
- *The user should describe his problem in his own classes
- *(<code>UserProblem</code> in the diagram below) which should implement
- *the {@link org.apache.commons.math.ode.FirstOrderDifferentialEquations
- *FirstOrderDifferentialEquations} interface. Then he should pass it to
- *the integrator he prefers among all the classes that implement the
- *{@link org.apache.commons.math.ode.FirstOrderIntegrator
- *FirstOrderIntegrator} interface.
- *</p>
+ * <p>
+ * The user should describe his problem in his own classes
+ * (<code>UserProblem</code> in the diagram below) which should implement
+ * the {@link org.apache.commons.math.ode.FirstOrderDifferentialEquations
+ * FirstOrderDifferentialEquations} interface. Then he should pass it to
+ * the integrator he prefers among all the classes that implement the
+ * {@link org.apache.commons.math.ode.FirstOrderIntegrator
+ * FirstOrderIntegrator} interface.
+ * </p>
  *
- *<p>
- *The solution of the integration problem is provided by two means. The
- *first one is aimed towards simple use: the state vector at the end of
- *the integration process is copied in the <code>y</code> array of the
- *{@link org.apache.commons.math.ode.FirstOrderIntegrator#integrate
- *FirstOrderIntegrator.integrate} method. The second one should be used
- *when more in-depth information is needed throughout the integration
- *process. The user can register an object implementing the {@link
- *org.apache.commons.math.ode.sampling.StepHandler StepHandler} interface or a
- *{@link org.apache.commons.math.ode.sampling.StepNormalizer StepNormalizer}
- *object wrapping a user-specified object implementing the {@link
- *org.apache.commons.math.ode.sampling.FixedStepHandler FixedStepHandler}
- *interface into the integrator before calling the {@link
- *org.apache.commons.math.ode.FirstOrderIntegrator#integrate
- *FirstOrderIntegrator.integrate} method. The user object will be called
- *appropriately during the integration process, allowing the user to
- *process intermediate results. The default step handler does nothing.
- *</p>
+ * <p>
+ * The solution of the integration problem is provided by two means. The
+ * first one is aimed towards simple use: the state vector at the end of
+ * the integration process is copied in the <code>y</code> array of the
+ * {@link org.apache.commons.math.ode.FirstOrderIntegrator#integrate
+ * FirstOrderIntegrator.integrate} method. The second one should be used
+ * when more in-depth information is needed throughout the integration
+ * process. The user can register an object implementing the {@link
+ * org.apache.commons.math.ode.sampling.StepHandler StepHandler} interface or a
+ * {@link org.apache.commons.math.ode.sampling.StepNormalizer StepNormalizer}
+ * object wrapping a user-specified object implementing the {@link
+ * org.apache.commons.math.ode.sampling.FixedStepHandler FixedStepHandler}
+ * interface into the integrator before calling the {@link
+ * org.apache.commons.math.ode.FirstOrderIntegrator#integrate
+ * FirstOrderIntegrator.integrate} method. The user object will be called
+ * appropriately during the integration process, allowing the user to
+ * process intermediate results. The default step handler does nothing.
+ * </p>
  *
- *<p>
- *{@link org.apache.commons.math.ode.ContinuousOutputModel
- *ContinuousOutputModel} is a special-purpose step handler that is able
- *to store all steps and to provide transparent access to any
- *intermediate result once the integration is over. An important feature
- *of this class is that it implements the <code>Serializable</code>
- *interface. This means that a complete continuous model of the
- *integrated function throughout the integration range can be serialized
- *and reused later (if stored into a persistent medium like a filesystem
- *or a database) or elsewhere (if sent to another application). Only the
- *result of the integration is stored, there is no reference to the
- *integrated problem by itself.
- *</p>
+ * <p>
+ * {@link org.apache.commons.math.ode.ContinuousOutputModel
+ * ContinuousOutputModel} is a special-purpose step handler that is able
+ * to store all steps and to provide transparent access to any
+ * intermediate result once the integration is over. An important feature
+ * of this class is that it implements the <code>Serializable</code>
+ * interface. This means that a complete continuous model of the
+ * integrated function throughout the integration range can be serialized
+ * and reused later (if stored into a persistent medium like a filesystem
+ * or a database) or elsewhere (if sent to another application). Only the
+ * result of the integration is stored, there is no reference to the
+ * integrated problem by itself.
+ * </p>
  *
- *<p>
- *Other default implementations of the {@link
- *org.apache.commons.math.ode.sampling.StepHandler StepHandler} interface are
- *available for general needs ({@link
- *org.apache.commons.math.ode.sampling.DummyStepHandler DummyStepHandler}, {@link
- *org.apache.commons.math.ode.sampling.StepNormalizer StepNormalizer}) and custom
- *implementations can be developed for specific needs. As an example,
- *if an application is to be completely driven by the integration
- *process, then most of the application code will be run inside a step
- *handler specific to this application.
- *</p>
+ * <p>
+ * Other default implementations of the {@link
+ * org.apache.commons.math.ode.sampling.StepHandler StepHandler} interface are
+ * available for general needs ({@link
+ * org.apache.commons.math.ode.sampling.DummyStepHandler DummyStepHandler}, {@link
+ * org.apache.commons.math.ode.sampling.StepNormalizer StepNormalizer}) and custom
+ * implementations can be developed for specific needs. As an example,
+ * if an application is to be completely driven by the integration
+ * process, then most of the application code will be run inside a step
+ * handler specific to this application.
+ * </p>
  *
- *<p>
- *Some integrators (the simple ones) use fixed steps that are set at
- *creation time. The more efficient integrators use variable steps that
- *are handled internally in order to control the integration error with
- *respect to a specified accuracy (these integrators extend the {@link
- *org.apache.commons.math.ode.nonstiff.AdaptiveStepsizeIntegrator
- *AdaptiveStepsizeIntegrator} abstract class). In this case, the step
- *handler which is called after each successful step shows up the
- *variable stepsize. The {@link
- *org.apache.commons.math.ode.sampling.StepNormalizer StepNormalizer} class can
- *be used to convert the variable stepsize into a fixed stepsize that
- *can be handled by classes implementing the {@link
- *org.apache.commons.math.ode.sampling.FixedStepHandler FixedStepHandler}
- *interface. Adaptive stepsize integrators can automatically compute the
- *initial stepsize by themselves, however the user can specify it if he
- *prefers to retain full control over the integration or if the
- *automatic guess is wrong.
- *</p>
+ * <p>
+ * Some integrators (the simple ones) use fixed steps that are set at
+ * creation time. The more efficient integrators use variable steps that
+ * are handled internally in order to control the integration error with
+ * respect to a specified accuracy (these integrators extend the {@link
+ * org.apache.commons.math.ode.nonstiff.AdaptiveStepsizeIntegrator
+ * AdaptiveStepsizeIntegrator} abstract class). In this case, the step
+ * handler which is called after each successful step shows up the
+ * variable stepsize. The {@link
+ * org.apache.commons.math.ode.sampling.StepNormalizer StepNormalizer} class can
+ * be used to convert the variable stepsize into a fixed stepsize that
+ * can be handled by classes implementing the {@link
+ * org.apache.commons.math.ode.sampling.FixedStepHandler FixedStepHandler}
+ * interface. Adaptive stepsize integrators can automatically compute the
+ * initial stepsize by themselves, however the user can specify it if he
+ * prefers to retain full control over the integration or if the
+ * automatic guess is wrong.
+ * </p>
  *
- *<p>
- *<table border="1" align="center">
- *<tr BGCOLOR="#CCCCFF"><td colspan=2><font size="+2">Fixed Step Integrators</font></td></tr>
- *<tr BGCOLOR="#EEEEFF"><font size="+1"><td>Name</td><td>Order</td></font></tr>
- *<tr><td>{@link org.apache.commons.math.ode.nonstiff.EulerIntegrator Euler}</td><td>1</td></tr>
- *<tr><td>{@link org.apache.commons.math.ode.nonstiff.MidpointIntegrator Midpoint}</td><td>2</td></tr>
- *<tr><td>{@link org.apache.commons.math.ode.nonstiff.ClassicalRungeKuttaIntegrator Classical Runge-Kutta}</td><td>4</td></tr>
- *<tr><td>{@link org.apache.commons.math.ode.nonstiff.GillIntegrator Gill}</td><td>4</td></tr>
- *<tr><td>{@link org.apache.commons.math.ode.nonstiff.ThreeEighthesIntegrator 3/8}</td><td>4</td></tr>
- *</table>
- *</p>
+ * <p>
+ * <table border="1" align="center">
+ * <tr BGCOLOR="#CCCCFF"><td colspan=2><font size="+2">Fixed Step Integrators</font></td></tr>
+ * <tr BGCOLOR="#EEEEFF"><font size="+1"><td>Name</td><td>Order</td></font></tr>
+ * <tr><td>{@link org.apache.commons.math.ode.nonstiff.EulerIntegrator Euler}</td><td>1</td></tr>
+ * <tr><td>{@link org.apache.commons.math.ode.nonstiff.MidpointIntegrator Midpoint}</td><td>2</td></tr>
+ * <tr><td>{@link org.apache.commons.math.ode.nonstiff.ClassicalRungeKuttaIntegrator Classical Runge-Kutta}</td><td>4</td></tr>
+ * <tr><td>{@link org.apache.commons.math.ode.nonstiff.GillIntegrator Gill}</td><td>4</td></tr>
+ * <tr><td>{@link org.apache.commons.math.ode.nonstiff.ThreeEighthesIntegrator 3/8}</td><td>4</td></tr>
+ * </table>
+ * </p>
  *
- *<table border="1" align="center">
- *<tr BGCOLOR="#CCCCFF"><td colspan=3><font size="+2">Adaptive Stepsize Integrators</font></td></tr>
- *<tr BGCOLOR="#EEEEFF"><font size="+1"><td>Name</td><td>Integration Order</td><td>Error Estimation Order</td></font></tr>
- *<tr><td>{@link org.apache.commons.math.ode.nonstiff.HighamHall54Integrator Higham and Hall}</td><td>5</td><td>4</td></tr>
- *<tr><td>{@link org.apache.commons.math.ode.nonstiff.DormandPrince54Integrator Dormand-Prince 5(4)}</td><td>5</td><td>4</td></tr>
- *<tr><td>{@link org.apache.commons.math.ode.nonstiff.DormandPrince853Integrator Dormand-Prince 8(5,3)}</td><td>8</td><td>5 and 3</td></tr>
- *<tr><td>{@link org.apache.commons.math.ode.nonstiff.GraggBulirschStoerIntegrator Gragg-Bulirsch-Stoer}</td><td>variable (up to 18 by default)</td><td>variable</td></tr>
- *<tr><td>{@link org.apache.commons.math.ode.nonstiff.AdamsBashforthIntegrator Adams-Bashforth}</td><td>variable</td><td>variable</td></tr>
- *<tr><td>{@link org.apache.commons.math.ode.nonstiff.AdamsMoultonIntegrator Adams-Moulton}</td><td>variable</td><td>variable</td></tr>
- *</table>
- *</p>
+ * <table border="1" align="center">
+ * <tr BGCOLOR="#CCCCFF"><td colspan=3><font size="+2">Adaptive Stepsize Integrators</font></td></tr>
+ * <tr BGCOLOR="#EEEEFF"><font size="+1"><td>Name</td><td>Integration Order</td><td>Error Estimation Order</td></font></tr>
+ * <tr><td>{@link org.apache.commons.math.ode.nonstiff.HighamHall54Integrator Higham and Hall}</td><td>5</td><td>4</td></tr>
+ * <tr><td>{@link org.apache.commons.math.ode.nonstiff.DormandPrince54Integrator Dormand-Prince 5(4)}</td><td>5</td><td>4</td></tr>
+ * <tr><td>{@link org.apache.commons.math.ode.nonstiff.DormandPrince853Integrator Dormand-Prince 8(5,3)}</td><td>8</td><td>5 and 3</td></tr>
+ * <tr><td>{@link org.apache.commons.math.ode.nonstiff.GraggBulirschStoerIntegrator Gragg-Bulirsch-Stoer}</td><td>variable (up to 18 by default)</td><td>variable</td></tr>
+ * <tr><td>{@link org.apache.commons.math.ode.nonstiff.AdamsBashforthIntegrator Adams-Bashforth}</td><td>variable</td><td>variable</td></tr>
+ * <tr><td>{@link org.apache.commons.math.ode.nonstiff.AdamsMoultonIntegrator Adams-Moulton}</td><td>variable</td><td>variable</td></tr>
+ * </table>
+ * </p>
  *
- *<p>
- *In the table above, the {@link org.apache.commons.math.ode.nonstiff.AdamsBashforthIntegrator
- *Adams-Bashforth} and {@link org.apache.commons.math.ode.nonstiff.AdamsMoultonIntegrator
- *Adams-Moulton} integrators appear as variable-step ones. This is an experimental extension
- *to the classical algorithms using the Nordsieck vector representation.
- *</p>
+ * <p>
+ * In the table above, the {@link org.apache.commons.math.ode.nonstiff.AdamsBashforthIntegrator
+ * Adams-Bashforth} and {@link org.apache.commons.math.ode.nonstiff.AdamsMoultonIntegrator
+ * Adams-Moulton} integrators appear as variable-step ones. This is an experimental extension
+ * to the classical algorithms using the Nordsieck vector representation.
+ * </p>
  *
  *
  */

src/main/java/org/apache/commons/math/ode/sampling/package-info.java

@@ -16,44 +16,44 @@
  */
 /**
  *
- *<p>
- *This package provides classes to handle sampling steps during
- *Ordinary Differential Equations integration.
- *</p>
+ * <p>
+ * This package provides classes to handle sampling steps during
+ * Ordinary Differential Equations integration.
+ * </p>
  *
- *<p>
- *In addition to computing the evolution of the state vector at some grid points, all
- *ODE integrators also build up interpolation models of this evolution <em>inside</em> the
- *last computed step. If users are interested in these interpolators, they can register a
- *{@link org.apache.commons.math.ode.sampling.StepHandler StepHandler} instance using the
- *{@link org.apache.commons.math.ode.FirstOrderIntegrator#addStepHandler addStepHandler}
- *method which is supported by all integrators. The integrator will call this instance
- *at the end of each accepted step and provide it the interpolator. The user can do
- *whatever he wants with this interpolator, which computes both the state and its
- *time-derivative. A typical use of step handler is to provide some output to monitor
- *the integration process.
- *</p>
+ * <p>
+ * In addition to computing the evolution of the state vector at some grid points, all
+ * ODE integrators also build up interpolation models of this evolution <em>inside</em> the
+ * last computed step. If users are interested in these interpolators, they can register a
+ * {@link org.apache.commons.math.ode.sampling.StepHandler StepHandler} instance using the
+ * {@link org.apache.commons.math.ode.FirstOrderIntegrator#addStepHandler addStepHandler}
+ * method which is supported by all integrators. The integrator will call this instance
+ * at the end of each accepted step and provide it the interpolator. The user can do
+ * whatever he wants with this interpolator, which computes both the state and its
+ * time-derivative. A typical use of step handler is to provide some output to monitor
+ * the integration process.
+ * </p>
  *
- *<p>
- *In a sense, this is a kind of Inversion Of Control: rather than having the master
- *application driving the slave integrator by providing the target end value for
- *the free variable, we get a master integrator scheduling the free variable
- *evolution and calling the slave application callbacks that were registered at
- *configuration time.
- *</p>
+ * <p>
+ * In a sense, this is a kind of Inversion Of Control: rather than having the master
+ * application driving the slave integrator by providing the target end value for
+ * the free variable, we get a master integrator scheduling the free variable
+ * evolution and calling the slave application callbacks that were registered at
+ * configuration time.
+ * </p>
  *
- *<p>
- *Since some integrators may use variable step size, the generic {@link
- *org.apache.commons.math.ode.sampling.StepHandler StepHandler} interface can be called
- *either at regular or irregular rate. This interface allows to navigate to any location
- *within the last computed step, thanks to the provided {@link
- *org.apache.commons.math.ode.sampling.StepInterpolator StepInterpolator} object.
- *If regular output is desired (for example in order to write an ephemeris file), then
- *the simpler {@link org.apache.commons.math.ode.sampling.FixedStepHandler FixedStepHandler}
- *interface can be used. Objects implementing this interface should be wrapped within a
- *{@link org.apache.commons.math.ode.sampling.StepNormalizer StepNormalizer} instance
- *in order to be registered to the integrator.
- *</p>
+ * <p>
+ * Since some integrators may use variable step size, the generic {@link
+ * org.apache.commons.math.ode.sampling.StepHandler StepHandler} interface can be called
+ * either at regular or irregular rate. This interface allows to navigate to any location
+ * within the last computed step, thanks to the provided {@link
+ * org.apache.commons.math.ode.sampling.StepInterpolator StepInterpolator} object.
+ * If regular output is desired (for example in order to write an ephemeris file), then
+ * the simpler {@link org.apache.commons.math.ode.sampling.FixedStepHandler FixedStepHandler}
+ * interface can be used. Objects implementing this interface should be wrapped within a
+ * {@link org.apache.commons.math.ode.sampling.StepNormalizer StepNormalizer} instance
+ * in order to be registered to the integrator.
+ * </p>
  *
  *
  */

src/main/java/org/apache/commons/math/optimization/direct/package-info.java

@@ -16,9 +16,9 @@
  */
 /**
  *
- *<p>
- *This package provides optimization algorithms that don't require derivatives.
- *</p>
+ * <p>
+ * This package provides optimization algorithms that don't require derivatives.
+ * </p>
  *
  */
 package org.apache.commons.math.optimization.direct;

src/main/java/org/apache/commons/math/optimization/fitting/package-info.java

@@ -16,14 +16,14 @@
  */
 /**
  *
- *This package provides classes to perform curve fitting.
+ * This package provides classes to perform curve fitting.
  *
- *<p>Curve fitting is a special case of a least squares problem
- *were the parameters are the coefficients of a function <code>f</code>
- *whose graph <code>y=f(x)</code> should pass through sample points, and
- *were the objective function is the squared sum of residuals
- *<code>f(x<sub>i</sub>)-y<sub>i</sub></code> for observed points
- *(x<sub>i</sub>, y<sub>i</sub>).</p>
+ * <p>Curve fitting is a special case of a least squares problem
+ * were the parameters are the coefficients of a function <code>f</code>
+ * whose graph <code>y=f(x)</code> should pass through sample points, and
+ * were the objective function is the squared sum of residuals
+ * <code>f(x<sub>i</sub>)-y<sub>i</sub></code> for observed points
+ * (x<sub>i</sub>, y<sub>i</sub>).</p>
  *
  *
  */

src/main/java/org/apache/commons/math/optimization/general/package-info.java

@@ -16,7 +16,7 @@
  */
 /**
  *
- *This package provides optimization algorithms that require derivatives.
+ * This package provides optimization algorithms that require derivatives.
  *
  */
 package org.apache.commons.math.optimization.general;

src/main/java/org/apache/commons/math/optimization/linear/package-info.java

@@ -16,7 +16,7 @@
  */
 /**
  *
- *This package provides optimization algorithms for linear constrained problems.
+ * This package provides optimization algorithms for linear constrained problems.
  *
  */
 package org.apache.commons.math.optimization.linear;

src/main/java/org/apache/commons/math/optimization/package-info.java

@@ -16,22 +16,22 @@
  */
 /**
  *
- *<p>
- *This package provides common interfaces for the optimization algorithms
- *provided in sub-packages. The main interfaces defines optimizers and convergence
- *checkers. The functions that are optimized by the algorithms provided by this
- *package and its sub-packages are a subset of the one defined in the <code>analysis</code>
- *package, namely the real and vector valued functions. These functions are called
- *objective function here. When the goal is to minimize, the functions are often called
- *cost function, this name is not used in this package.
- *</p>
+ * <p>
+ * This package provides common interfaces for the optimization algorithms
+ * provided in sub-packages. The main interfaces defines optimizers and convergence
+ * checkers. The functions that are optimized by the algorithms provided by this
+ * package and its sub-packages are a subset of the one defined in the <code>analysis</code>
+ * package, namely the real and vector valued functions. These functions are called
+ * objective function here. When the goal is to minimize, the functions are often called
+ * cost function, this name is not used in this package.
+ * </p>
  *
- *<p>
- *Optimizers are the algorithms that will either minimize or maximize, the objective function
- *by changing its input variables set until an optimal set is found. There are only four
- *interfaces defining the common behavior of optimizers, one for each supported type of objective
- *function:
- *<ul>
+ * <p>
+ * Optimizers are the algorithms that will either minimize or maximize, the objective function
+ * by changing its input variables set until an optimal set is found. There are only four
+ * interfaces defining the common behavior of optimizers, one for each supported type of objective
+ * function:
+ * <ul>
  *  <li>{@link org.apache.commons.math.optimization.univariate.UnivariateRealOptimizer
  *      UnivariateRealOptimizer} for {@link org.apache.commons.math.analysis.UnivariateRealFunction
  *      univariate real functions}</li>
@@ -46,27 +46,27 @@
  *      DifferentiableMultivariateVectorialOptimizer} for {@link
  *      org.apache.commons.math.analysis.DifferentiableMultivariateVectorialFunction
  *      differentiable multivariate vectorial functions}</li>
- *</ul>
- *</p>
+ * </ul>
+ * </p>
  *
- *<p>
- *Despite there are only four types of supported optimizers, it is possible to optimize a
- *transform a {@link org.apache.commons.math.analysis.MultivariateVectorialFunction
- *non-differentiable multivariate vectorial function} by converting it to a {@link
- *org.apache.commons.math.analysis.MultivariateRealFunction non-differentiable multivariate
- *real function} thanks to the {@link
- *org.apache.commons.math.optimization.LeastSquaresConverter LeastSquaresConverter} helper class.
- *The transformed function can be optimized using any implementation of the {@link
- *org.apache.commons.math.optimization.MultivariateRealOptimizer MultivariateRealOptimizer} interface.
- *</p>
+ * <p>
+ * Despite there are only four types of supported optimizers, it is possible to optimize a
+ * transform a {@link org.apache.commons.math.analysis.MultivariateVectorialFunction
+ * non-differentiable multivariate vectorial function} by converting it to a {@link
+ * org.apache.commons.math.analysis.MultivariateRealFunction non-differentiable multivariate
+ * real function} thanks to the {@link
+ * org.apache.commons.math.optimization.LeastSquaresConverter LeastSquaresConverter} helper class.
+ * The transformed function can be optimized using any implementation of the {@link
+ * org.apache.commons.math.optimization.MultivariateRealOptimizer MultivariateRealOptimizer} interface.
+ * </p>
  *
- *<p>
- *For each of the four types of supported optimizers, there is a special implementation which
- *wraps a classical optimizer in order to add it a multi-start feature. This feature call the
- *underlying optimizer several times in sequence with different starting points and returns
- *the best optimum found or all optima if desired. This is a classical way to prevent being
- *trapped into a local extremum when looking for a global one.
- *</p>
+ * <p>
+ * For each of the four types of supported optimizers, there is a special implementation which
+ * wraps a classical optimizer in order to add it a multi-start feature. This feature call the
+ * underlying optimizer several times in sequence with different starting points and returns
+ * the best optimum found or all optima if desired. This is a classical way to prevent being
+ * trapped into a local extremum when looking for a global one.
+ * </p>
  *
  */
 package org.apache.commons.math.optimization;

src/main/java/org/apache/commons/math/optimization/univariate/package-info.java

@@ -17,6 +17,6 @@
 /**
  *
  *     Univariate real functions minimum finding algorithms.
- *    
+ *
  */
 package org.apache.commons.math.optimization.univariate;

src/main/java/org/apache/commons/math/package-info.java

@@ -15,6 +15,6 @@
  * limitations under the License.
  */
 /**
- *Common classes used throughout the commons-math library.
+ * Common classes used throughout the commons-math library.
  */
 package org.apache.commons.math;

src/main/java/org/apache/commons/math/random/package-info.java

@@ -127,6 +127,6 @@
  *      very strong properties of unpredictability as needed in cryptography.
  *      </p>
  *
- *    
+ *
  */
 package org.apache.commons.math.random;

src/main/java/org/apache/commons/math/special/package-info.java

@@ -15,6 +15,6 @@
  * limitations under the License.
  */
 /**
- *Implementations of special functions such as Beta and Gamma.
+ * Implementations of special functions such as Beta and Gamma.
  */
 package org.apache.commons.math.special;

src/main/java/org/apache/commons/math/stat/clustering/package-info.java

@@ -15,6 +15,6 @@
  * limitations under the License.
  */
 /**
- *Clustering algorithms
+ * Clustering algorithms
  */
 package org.apache.commons.math.stat.clustering;

src/main/java/org/apache/commons/math/stat/correlation/package-info.java

@@ -17,6 +17,6 @@
 /**
  *
  *        Correlations/Covariance computations.
- *    
+ *
  */
 package org.apache.commons.math.stat.correlation;

src/main/java/org/apache/commons/math/stat/descriptive/moment/package-info.java

@@ -15,6 +15,6 @@
  * limitations under the License.
  */
 /**
- *Summary statistics based on moments.
+ * Summary statistics based on moments.
  */
 package org.apache.commons.math.stat.descriptive.moment;

src/main/java/org/apache/commons/math/stat/descriptive/package-info.java

@@ -39,6 +39,6 @@
  *          <span style="font-weight: bold;"> stat.clear();</span><br/>
  *          System.out.println("mean after clear is NaN = " + <span style="font-weight: bold;">stat.getResult()</span>);
  *        </code>
- *    
+ *
  */
 package org.apache.commons.math.stat.descriptive;

src/main/java/org/apache/commons/math/stat/descriptive/rank/package-info.java

@@ -15,6 +15,6 @@
  * limitations under the License.
  */
 /**
- *Summary statistics based on ranks.
+ * Summary statistics based on ranks.
  */
 package org.apache.commons.math.stat.descriptive.rank;

src/main/java/org/apache/commons/math/stat/descriptive/summary/package-info.java

@@ -15,6 +15,6 @@
  * limitations under the License.
  */
 /**
- *Other summary statistics.
+ * Other summary statistics.
  */
 package org.apache.commons.math.stat.descriptive.summary;

src/main/java/org/apache/commons/math/stat/inference/package-info.java

@@ -18,6 +18,6 @@
  *
  *      Classes providing hypothesis testing and confidence interval
  *      construction.
- *    
+ *
  */
 package org.apache.commons.math.stat.inference;

src/main/java/org/apache/commons/math/stat/package-info.java

@@ -15,6 +15,6 @@
  * limitations under the License.
  */
 /**
- *Data storage, manipulation and summary routines.
+ * Data storage, manipulation and summary routines.
  */
 package org.apache.commons.math.stat;

src/main/java/org/apache/commons/math/stat/ranking/package-info.java

@@ -17,6 +17,6 @@
 /**
  *
  *      Classes providing rank transformations.
- *    
+ *
  */
 package org.apache.commons.math.stat.ranking;

src/main/java/org/apache/commons/math/stat/regression/package-info.java

@@ -17,6 +17,6 @@
 /**
  *
  *      Statistical routines involving multivariate data.
- *    
+ *
  */
 package org.apache.commons.math.stat.regression;

src/main/java/org/apache/commons/math/transform/package-info.java

@@ -17,6 +17,6 @@
 /**
  *
  *     Implementations of transform methods, including Fast Fourier transforms.
- *    
+ *
  */
 package org.apache.commons.math.transform;

src/main/java/org/apache/commons/math/util/package-info.java

@@ -15,6 +15,6 @@
  * limitations under the License.
  */
 /**
- *Convenience routines and common data structures used throughout the commons-math library.
+ * Convenience routines and common data structures used throughout the commons-math library.
  */
 package org.apache.commons.math.util;