From 121638c7c2d2654121304529596fffb8845c5734 Mon Sep 17 00:00:00 2001 From: Luc Maisonobe Date: Sun, 2 Oct 2011 09:25:27 +0000 Subject: [PATCH] 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 --- .../math/analysis/function/package-info.java | 2 +- .../analysis/integration/package-info.java | 2 +- .../analysis/interpolation/package-info.java | 2 +- .../commons/math/analysis/package-info.java | 2 +- .../analysis/polynomials/package-info.java | 2 +- .../math/analysis/solvers/package-info.java | 2 +- .../commons/math/complex/package-info.java | 2 +- .../apache/commons/math/dfp/package-info.java | 90 +++--- .../math/distribution/package-info.java | 2 +- .../commons/math/exception/package-info.java | 2 +- .../math/exception/util/package-info.java | 2 +- .../commons/math/filter/package-info.java | 2 +- .../commons/math/fraction/package-info.java | 2 +- .../commons/math/genetics/package-info.java | 6 +- .../geometry/euclidean/oned/package-info.java | 6 +- .../euclidean/threed/package-info.java | 6 +- .../geometry/euclidean/twod/package-info.java | 6 +- .../commons/math/geometry/package-info.java | 8 +- .../geometry/partitioning/package-info.java | 160 +++++------ .../partitioning/utilities/package-info.java | 6 +- .../commons/math/linear/package-info.java | 2 +- .../commons/math/ode/events/package-info.java | 88 +++--- .../math/ode/nonstiff/package-info.java | 6 +- .../apache/commons/math/ode/package-info.java | 260 +++++++++--------- .../math/ode/sampling/package-info.java | 70 ++--- .../optimization/direct/package-info.java | 6 +- .../optimization/fitting/package-info.java | 14 +- .../optimization/general/package-info.java | 2 +- .../optimization/linear/package-info.java | 2 +- .../math/optimization/package-info.java | 68 ++--- .../optimization/univariate/package-info.java | 2 +- .../org/apache/commons/math/package-info.java | 2 +- .../commons/math/random/package-info.java | 2 +- .../commons/math/special/package-info.java | 2 +- .../math/stat/clustering/package-info.java | 2 +- .../math/stat/correlation/package-info.java | 2 +- .../stat/descriptive/moment/package-info.java | 2 +- .../math/stat/descriptive/package-info.java | 2 +- .../stat/descriptive/rank/package-info.java | 2 +- .../descriptive/summary/package-info.java | 2 +- .../math/stat/inference/package-info.java | 2 +- .../commons/math/stat/package-info.java | 2 +- .../math/stat/ranking/package-info.java | 2 +- .../math/stat/regression/package-info.java | 2 +- .../commons/math/transform/package-info.java | 2 +- .../commons/math/util/package-info.java | 2 +- 46 files changed, 431 insertions(+), 431 deletions(-) diff --git a/src/main/java/org/apache/commons/math/analysis/function/package-info.java b/src/main/java/org/apache/commons/math/analysis/function/package-info.java index 05213a508..148939c4a 100644 --- a/src/main/java/org/apache/commons/math/analysis/function/package-info.java +++ b/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. *

- * + * */ package org.apache.commons.math.analysis.function; diff --git a/src/main/java/org/apache/commons/math/analysis/integration/package-info.java b/src/main/java/org/apache/commons/math/analysis/integration/package-info.java index f46c3c404..a2d2d94b0 100644 --- a/src/main/java/org/apache/commons/math/analysis/integration/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/analysis/interpolation/package-info.java b/src/main/java/org/apache/commons/math/analysis/interpolation/package-info.java index 9cac37486..d0d5d409a 100644 --- a/src/main/java/org/apache/commons/math/analysis/interpolation/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/analysis/package-info.java b/src/main/java/org/apache/commons/math/analysis/package-info.java index 43944f601..259c7ee6c 100644 --- a/src/main/java/org/apache/commons/math/analysis/package-info.java +++ b/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. *

- * + * */ package org.apache.commons.math.analysis; diff --git a/src/main/java/org/apache/commons/math/analysis/polynomials/package-info.java b/src/main/java/org/apache/commons/math/analysis/polynomials/package-info.java index b492f5420..cb7801f28 100644 --- a/src/main/java/org/apache/commons/math/analysis/polynomials/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/analysis/solvers/package-info.java b/src/main/java/org/apache/commons/math/analysis/solvers/package-info.java index ba715e3c8..09845f361 100644 --- a/src/main/java/org/apache/commons/math/analysis/solvers/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/complex/package-info.java b/src/main/java/org/apache/commons/math/complex/package-info.java index c067c57ba..9c5d74f2b 100644 --- a/src/main/java/org/apache/commons/math/complex/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/dfp/package-info.java b/src/main/java/org/apache/commons/math/dfp/package-info.java index fcaecb6ee..45d69605c 100644 --- a/src/main/java/org/apache/commons/math/dfp/package-info.java +++ b/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 * - *

Another floating point class. This one is built using radix 10000 - *which is 104, so its almost decimal.

+ *

Another floating point class. This one is built using radix 10000 + * which is 104, so its almost decimal.

* - *

The design goals here are: - *

    + *

    The design goals here are: + *

      *
    1. Decimal math, or close to it
      2. *
    2. Settable precision (but no mix between numbers using different settings)
      3. *
    3. Portability. Code should be keep as portable as possible.
      4. @@ -31,58 +31,58 @@ * algebraic operation *
    4. Comply with IEEE 854-1987 as much as possible. * (See IEEE 854-1987 notes below)
      5. - *

    + *

* - *

Trade offs: - *

    + *

    Trade offs: + *

      *
    1. Memory foot print. I'm using more memory than necessary to * represent numbers to get better performance.
      2. *
    2. 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.
      3. - *

    + *

* - *

Numbers are represented in the following form: - *

- *n  =  sign × mant × (radix)exp;

- *
- *where sign is ±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

+ *

Numbers are represented in the following form: + * 

+ * n  =  sign × mant × (radix)exp;

+ *
+ * where sign is ±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

* - *

IEEE 854-1987 Notes and differences

+ *

IEEE 854-1987 Notes and differences

* - *

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.

+ *

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.

* - *

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.

+ *

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.

* - *

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.

+ *

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.

* - *

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)∗4), eg, for digits=5, MIN_EXP=-32767, that would - *be 1e-131092.

+ *

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)∗4), eg, for digits=5, MIN_EXP=-32767, that would + * be 1e-131092.

+ * + *

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.

* - *

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.

- * */ package org.apache.commons.math.dfp; diff --git a/src/main/java/org/apache/commons/math/distribution/package-info.java b/src/main/java/org/apache/commons/math/distribution/package-info.java index 840fe113f..e26ba37a5 100644 --- a/src/main/java/org/apache/commons/math/distribution/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/exception/package-info.java b/src/main/java/org/apache/commons/math/exception/package-info.java index b73b3be82..e42b8fe82 100644 --- a/src/main/java/org/apache/commons/math/exception/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/exception/util/package-info.java b/src/main/java/org/apache/commons/math/exception/util/package-info.java index f877675e3..871bef298 100644 --- a/src/main/java/org/apache/commons/math/exception/util/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/filter/package-info.java b/src/main/java/org/apache/commons/math/filter/package-info.java index d4225729a..0c7fa6625 100644 --- a/src/main/java/org/apache/commons/math/filter/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/fraction/package-info.java b/src/main/java/org/apache/commons/math/fraction/package-info.java index e6187ce90..59c86fac0 100644 --- a/src/main/java/org/apache/commons/math/fraction/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/genetics/package-info.java b/src/main/java/org/apache/commons/math/genetics/package-info.java index ff635e6b2..affd773aa 100644 --- a/src/main/java/org/apache/commons/math/genetics/package-info.java +++ b/src/main/java/org/apache/commons/math/genetics/package-info.java @@ -16,9 +16,9 @@ */ /** * - *

- *This package provides Genetic Algorithms components and implementations. - *

+ *

+ * This package provides Genetic Algorithms components and implementations. + *

* */ package org.apache.commons.math.genetics; diff --git a/src/main/java/org/apache/commons/math/geometry/euclidean/oned/package-info.java b/src/main/java/org/apache/commons/math/geometry/euclidean/oned/package-info.java index 47a60d6b4..83ccf22f5 100644 --- a/src/main/java/org/apache/commons/math/geometry/euclidean/oned/package-info.java +++ b/src/main/java/org/apache/commons/math/geometry/euclidean/oned/package-info.java @@ -16,9 +16,9 @@ */ /** * - *

- *This package provides basic 1D geometry components. - *

+ *

+ * This package provides basic 1D geometry components. + *

* */ package org.apache.commons.math.geometry.euclidean.oned; diff --git a/src/main/java/org/apache/commons/math/geometry/euclidean/threed/package-info.java b/src/main/java/org/apache/commons/math/geometry/euclidean/threed/package-info.java index 0d81814b6..5537b96cf 100644 --- a/src/main/java/org/apache/commons/math/geometry/euclidean/threed/package-info.java +++ b/src/main/java/org/apache/commons/math/geometry/euclidean/threed/package-info.java @@ -16,9 +16,9 @@ */ /** * - *

- *This package provides basic 3D geometry components. - *

+ *

+ * This package provides basic 3D geometry components. + *

* */ package org.apache.commons.math.geometry.euclidean.threed; diff --git a/src/main/java/org/apache/commons/math/geometry/euclidean/twod/package-info.java b/src/main/java/org/apache/commons/math/geometry/euclidean/twod/package-info.java index e26e6cc49..13aaf016c 100644 --- a/src/main/java/org/apache/commons/math/geometry/euclidean/twod/package-info.java +++ b/src/main/java/org/apache/commons/math/geometry/euclidean/twod/package-info.java @@ -16,9 +16,9 @@ */ /** * - *

- *This package provides basic 2D geometry components. - *

+ *

+ * This package provides basic 2D geometry components. + *

* */ package org.apache.commons.math.geometry.euclidean.twod; diff --git a/src/main/java/org/apache/commons/math/geometry/package-info.java b/src/main/java/org/apache/commons/math/geometry/package-info.java index 40ef6d4b5..97c179226 100644 --- a/src/main/java/org/apache/commons/math/geometry/package-info.java +++ b/src/main/java/org/apache/commons/math/geometry/package-info.java @@ -16,10 +16,10 @@ */ /** * - *

- *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. - *

+ *

+ * 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. + *

* */ package org.apache.commons.math.geometry; diff --git a/src/main/java/org/apache/commons/math/geometry/partitioning/package-info.java b/src/main/java/org/apache/commons/math/geometry/partitioning/package-info.java index 17f90cdb1..f4e4bd94d 100644 --- a/src/main/java/org/apache/commons/math/geometry/partitioning/package-info.java +++ b/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. * - *

- *{@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). - *

+ *

+ * {@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). + *

* - *

- *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. - *

+ *

+ * 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. + *

* - *

- *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 not 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). - *

+ *

+ * 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 not 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). + *

* - *

- *Rather than simply associating the internal nodes with an hyperplane, - *we consider sub-hyperplanes 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. - *

+ *

+ * Rather than simply associating the internal nodes with an hyperplane, + * we consider sub-hyperplanes 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. + *

* - *

- *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 - *O(log(n)) where n is the number of facets) - *or if the first tree levels close to the root discriminate large parts - *of the total space. - *

+ *

+ * 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 + * O(log(n)) where n is the number of facets) + * or if the first tree levels close to the root discriminate large parts + * of the total space. + *

* - *

- *One of the main sources for the development of this package was Bruce - *Naylor, John Amanatides and William Thibault paper Merging - *BSP Trees Yields Polyhedral Set Operations 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 here. - *

+ *

+ * One of the main sources for the development of this package was Bruce + * Naylor, John Amanatides and William Thibault paper Merging + * BSP Trees Yields Polyhedral Set Operations 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 here. + *

* * */ diff --git a/src/main/java/org/apache/commons/math/geometry/partitioning/utilities/package-info.java b/src/main/java/org/apache/commons/math/geometry/partitioning/utilities/package-info.java index 85debb647..01f655850 100644 --- a/src/main/java/org/apache/commons/math/geometry/partitioning/utilities/package-info.java +++ b/src/main/java/org/apache/commons/math/geometry/partitioning/utilities/package-info.java @@ -16,9 +16,9 @@ */ /** * - *

- *This package provides multidimensional ordering features for partitioning. - *

+ *

+ * This package provides multidimensional ordering features for partitioning. + *

* */ package org.apache.commons.math.geometry.partitioning.utilities; diff --git a/src/main/java/org/apache/commons/math/linear/package-info.java b/src/main/java/org/apache/commons/math/linear/package-info.java index ac1630ac3..4250cc372 100644 --- a/src/main/java/org/apache/commons/math/linear/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/ode/events/package-info.java b/src/main/java/org/apache/commons/math/ode/events/package-info.java index 1c06625c8..0dcce4ffd 100644 --- a/src/main/java/org/apache/commons/math/ode/events/package-info.java +++ b/src/main/java/org/apache/commons/math/ode/events/package-info.java @@ -16,38 +16,38 @@ */ /** * - *

- *This package provides classes to handle discrete events occurring during - *Ordinary Differential Equations integration. - *

+ *

+ * This package provides classes to handle discrete events occurring during + * Ordinary Differential Equations integration. + *

* - *

- *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). - *

+ *

+ * 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). + *

* - *

- *When an event is triggered, several different options are available: - *

- * * - *

- *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: - *

+ * 

+ * 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:
+ * 
  *  public double g(double t, double[] y) {
  *    return y[0] - targetConcentration;
  *  }
@@ -55,18 +55,18 @@
  *  public int eventOccurred(double t, double[] y) {
  *    return STOP;
  *  }
- *

- *

+ *
+ *

* - *

- *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: - *

+ * 

+ * 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:
+ * 
  *  public double g(double t, double[] y) {
  *    return (t - tManeuverStart) ∗ (t - tManeuverStop);
  *  }
@@ -74,12 +74,12 @@
  *  public int eventOccurred(double t, double[] y) {
  *    return RESET_DERIVATIVES;
  *  }
- *

- *

+ *
+ *

* - *

- *The third case is useful mainly for monitoring purposes, a simple example is: - *

+ * 

+ * The third case is useful mainly for monitoring purposes, a simple example is:
+ * 
  *  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;
  *  }
- *

- *

+ *
+ *

* * */ diff --git a/src/main/java/org/apache/commons/math/ode/nonstiff/package-info.java b/src/main/java/org/apache/commons/math/ode/nonstiff/package-info.java index cd431d3a0..aa90713a8 100644 --- a/src/main/java/org/apache/commons/math/ode/nonstiff/package-info.java +++ b/src/main/java/org/apache/commons/math/ode/nonstiff/package-info.java @@ -16,9 +16,9 @@ */ /** * - *

- *This package provides classes to solve non-stiff Ordinary Differential Equations problems. - *

+ *

+ * This package provides classes to solve non-stiff Ordinary Differential Equations problems. + *

* * */ diff --git a/src/main/java/org/apache/commons/math/ode/package-info.java b/src/main/java/org/apache/commons/math/ode/package-info.java index 231ea5d8f..49936ea58 100644 --- a/src/main/java/org/apache/commons/math/ode/package-info.java +++ b/src/main/java/org/apache/commons/math/ode/package-info.java @@ -16,147 +16,147 @@ */ /** * - *

- *This package provides classes to solve Ordinary Differential Equations problems. - *

+ *

+ * This package provides classes to solve Ordinary Differential Equations problems. + *

* - *

- *This package solves Initial Value Problems of the form - *y'=f(t,y) with t0 and - *y(t0)=y0 known. The provided - *integrators compute an estimate of y(t) from - *t=t0 to t=t1. - *It is also possible to get thederivatives with respect to the initial state - *dy(t)/dy(t0) or the derivatives with - *respect to some ODE parameters dy(t)/dp. - *

+ *

+ * This package solves Initial Value Problems of the form + * y'=f(t,y) with t0 and + * y(t0)=y0 known. The provided + * integrators compute an estimate of y(t) from + * t=t0 to t=t1. + * It is also possible to get thederivatives with respect to the initial state + * dy(t)/dy(t0) or the derivatives with + * respect to some ODE parameters dy(t)/dp. + *

* - *

- *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. - *

+ *

+ * 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. + *

* - *

- *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. - *

+ *

+ * 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. + *

* - *

- *The user should describe his problem in his own classes - *(UserProblem 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. - *

+ *

+ * The user should describe his problem in his own classes + * (UserProblem 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. + *

* - *

- *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 y 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. - *

+ *

+ * 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 y 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. + *

* - *

- *{@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 Serializable - *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. - *

+ *

+ * {@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 Serializable + * 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. + *

* - *

- *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. - *

+ *

+ * 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. + *

* - *

- *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. - *

+ *

+ * 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. + *

* - *

- * - * - * - * - * - * - * - * - *
Fixed Step Integrators
NameOrder
{@link org.apache.commons.math.ode.nonstiff.EulerIntegrator Euler}1
{@link org.apache.commons.math.ode.nonstiff.MidpointIntegrator Midpoint}2
{@link org.apache.commons.math.ode.nonstiff.ClassicalRungeKuttaIntegrator Classical Runge-Kutta}4
{@link org.apache.commons.math.ode.nonstiff.GillIntegrator Gill}4
{@link org.apache.commons.math.ode.nonstiff.ThreeEighthesIntegrator 3/8}4
- *

+ *

+ * + * + * + * + * + * + * + * + *
Fixed Step Integrators
NameOrder
{@link org.apache.commons.math.ode.nonstiff.EulerIntegrator Euler}1
{@link org.apache.commons.math.ode.nonstiff.MidpointIntegrator Midpoint}2
{@link org.apache.commons.math.ode.nonstiff.ClassicalRungeKuttaIntegrator Classical Runge-Kutta}4
{@link org.apache.commons.math.ode.nonstiff.GillIntegrator Gill}4
{@link org.apache.commons.math.ode.nonstiff.ThreeEighthesIntegrator 3/8}4
+ *

* - * - * - * - * - * - * - * - * - * - *
Adaptive Stepsize Integrators
NameIntegration OrderError Estimation Order
{@link org.apache.commons.math.ode.nonstiff.HighamHall54Integrator Higham and Hall}54
{@link org.apache.commons.math.ode.nonstiff.DormandPrince54Integrator Dormand-Prince 5(4)}54
{@link org.apache.commons.math.ode.nonstiff.DormandPrince853Integrator Dormand-Prince 8(5,3)}85 and 3
{@link org.apache.commons.math.ode.nonstiff.GraggBulirschStoerIntegrator Gragg-Bulirsch-Stoer}variable (up to 18 by default)variable
{@link org.apache.commons.math.ode.nonstiff.AdamsBashforthIntegrator Adams-Bashforth}variablevariable
{@link org.apache.commons.math.ode.nonstiff.AdamsMoultonIntegrator Adams-Moulton}variablevariable
- *

+ * + * + * + * + * + * + * + * + * + *
Adaptive Stepsize Integrators
NameIntegration OrderError Estimation Order
{@link org.apache.commons.math.ode.nonstiff.HighamHall54Integrator Higham and Hall}54
{@link org.apache.commons.math.ode.nonstiff.DormandPrince54Integrator Dormand-Prince 5(4)}54
{@link org.apache.commons.math.ode.nonstiff.DormandPrince853Integrator Dormand-Prince 8(5,3)}85 and 3
{@link org.apache.commons.math.ode.nonstiff.GraggBulirschStoerIntegrator Gragg-Bulirsch-Stoer}variable (up to 18 by default)variable
{@link org.apache.commons.math.ode.nonstiff.AdamsBashforthIntegrator Adams-Bashforth}variablevariable
{@link org.apache.commons.math.ode.nonstiff.AdamsMoultonIntegrator Adams-Moulton}variablevariable
+ *

* - *

- *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. - *

+ *

+ * 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. + *

* * */ diff --git a/src/main/java/org/apache/commons/math/ode/sampling/package-info.java b/src/main/java/org/apache/commons/math/ode/sampling/package-info.java index 0886e95fe..bb88dc7de 100644 --- a/src/main/java/org/apache/commons/math/ode/sampling/package-info.java +++ b/src/main/java/org/apache/commons/math/ode/sampling/package-info.java @@ -16,44 +16,44 @@ */ /** * - *

- *This package provides classes to handle sampling steps during - *Ordinary Differential Equations integration. - *

+ *

+ * This package provides classes to handle sampling steps during + * Ordinary Differential Equations integration. + *

* - *

- *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 inside 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. - *

+ *

+ * 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 inside 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. + *

* - *

- *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. - *

+ *

+ * 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. + *

* - *

- *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. - *

+ *

+ * 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. + *

* * */ diff --git a/src/main/java/org/apache/commons/math/optimization/direct/package-info.java b/src/main/java/org/apache/commons/math/optimization/direct/package-info.java index 8da83d999..0bd9e122d 100644 --- a/src/main/java/org/apache/commons/math/optimization/direct/package-info.java +++ b/src/main/java/org/apache/commons/math/optimization/direct/package-info.java @@ -16,9 +16,9 @@ */ /** * - *

- *This package provides optimization algorithms that don't require derivatives. - *

+ *

+ * This package provides optimization algorithms that don't require derivatives. + *

* */ package org.apache.commons.math.optimization.direct; diff --git a/src/main/java/org/apache/commons/math/optimization/fitting/package-info.java b/src/main/java/org/apache/commons/math/optimization/fitting/package-info.java index 87bcca176..0ba73f05d 100644 --- a/src/main/java/org/apache/commons/math/optimization/fitting/package-info.java +++ b/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. * - *

Curve fitting is a special case of a least squares problem - *were the parameters are the coefficients of a function f - *whose graph y=f(x) should pass through sample points, and - *were the objective function is the squared sum of residuals - *f(xi)-yi for observed points - *(xi, yi).

+ *

Curve fitting is a special case of a least squares problem + * were the parameters are the coefficients of a function f + * whose graph y=f(x) should pass through sample points, and + * were the objective function is the squared sum of residuals + * f(xi)-yi for observed points + * (xi, yi).

* * */ diff --git a/src/main/java/org/apache/commons/math/optimization/general/package-info.java b/src/main/java/org/apache/commons/math/optimization/general/package-info.java index 773bd8007..e8c19c6ef 100644 --- a/src/main/java/org/apache/commons/math/optimization/general/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/optimization/linear/package-info.java b/src/main/java/org/apache/commons/math/optimization/linear/package-info.java index c619a9ab8..5cee2644d 100644 --- a/src/main/java/org/apache/commons/math/optimization/linear/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/optimization/package-info.java b/src/main/java/org/apache/commons/math/optimization/package-info.java index ec8a7444e..1e6681ccc 100644 --- a/src/main/java/org/apache/commons/math/optimization/package-info.java +++ b/src/main/java/org/apache/commons/math/optimization/package-info.java @@ -16,22 +16,22 @@ */ /** * - *

- *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 analysis - *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. - *

+ *

+ * 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 analysis + * 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. + *

* - *

- *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: - *

+ *

* - *

- *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. - *

+ *

+ * 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. + *

* - *

- *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. - *

+ *

+ * 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. + *

* */ package org.apache.commons.math.optimization; diff --git a/src/main/java/org/apache/commons/math/optimization/univariate/package-info.java b/src/main/java/org/apache/commons/math/optimization/univariate/package-info.java index d3a2488bf..266ef892b 100644 --- a/src/main/java/org/apache/commons/math/optimization/univariate/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/package-info.java b/src/main/java/org/apache/commons/math/package-info.java index aac1ff4ea..b9e4f7aa7 100644 --- a/src/main/java/org/apache/commons/math/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/random/package-info.java b/src/main/java/org/apache/commons/math/random/package-info.java index cffe79cb9..09c76a9fe 100644 --- a/src/main/java/org/apache/commons/math/random/package-info.java +++ b/src/main/java/org/apache/commons/math/random/package-info.java @@ -127,6 +127,6 @@ * very strong properties of unpredictability as needed in cryptography. *

* - * + * */ package org.apache.commons.math.random; diff --git a/src/main/java/org/apache/commons/math/special/package-info.java b/src/main/java/org/apache/commons/math/special/package-info.java index a33d6ee67..46fb274b5 100644 --- a/src/main/java/org/apache/commons/math/special/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/stat/clustering/package-info.java b/src/main/java/org/apache/commons/math/stat/clustering/package-info.java index b0a075c33..af9bef3e1 100644 --- a/src/main/java/org/apache/commons/math/stat/clustering/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/stat/correlation/package-info.java b/src/main/java/org/apache/commons/math/stat/correlation/package-info.java index d5cf9276b..649372be5 100644 --- a/src/main/java/org/apache/commons/math/stat/correlation/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/stat/descriptive/moment/package-info.java b/src/main/java/org/apache/commons/math/stat/descriptive/moment/package-info.java index 82d44441e..bc0d011c8 100644 --- a/src/main/java/org/apache/commons/math/stat/descriptive/moment/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/stat/descriptive/package-info.java b/src/main/java/org/apache/commons/math/stat/descriptive/package-info.java index 5648093fb..7f37f26c5 100644 --- a/src/main/java/org/apache/commons/math/stat/descriptive/package-info.java +++ b/src/main/java/org/apache/commons/math/stat/descriptive/package-info.java @@ -39,6 +39,6 @@ * stat.clear();
* System.out.println("mean after clear is NaN = " + stat.getResult()); * - * + * */ package org.apache.commons.math.stat.descriptive; diff --git a/src/main/java/org/apache/commons/math/stat/descriptive/rank/package-info.java b/src/main/java/org/apache/commons/math/stat/descriptive/rank/package-info.java index 652abb91d..7f26d608f 100644 --- a/src/main/java/org/apache/commons/math/stat/descriptive/rank/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/stat/descriptive/summary/package-info.java b/src/main/java/org/apache/commons/math/stat/descriptive/summary/package-info.java index 7972f0ee3..126876b40 100644 --- a/src/main/java/org/apache/commons/math/stat/descriptive/summary/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/stat/inference/package-info.java b/src/main/java/org/apache/commons/math/stat/inference/package-info.java index be5847c15..d0dcaf03d 100644 --- a/src/main/java/org/apache/commons/math/stat/inference/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/stat/package-info.java b/src/main/java/org/apache/commons/math/stat/package-info.java index 0dc825940..87caed558 100644 --- a/src/main/java/org/apache/commons/math/stat/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/stat/ranking/package-info.java b/src/main/java/org/apache/commons/math/stat/ranking/package-info.java index 3dd6c1c73..0c0d073d0 100644 --- a/src/main/java/org/apache/commons/math/stat/ranking/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/stat/regression/package-info.java b/src/main/java/org/apache/commons/math/stat/regression/package-info.java index bb12ae5ba..54912a4ba 100644 --- a/src/main/java/org/apache/commons/math/stat/regression/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/transform/package-info.java b/src/main/java/org/apache/commons/math/transform/package-info.java index 4cdb070fc..b3ed7f565 100644 --- a/src/main/java/org/apache/commons/math/transform/package-info.java +++ b/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; diff --git a/src/main/java/org/apache/commons/math/util/package-info.java b/src/main/java/org/apache/commons/math/util/package-info.java index 0150950ba..388712819 100644 --- a/src/main/java/org/apache/commons/math/util/package-info.java +++ b/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;