Another floating point class. This one is built using radix 10000 - *which is 10^{4}, so its almost decimal.
+ *Another floating point class. This one is built using radix 10000 + * which is 10^{4}, so its almost decimal.
* - *The design goals here are: - *
The design goals here are: + *
Trade offs: - *
Trade offs: + *
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 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 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 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.
* - *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 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 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 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; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/distribution/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/distribution/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/distribution/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/distribution/package-info.java Sun Oct 2 09:25:27 2011 @@ -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; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/exception/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/exception/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/exception/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/exception/package-info.java Sun Oct 2 09:25:27 2011 @@ -18,6 +18,6 @@ * * Specialized exceptions for algorithms errors. The exceptions can be localized * using simple java properties. - * + * */ package org.apache.commons.math.exception; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/exception/util/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/exception/util/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/exception/util/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/exception/util/package-info.java Sun Oct 2 09:25:27 2011 @@ -17,6 +17,6 @@ /** * * Classes supporting exception localization. - * + * */ package org.apache.commons.math.exception.util; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/filter/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/filter/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/filter/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/filter/package-info.java Sun Oct 2 09:25:27 2011 @@ -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; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/fraction/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/fraction/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/fraction/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/fraction/package-info.java Sun Oct 2 09:25:27 2011 @@ -17,6 +17,6 @@ /** * * Fraction number type and fraction number formatting. - * + * */ package org.apache.commons.math.fraction; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/genetics/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/genetics/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/genetics/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/genetics/package-info.java Sun Oct 2 09:25:27 2011 @@ -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; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/euclidean/oned/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/euclidean/oned/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/euclidean/oned/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/euclidean/oned/package-info.java Sun Oct 2 09:25:27 2011 @@ -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; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/euclidean/threed/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/euclidean/threed/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/euclidean/threed/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/euclidean/threed/package-info.java Sun Oct 2 09:25:27 2011 @@ -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; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/euclidean/twod/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/euclidean/twod/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/euclidean/twod/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/euclidean/twod/package-info.java Sun Oct 2 09:25:27 2011 @@ -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; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/package-info.java Sun Oct 2 09:25:27 2011 @@ -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; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/partitioning/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/partitioning/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/partitioning/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/partitioning/package-info.java Sun Oct 2 09:25:27 2011 @@ -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). - *
- * - *- *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). - *
- * - *- *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.
- *
- *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. - *
+ *+ * {@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. + *
+ * + *+ * 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. + *
+ * + *
+ * 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. + *
* * */ Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/partitioning/utilities/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/partitioning/utilities/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/partitioning/utilities/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/geometry/partitioning/utilities/package-info.java Sun Oct 2 09:25:27 2011 @@ -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; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/package-info.java Sun Oct 2 09:25:27 2011 @@ -15,6 +15,6 @@ * limitations under the License. */ /** - *Linear algebra support. + * Linear algebra support. */ package org.apache.commons.math.linear; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/ode/events/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/ode/events/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/ode/events/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/ode/events/package-info.java Sun Oct 2 09:25:27 2011 @@ -16,38 +16,38 @@ */ /** * - *- *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). - *
- * - *- *When an event is triggered, several different options are available: - *
- *+ * 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). + *
+ * + *+ * 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: - *
+ *+ * * * */ Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/ode/nonstiff/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/ode/nonstiff/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/ode/nonstiff/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/ode/nonstiff/package-info.java Sun Oct 2 09:25:27 2011 @@ -16,9 +16,9 @@ */ /** * - *+ * 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; * } - *- * + *
- *This package provides classes to solve non-stiff Ordinary Differential Equations problems. - *
+ *+ * This package provides classes to solve non-stiff Ordinary Differential Equations problems. + *
* * */ Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/ode/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/ode/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/ode/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/ode/package-info.java Sun Oct 2 09:25:27 2011 @@ -16,147 +16,147 @@ */ /** * - *- *This package provides classes to solve Ordinary Differential Equations problems. - *
- * - *
- *This package solves Initial Value Problems of the form
- *y'=f(t,y)
with t_{0}
and
- *y(t_{0})=y_{0}
known. The provided
- *integrators compute an estimate of y(t)
from
- *t=t_{0}
to t=t_{1}
.
- *It is also possible to get thederivatives with respect to the initial state
- *dy(t)/dy(t_{0})
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 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 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.
- *
- *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. - *
- * - *- * - * - * - * - * - * - * - * - *
Fixed Step Integrators | |
Name | Order |
{@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 | ||
Name | Integration Order | Error Estimation Order |
{@link org.apache.commons.math.ode.nonstiff.HighamHall54Integrator Higham and Hall} | 5 | 4 |
{@link org.apache.commons.math.ode.nonstiff.DormandPrince54Integrator Dormand-Prince 5(4)} | 5 | 4 |
{@link org.apache.commons.math.ode.nonstiff.DormandPrince853Integrator Dormand-Prince 8(5,3)} | 8 | 5 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} | variable | variable |
{@link org.apache.commons.math.ode.nonstiff.AdamsMoultonIntegrator Adams-Moulton} | variable | variable |
- *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. - *
+ *+ * This package provides classes to solve Ordinary Differential Equations problems. + *
+ * + *
+ * This package solves Initial Value Problems of the form
+ * y'=f(t,y)
with t_{0}
and
+ * y(t_{0})=y_{0}
known. The provided
+ * integrators compute an estimate of y(t)
from
+ * t=t_{0}
to t=t_{1}
.
+ * It is also possible to get thederivatives with respect to the initial state
+ * dy(t)/dy(t_{0})
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 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 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.
+ *
+ * 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. + *
+ * + *+ * + * + * + * + * + * + * + * + *
Fixed Step Integrators | |
Name | Order |
{@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 | ||
Name | Integration Order | Error Estimation Order |
{@link org.apache.commons.math.ode.nonstiff.HighamHall54Integrator Higham and Hall} | 5 | 4 |
{@link org.apache.commons.math.ode.nonstiff.DormandPrince54Integrator Dormand-Prince 5(4)} | 5 | 4 |
{@link org.apache.commons.math.ode.nonstiff.DormandPrince853Integrator Dormand-Prince 8(5,3)} | 8 | 5 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} | variable | variable |
{@link org.apache.commons.math.ode.nonstiff.AdamsMoultonIntegrator Adams-Moulton} | variable | variable |
+ * 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. + *
* * */ Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/ode/sampling/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/ode/sampling/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/ode/sampling/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/ode/sampling/package-info.java Sun Oct 2 09:25:27 2011 @@ -16,44 +16,44 @@ */ /** * - *- *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 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. - *
+ *+ * 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 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. + *
* * */ Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/optimization/direct/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/optimization/direct/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/optimization/direct/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/optimization/direct/package-info.java Sun Oct 2 09:25:27 2011 @@ -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; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/optimization/fitting/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/optimization/fitting/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/optimization/fitting/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/optimization/fitting/package-info.java Sun Oct 2 09:25:27 2011 @@ -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(x_{i})-y_{i}
for observed points
- *(x_{i}, y_{i}).
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(x_{i})-y_{i}
for observed points
+ * (x_{i}, y_{i}).
- *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: - *
+ * 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; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/optimization/univariate/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/optimization/univariate/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/optimization/univariate/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/optimization/univariate/package-info.java Sun Oct 2 09:25:27 2011 @@ -17,6 +17,6 @@ /** * * Univariate real functions minimum finding algorithms. - * + * */ package org.apache.commons.math.optimization.univariate; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/package-info.java Sun Oct 2 09:25:27 2011 @@ -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; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/random/package-info.java Sun Oct 2 09:25:27 2011 @@ -127,6 +127,6 @@ * very strong properties of unpredictability as needed in cryptography. * * - * + * */ package org.apache.commons.math.random; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/special/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/special/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/special/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/special/package-info.java Sun Oct 2 09:25:27 2011 @@ -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; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/stat/clustering/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/stat/clustering/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/stat/clustering/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/stat/clustering/package-info.java Sun Oct 2 09:25:27 2011 @@ -15,6 +15,6 @@ * limitations under the License. */ /** - *Clustering algorithms + * Clustering algorithms */ package org.apache.commons.math.stat.clustering; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/stat/correlation/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/stat/correlation/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/stat/correlation/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/stat/correlation/package-info.java Sun Oct 2 09:25:27 2011 @@ -17,6 +17,6 @@ /** * * Correlations/Covariance computations. - * + * */ package org.apache.commons.math.stat.correlation; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/stat/descriptive/moment/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/stat/descriptive/moment/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/stat/descriptive/moment/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/stat/descriptive/moment/package-info.java Sun Oct 2 09:25:27 2011 @@ -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; Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/stat/descriptive/package-info.java URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/stat/descriptive/package-info.java?rev=1178163&r1=1178162&r2=1178163&view=diff ============================================================================== --- commons/proper/math/trunk/src/main/java/org/apache/commons/math/stat/descriptive/package-info.java (original) +++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/stat/descriptive/package-info.java Sun Oct 2 09:25:27 2011 @@ -39,6 +39,6 @@ * stat.clear();