http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsBashforthIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsBashforthIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsBashforthIntegrator.java index cd84f18..5321750 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsBashforthIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsBashforthIntegrator.java @@ -54,19 +54,19 @@ import org.apache.commons.math4.util.FastMath; * <h3>Implementation details</h3> * * <p>We define scaled derivatives s<sub>i</sub>(n) at step n as: - * <pre> + * <div style="white-space: pre"><code> * s<sub>1</sub>(n) = h y'<sub>n</sub> for first derivative * s<sub>2</sub>(n) = h<sup>2</sup>/2 y''<sub>n</sub> for second derivative * s<sub>3</sub>(n) = h<sup>3</sup>/6 y'''<sub>n</sub> for third derivative * ... * s<sub>k</sub>(n) = h<sup>k</sup>/k! y<sup>(k)</sup><sub>n</sub> for k<sup>th</sup> derivative - * </pre></p> + * </code></div> * * <p>The definitions above use the classical representation with several previous first * derivatives. Lets define - * <pre> + * <div style="white-space: pre"><code> * q<sub>n</sub> = [ s<sub>1</sub>(n-1) s<sub>1</sub>(n-2) ... s<sub>1</sub>(n-(k-1)) ]<sup>T</sup> - * </pre> + * </code></div> * (we omit the k index in the notation for clarity). With these definitions, * Adams-Bashforth methods can be written: * <ul> @@ -75,30 +75,29 @@ import org.apache.commons.math4.util.FastMath; * <li>k = 3: y<sub>n+1</sub> = y<sub>n</sub> + 23/12 s<sub>1</sub>(n) + [ -16/12 5/12 ] q<sub>n</sub></li> * <li>k = 4: y<sub>n+1</sub> = y<sub>n</sub> + 55/24 s<sub>1</sub>(n) + [ -59/24 37/24 -9/24 ] q<sub>n</sub></li> * <li>...</li> - * </ul></p> + * </ul> * * <p>Instead of using the classical representation with first derivatives only (y<sub>n</sub>, * s<sub>1</sub>(n) and q<sub>n</sub>), our implementation uses the Nordsieck vector with * higher degrees scaled derivatives all taken at the same step (y<sub>n</sub>, s<sub>1</sub>(n) * and r<sub>n</sub>) where r<sub>n</sub> is defined as: - * <pre> + * <div style="white-space: pre"><code> * r<sub>n</sub> = [ s<sub>2</sub>(n), s<sub>3</sub>(n) ... s<sub>k</sub>(n) ]<sup>T</sup> - * </pre> + * </code></div> * (here again we omit the k index in the notation for clarity) - * </p> * * <p>Taylor series formulas show that for any index offset i, s<sub>1</sub>(n-i) can be * computed from s<sub>1</sub>(n), s<sub>2</sub>(n) ... s<sub>k</sub>(n), the formula being exact * for degree k polynomials. - * <pre> + * <div style="white-space: pre"><code> * s<sub>1</sub>(n-i) = s<sub>1</sub>(n) + ∑<sub>j>0</sub> (j+1) (-i)<sup>j</sup> s<sub>j+1</sub>(n) - * </pre> + * </code></div> * The previous formula can be used with several values for i to compute the transform between * classical representation and Nordsieck vector. The transform between r<sub>n</sub> * and q<sub>n</sub> resulting from the Taylor series formulas above is: - * <pre> + * <div style="white-space: pre"><code> * q<sub>n</sub> = s<sub>1</sub>(n) u + P r<sub>n</sub> - * </pre> + * </code></div> * where u is the [ 1 1 ... 1 ]<sup>T</sup> vector and P is the (k-1)×(k-1) matrix built * with the (j+1) (-i)<sup>j</sup> terms with i being the row number starting from 1 and j being * the column number starting from 1: @@ -108,7 +107,7 @@ import org.apache.commons.math4.util.FastMath; * P = [ -6 27 -108 405 ... ] * [ -8 48 -256 1280 ... ] * [ ... ] - * </pre></p> + * </pre> * * <p>Using the Nordsieck vector has several advantages: * <ul> @@ -117,7 +116,7 @@ import org.apache.commons.math4.util.FastMath; * <li>it simplifies step changes that occur when discrete events that truncate * the step are triggered,</li> * <li>it allows to extend the methods in order to support adaptive stepsize.</li> - * </ul></p> + * </ul> * * <p>The Nordsieck vector at step n+1 is computed from the Nordsieck vector at step n as follows: * <ul> @@ -134,7 +133,7 @@ import org.apache.commons.math4.util.FastMath; * [ ... | 0 ] * [ 0 0 ... 1 0 | 0 ] * [ 0 0 ... 0 1 | 0 ] - * </pre></p> + * </pre> * * <p>The P<sup>-1</sup>u vector and the P<sup>-1</sup> A P matrix do not depend on the state, * they only depend on k and therefore are precomputed once for all.</p>
http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsFieldIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsFieldIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsFieldIntegrator.java index cb2061b..700739d 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsFieldIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsFieldIntegrator.java @@ -112,10 +112,10 @@ public abstract class AdamsFieldIntegrator<T extends RealFieldElement<T>> extend /** Update the high order scaled derivatives for Adams integrators (phase 1). * <p>The complete update of high order derivatives has a form similar to: - * <pre> + * <div style="white-space: pre"><code> * r<sub>n+1</sub> = (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u + P<sup>-1</sup> A P r<sub>n</sub> - * </pre> - * this method computes the P<sup>-1</sup> A P r<sub>n</sub> part.</p> + * </code></div> + * this method computes the P<sup>-1</sup> A P r<sub>n</sub> part. * @param highOrder high order scaled derivatives * (h<sup>2</sup>/2 y'', ... h<sup>k</sup>/k! y(k)) * @return updated high order derivatives @@ -127,10 +127,10 @@ public abstract class AdamsFieldIntegrator<T extends RealFieldElement<T>> extend /** Update the high order scaled derivatives Adams integrators (phase 2). * <p>The complete update of high order derivatives has a form similar to: - * <pre> + * <div style="white-space: pre"><code> * r<sub>n+1</sub> = (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u + P<sup>-1</sup> A P r<sub>n</sub> - * </pre> - * this method computes the (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u part.</p> + * </code></div> + * this method computes the (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u part. * <p>Phase 1 of the update must already have been performed.</p> * @param start first order scaled derivatives at step start * @param end first order scaled derivatives at step end http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsIntegrator.java index 9563d31..01a41b7 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsIntegrator.java @@ -101,10 +101,10 @@ public abstract class AdamsIntegrator extends MultistepIntegrator { /** Update the high order scaled derivatives for Adams integrators (phase 1). * <p>The complete update of high order derivatives has a form similar to: - * <pre> + * <div style="white-space: pre"><code> * r<sub>n+1</sub> = (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u + P<sup>-1</sup> A P r<sub>n</sub> - * </pre> - * this method computes the P<sup>-1</sup> A P r<sub>n</sub> part.</p> + * </code></div> + * this method computes the P<sup>-1</sup> A P r<sub>n</sub> part. * @param highOrder high order scaled derivatives * (h<sup>2</sup>/2 y'', ... h<sup>k</sup>/k! y(k)) * @return updated high order derivatives @@ -116,10 +116,10 @@ public abstract class AdamsIntegrator extends MultistepIntegrator { /** Update the high order scaled derivatives Adams integrators (phase 2). * <p>The complete update of high order derivatives has a form similar to: - * <pre> + * <div style="white-space: pre"><code> * r<sub>n+1</sub> = (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u + P<sup>-1</sup> A P r<sub>n</sub> - * </pre> - * this method computes the (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u part.</p> + * </code></div> + * this method computes the (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u part. * <p>Phase 1 of the update must already have been performed.</p> * @param start first order scaled derivatives at step start * @param end first order scaled derivatives at step end http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonFieldIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonFieldIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonFieldIntegrator.java index 658cd6d..bc07d03 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonFieldIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonFieldIntegrator.java @@ -62,19 +62,19 @@ import org.apache.commons.math4.util.MathUtils; * <h3>Implementation details</h3> * * <p>We define scaled derivatives s<sub>i</sub>(n) at step n as: - * <pre> + * <div style="white-space: pre"><code> * s<sub>1</sub>(n) = h y'<sub>n</sub> for first derivative * s<sub>2</sub>(n) = h<sup>2</sup>/2 y''<sub>n</sub> for second derivative * s<sub>3</sub>(n) = h<sup>3</sup>/6 y'''<sub>n</sub> for third derivative * ... * s<sub>k</sub>(n) = h<sup>k</sup>/k! y<sup>(k)</sup><sub>n</sub> for k<sup>th</sup> derivative - * </pre></p> + * </code></div> * * <p>The definitions above use the classical representation with several previous first * derivatives. Lets define - * <pre> + * <div style="white-space: pre"><code> * q<sub>n</sub> = [ s<sub>1</sub>(n-1) s<sub>1</sub>(n-2) ... s<sub>1</sub>(n-(k-1)) ]<sup>T</sup> - * </pre> + * </code></div> * (we omit the k index in the notation for clarity). With these definitions, * Adams-Moulton methods can be written: * <ul> @@ -83,30 +83,29 @@ import org.apache.commons.math4.util.MathUtils; * <li>k = 3: y<sub>n+1</sub> = y<sub>n</sub> + 5/12 s<sub>1</sub>(n+1) + [ 8/12 -1/12 ] q<sub>n+1</sub></li> * <li>k = 4: y<sub>n+1</sub> = y<sub>n</sub> + 9/24 s<sub>1</sub>(n+1) + [ 19/24 -5/24 1/24 ] q<sub>n+1</sub></li> * <li>...</li> - * </ul></p> + * </ul> * * <p>Instead of using the classical representation with first derivatives only (y<sub>n</sub>, * s<sub>1</sub>(n+1) and q<sub>n+1</sub>), our implementation uses the Nordsieck vector with * higher degrees scaled derivatives all taken at the same step (y<sub>n</sub>, s<sub>1</sub>(n) * and r<sub>n</sub>) where r<sub>n</sub> is defined as: - * <pre> + * <div style="white-space: pre"><code> * r<sub>n</sub> = [ s<sub>2</sub>(n), s<sub>3</sub>(n) ... s<sub>k</sub>(n) ]<sup>T</sup> - * </pre> + * </code></div> * (here again we omit the k index in the notation for clarity) - * </p> * * <p>Taylor series formulas show that for any index offset i, s<sub>1</sub>(n-i) can be * computed from s<sub>1</sub>(n), s<sub>2</sub>(n) ... s<sub>k</sub>(n), the formula being exact * for degree k polynomials. - * <pre> + * <div style="white-space: pre"><code> * s<sub>1</sub>(n-i) = s<sub>1</sub>(n) + ∑<sub>j>0</sub> (j+1) (-i)<sup>j</sup> s<sub>j+1</sub>(n) - * </pre> + * </code></div> * The previous formula can be used with several values for i to compute the transform between * classical representation and Nordsieck vector. The transform between r<sub>n</sub> * and q<sub>n</sub> resulting from the Taylor series formulas above is: - * <pre> + * <div style="white-space: pre"><code> * q<sub>n</sub> = s<sub>1</sub>(n) u + P r<sub>n</sub> - * </pre> + * </code></div> * where u is the [ 1 1 ... 1 ]<sup>T</sup> vector and P is the (k-1)×(k-1) matrix built * with the (j+1) (-i)<sup>j</sup> terms with i being the row number starting from 1 and j being * the column number starting from 1: @@ -116,7 +115,7 @@ import org.apache.commons.math4.util.MathUtils; * P = [ -6 27 -108 405 ... ] * [ -8 48 -256 1280 ... ] * [ ... ] - * </pre></p> + * </pre> * * <p>Using the Nordsieck vector has several advantages: * <ul> @@ -125,7 +124,7 @@ import org.apache.commons.math4.util.MathUtils; * <li>it simplifies step changes that occur when discrete events that truncate * the step are triggered,</li> * <li>it allows to extend the methods in order to support adaptive stepsize.</li> - * </ul></p> + * </ul> * * <p>The predicted Nordsieck vector at step n+1 is computed from the Nordsieck vector at step * n as follows: @@ -152,7 +151,7 @@ import org.apache.commons.math4.util.MathUtils; * </ul> * where the upper case Y<sub>n+1</sub>, S<sub>1</sub>(n+1) and R<sub>n+1</sub> represent the * predicted states whereas the lower case y<sub>n+1</sub>, s<sub>n+1</sub> and r<sub>n+1</sub> - * represent the corrected states.</p> + * represent the corrected states. * * <p>The P<sup>-1</sup>u vector and the P<sup>-1</sup> A P matrix do not depend on the state, * they only depend on k and therefore are precomputed once for all.</p> http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonIntegrator.java index 2e5c544..634fcac 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsMoultonIntegrator.java @@ -59,19 +59,19 @@ import org.apache.commons.math4.util.FastMath; * <h3>Implementation details</h3> * * <p>We define scaled derivatives s<sub>i</sub>(n) at step n as: - * <pre> + * <div style="white-space: pre"><code> * s<sub>1</sub>(n) = h y'<sub>n</sub> for first derivative * s<sub>2</sub>(n) = h<sup>2</sup>/2 y''<sub>n</sub> for second derivative * s<sub>3</sub>(n) = h<sup>3</sup>/6 y'''<sub>n</sub> for third derivative * ... * s<sub>k</sub>(n) = h<sup>k</sup>/k! y<sup>(k)</sup><sub>n</sub> for k<sup>th</sup> derivative - * </pre></p> + * </code></div> * * <p>The definitions above use the classical representation with several previous first * derivatives. Lets define - * <pre> + * <div style="white-space: pre"><code> * q<sub>n</sub> = [ s<sub>1</sub>(n-1) s<sub>1</sub>(n-2) ... s<sub>1</sub>(n-(k-1)) ]<sup>T</sup> - * </pre> + * </code></div> * (we omit the k index in the notation for clarity). With these definitions, * Adams-Moulton methods can be written: * <ul> @@ -80,30 +80,29 @@ import org.apache.commons.math4.util.FastMath; * <li>k = 3: y<sub>n+1</sub> = y<sub>n</sub> + 5/12 s<sub>1</sub>(n+1) + [ 8/12 -1/12 ] q<sub>n+1</sub></li> * <li>k = 4: y<sub>n+1</sub> = y<sub>n</sub> + 9/24 s<sub>1</sub>(n+1) + [ 19/24 -5/24 1/24 ] q<sub>n+1</sub></li> * <li>...</li> - * </ul></p> + * </ul> * * <p>Instead of using the classical representation with first derivatives only (y<sub>n</sub>, * s<sub>1</sub>(n+1) and q<sub>n+1</sub>), our implementation uses the Nordsieck vector with * higher degrees scaled derivatives all taken at the same step (y<sub>n</sub>, s<sub>1</sub>(n) * and r<sub>n</sub>) where r<sub>n</sub> is defined as: - * <pre> + * <div style="white-space: pre"><code> * r<sub>n</sub> = [ s<sub>2</sub>(n), s<sub>3</sub>(n) ... s<sub>k</sub>(n) ]<sup>T</sup> - * </pre> + * </code></div> * (here again we omit the k index in the notation for clarity) - * </p> * * <p>Taylor series formulas show that for any index offset i, s<sub>1</sub>(n-i) can be * computed from s<sub>1</sub>(n), s<sub>2</sub>(n) ... s<sub>k</sub>(n), the formula being exact * for degree k polynomials. - * <pre> + * <div style="white-space: pre"><code> * s<sub>1</sub>(n-i) = s<sub>1</sub>(n) + ∑<sub>j>0</sub> (j+1) (-i)<sup>j</sup> s<sub>j+1</sub>(n) - * </pre> + * </code></div> * The previous formula can be used with several values for i to compute the transform between * classical representation and Nordsieck vector. The transform between r<sub>n</sub> * and q<sub>n</sub> resulting from the Taylor series formulas above is: - * <pre> + * <div style="white-space: pre"><code> * q<sub>n</sub> = s<sub>1</sub>(n) u + P r<sub>n</sub> - * </pre> + * </code></div> * where u is the [ 1 1 ... 1 ]<sup>T</sup> vector and P is the (k-1)×(k-1) matrix built * with the (j+1) (-i)<sup>j</sup> terms with i being the row number starting from 1 and j being * the column number starting from 1: @@ -113,7 +112,7 @@ import org.apache.commons.math4.util.FastMath; * P = [ -6 27 -108 405 ... ] * [ -8 48 -256 1280 ... ] * [ ... ] - * </pre></p> + * </pre> * * <p>Using the Nordsieck vector has several advantages: * <ul> @@ -122,7 +121,7 @@ import org.apache.commons.math4.util.FastMath; * <li>it simplifies step changes that occur when discrete events that truncate * the step are triggered,</li> * <li>it allows to extend the methods in order to support adaptive stepsize.</li> - * </ul></p> + * </ul> * * <p>The predicted Nordsieck vector at step n+1 is computed from the Nordsieck vector at step * n as follows: @@ -149,7 +148,7 @@ import org.apache.commons.math4.util.FastMath; * </ul> * where the upper case Y<sub>n+1</sub>, S<sub>1</sub>(n+1) and R<sub>n+1</sub> represent the * predicted states whereas the lower case y<sub>n+1</sub>, s<sub>n+1</sub> and r<sub>n+1</sub> - * represent the corrected states.</p> + * represent the corrected states. * * <p>The P<sup>-1</sup>u vector and the P<sup>-1</sup> A P matrix do not depend on the state, * they only depend on k and therefore are precomputed once for all.</p> http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsNordsieckFieldTransformer.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsNordsieckFieldTransformer.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsNordsieckFieldTransformer.java index 7c2b872..c65a948 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsNordsieckFieldTransformer.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsNordsieckFieldTransformer.java @@ -37,43 +37,42 @@ import org.apache.commons.math4.util.MathArrays; * representation with higher order scaled derivatives.</p> * * <p>We define scaled derivatives s<sub>i</sub>(n) at step n as: - * <pre> + * <div style="white-space: pre"><code> * s<sub>1</sub>(n) = h y'<sub>n</sub> for first derivative * s<sub>2</sub>(n) = h<sup>2</sup>/2 y''<sub>n</sub> for second derivative * s<sub>3</sub>(n) = h<sup>3</sup>/6 y'''<sub>n</sub> for third derivative * ... * s<sub>k</sub>(n) = h<sup>k</sup>/k! y<sup>(k)</sup><sub>n</sub> for k<sup>th</sup> derivative - * </pre></p> + * </code></div> * * <p>With the previous definition, the classical representation of multistep methods * uses first derivatives only, i.e. it handles y<sub>n</sub>, s<sub>1</sub>(n) and * q<sub>n</sub> where q<sub>n</sub> is defined as: - * <pre> + * <div style="white-space: pre"><code> * q<sub>n</sub> = [ s<sub>1</sub>(n-1) s<sub>1</sub>(n-2) ... s<sub>1</sub>(n-(k-1)) ]<sup>T</sup> - * </pre> - * (we omit the k index in the notation for clarity).</p> + * </code></div> + * (we omit the k index in the notation for clarity). * * <p>Another possible representation uses the Nordsieck vector with * higher degrees scaled derivatives all taken at the same step, i.e it handles y<sub>n</sub>, * s<sub>1</sub>(n) and r<sub>n</sub>) where r<sub>n</sub> is defined as: - * <pre> + * <div style="white-space: pre"><code> * r<sub>n</sub> = [ s<sub>2</sub>(n), s<sub>3</sub>(n) ... s<sub>k</sub>(n) ]<sup>T</sup> - * </pre> + * </code></div> * (here again we omit the k index in the notation for clarity) - * </p> * * <p>Taylor series formulas show that for any index offset i, s<sub>1</sub>(n-i) can be * computed from s<sub>1</sub>(n), s<sub>2</sub>(n) ... s<sub>k</sub>(n), the formula being exact * for degree k polynomials. - * <pre> + * <div style="white-space: pre"><code> * s<sub>1</sub>(n-i) = s<sub>1</sub>(n) + ∑<sub>j>0</sub> (j+1) (-i)<sup>j</sup> s<sub>j+1</sub>(n) - * </pre> + * </code></div> * The previous formula can be used with several values for i to compute the transform between * classical representation and Nordsieck vector at step end. The transform between r<sub>n</sub> * and q<sub>n</sub> resulting from the Taylor series formulas above is: - * <pre> + * <div style="white-space: pre"><code> * q<sub>n</sub> = s<sub>1</sub>(n) u + P r<sub>n</sub> - * </pre> + * </code></div> * where u is the [ 1 1 ... 1 ]<sup>T</sup> vector and P is the (k-1)×(k-1) matrix built * with the (j+1) (-i)<sup>j</sup> terms with i being the row number starting from 1 and j being * the column number starting from 1: @@ -83,7 +82,7 @@ import org.apache.commons.math4.util.MathArrays; * P = [ -6 27 -108 405 ... ] * [ -8 48 -256 1280 ... ] * [ ... ] - * </pre></p> + * </pre> * * <p>Changing -i into +i in the formula above can be used to compute a similar transform between * classical representation and Nordsieck vector at step start. The resulting matrix is simply @@ -105,7 +104,7 @@ import org.apache.commons.math4.util.MathArrays; * [ ... | 0 ] * [ 0 0 ... 1 0 | 0 ] * [ 0 0 ... 0 1 | 0 ] - * </pre></p> + * </pre> * * <p>For {@link AdamsMoultonIntegrator Adams-Moulton} method, the predicted Nordsieck vector * at step n+1 is computed from the Nordsieck vector at step n as follows: @@ -122,7 +121,7 @@ import org.apache.commons.math4.util.MathArrays; * </ul> * where the upper case Y<sub>n+1</sub>, S<sub>1</sub>(n+1) and R<sub>n+1</sub> represent the * predicted states whereas the lower case y<sub>n+1</sub>, s<sub>n+1</sub> and r<sub>n+1</sub> - * represent the corrected states.</p> + * represent the corrected states. * * <p>We observe that both methods use similar update formulas. In both cases a P<sup>-1</sup>u * vector and a P<sup>-1</sup> A P matrix are used that do not depend on the state, @@ -218,7 +217,7 @@ public class AdamsNordsieckFieldTransformer<T extends RealFieldElement<T>> { * P = [ -6 27 -108 405 ... ] * [ -8 48 -256 1280 ... ] * [ ... ] - * </pre></p> + * </pre> * @param rows number of rows of the matrix * @return P matrix */ @@ -318,10 +317,10 @@ public class AdamsNordsieckFieldTransformer<T extends RealFieldElement<T>> { /** Update the high order scaled derivatives for Adams integrators (phase 1). * <p>The complete update of high order derivatives has a form similar to: - * <pre> + * <div style="white-space: pre"><code> * r<sub>n+1</sub> = (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u + P<sup>-1</sup> A P r<sub>n</sub> - * </pre> - * this method computes the P<sup>-1</sup> A P r<sub>n</sub> part.</p> + * </code></div> + * this method computes the P<sup>-1</sup> A P r<sub>n</sub> part. * @param highOrder high order scaled derivatives * (h<sup>2</sup>/2 y'', ... h<sup>k</sup>/k! y(k)) * @return updated high order derivatives @@ -333,10 +332,10 @@ public class AdamsNordsieckFieldTransformer<T extends RealFieldElement<T>> { /** Update the high order scaled derivatives Adams integrators (phase 2). * <p>The complete update of high order derivatives has a form similar to: - * <pre> + * <div style="white-space: pre"><code> * r<sub>n+1</sub> = (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u + P<sup>-1</sup> A P r<sub>n</sub> - * </pre> - * this method computes the (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u part.</p> + * </code></div> + * this method computes the (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u part. * <p>Phase 1 of the update must already have been performed.</p> * @param start first order scaled derivatives at step start * @param end first order scaled derivatives at step end http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsNordsieckTransformer.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsNordsieckTransformer.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsNordsieckTransformer.java index f38e61a..7cf5a4e 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsNordsieckTransformer.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/AdamsNordsieckTransformer.java @@ -39,43 +39,42 @@ import org.apache.commons.math4.linear.RealMatrix; * representation with higher order scaled derivatives.</p> * * <p>We define scaled derivatives s<sub>i</sub>(n) at step n as: - * <pre> + * <div style="white-space: pre"><code> * s<sub>1</sub>(n) = h y'<sub>n</sub> for first derivative * s<sub>2</sub>(n) = h<sup>2</sup>/2 y''<sub>n</sub> for second derivative * s<sub>3</sub>(n) = h<sup>3</sup>/6 y'''<sub>n</sub> for third derivative * ... * s<sub>k</sub>(n) = h<sup>k</sup>/k! y<sup>(k)</sup><sub>n</sub> for k<sup>th</sup> derivative - * </pre></p> + * </code></div> * * <p>With the previous definition, the classical representation of multistep methods * uses first derivatives only, i.e. it handles y<sub>n</sub>, s<sub>1</sub>(n) and * q<sub>n</sub> where q<sub>n</sub> is defined as: - * <pre> + * <div style="white-space: pre"><code> * q<sub>n</sub> = [ s<sub>1</sub>(n-1) s<sub>1</sub>(n-2) ... s<sub>1</sub>(n-(k-1)) ]<sup>T</sup> - * </pre> - * (we omit the k index in the notation for clarity).</p> + * </code></div> + * (we omit the k index in the notation for clarity). * * <p>Another possible representation uses the Nordsieck vector with * higher degrees scaled derivatives all taken at the same step, i.e it handles y<sub>n</sub>, * s<sub>1</sub>(n) and r<sub>n</sub>) where r<sub>n</sub> is defined as: - * <pre> + * <div style="white-space: pre"><code> * r<sub>n</sub> = [ s<sub>2</sub>(n), s<sub>3</sub>(n) ... s<sub>k</sub>(n) ]<sup>T</sup> - * </pre> + * </code></div> * (here again we omit the k index in the notation for clarity) - * </p> * * <p>Taylor series formulas show that for any index offset i, s<sub>1</sub>(n-i) can be * computed from s<sub>1</sub>(n), s<sub>2</sub>(n) ... s<sub>k</sub>(n), the formula being exact * for degree k polynomials. - * <pre> + * <div style="white-space: pre"><code> * s<sub>1</sub>(n-i) = s<sub>1</sub>(n) + ∑<sub>j>0</sub> (j+1) (-i)<sup>j</sup> s<sub>j+1</sub>(n) - * </pre> + * </code></div> * The previous formula can be used with several values for i to compute the transform between * classical representation and Nordsieck vector at step end. The transform between r<sub>n</sub> * and q<sub>n</sub> resulting from the Taylor series formulas above is: - * <pre> + * <div style="white-space: pre"><code> * q<sub>n</sub> = s<sub>1</sub>(n) u + P r<sub>n</sub> - * </pre> + * </code></div> * where u is the [ 1 1 ... 1 ]<sup>T</sup> vector and P is the (k-1)×(k-1) matrix built * with the (j+1) (-i)<sup>j</sup> terms with i being the row number starting from 1 and j being * the column number starting from 1: @@ -85,7 +84,7 @@ import org.apache.commons.math4.linear.RealMatrix; * P = [ -6 27 -108 405 ... ] * [ -8 48 -256 1280 ... ] * [ ... ] - * </pre></p> + * </pre> * * <p>Changing -i into +i in the formula above can be used to compute a similar transform between * classical representation and Nordsieck vector at step start. The resulting matrix is simply @@ -107,7 +106,7 @@ import org.apache.commons.math4.linear.RealMatrix; * [ ... | 0 ] * [ 0 0 ... 1 0 | 0 ] * [ 0 0 ... 0 1 | 0 ] - * </pre></p> + * </pre> * * <p>For {@link AdamsMoultonIntegrator Adams-Moulton} method, the predicted Nordsieck vector * at step n+1 is computed from the Nordsieck vector at step n as follows: @@ -124,7 +123,7 @@ import org.apache.commons.math4.linear.RealMatrix; * </ul> * where the upper case Y<sub>n+1</sub>, S<sub>1</sub>(n+1) and R<sub>n+1</sub> represent the * predicted states whereas the lower case y<sub>n+1</sub>, s<sub>n+1</sub> and r<sub>n+1</sub> - * represent the corrected states.</p> + * represent the corrected states. * * <p>We observe that both methods use similar update formulas. In both cases a P<sup>-1</sup>u * vector and a P<sup>-1</sup> A P matrix are used that do not depend on the state, @@ -220,7 +219,7 @@ public class AdamsNordsieckTransformer { * P = [ -6 27 -108 405 ... ] * [ -8 48 -256 1280 ... ] * [ ... ] - * </pre></p> + * </pre> * @param rows number of rows of the matrix * @return P matrix */ @@ -319,10 +318,10 @@ public class AdamsNordsieckTransformer { /** Update the high order scaled derivatives for Adams integrators (phase 1). * <p>The complete update of high order derivatives has a form similar to: - * <pre> + * <div style="white-space: pre"><code> * r<sub>n+1</sub> = (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u + P<sup>-1</sup> A P r<sub>n</sub> - * </pre> - * this method computes the P<sup>-1</sup> A P r<sub>n</sub> part.</p> + * </code></div> + * this method computes the P<sup>-1</sup> A P r<sub>n</sub> part. * @param highOrder high order scaled derivatives * (h<sup>2</sup>/2 y'', ... h<sup>k</sup>/k! y(k)) * @return updated high order derivatives @@ -334,10 +333,10 @@ public class AdamsNordsieckTransformer { /** Update the high order scaled derivatives Adams integrators (phase 2). * <p>The complete update of high order derivatives has a form similar to: - * <pre> + * <div style="white-space: pre"><code> * r<sub>n+1</sub> = (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u + P<sup>-1</sup> A P r<sub>n</sub> - * </pre> - * this method computes the (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u part.</p> + * </code></div> + * this method computes the (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u part. * <p>Phase 1 of the update must already have been performed.</p> * @param start first order scaled derivatives at step start * @param end first order scaled derivatives at step end http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/AdaptiveStepsizeFieldIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/AdaptiveStepsizeFieldIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/AdaptiveStepsizeFieldIntegrator.java index ca774c3..cda1310 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/AdaptiveStepsizeFieldIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/AdaptiveStepsizeFieldIntegrator.java @@ -45,7 +45,7 @@ import org.apache.commons.math4.util.MathUtils; * state vector and relTol_i is the relative tolerance for the same * component. The user can also use only two scalar values absTol and * relTol which will be used for all components. - * </p> + * * <p> * Note that <em>only</em> the {@link FieldODEState#getState() main part} * of the state vector is used for stepsize control. The {@link @@ -55,12 +55,12 @@ import org.apache.commons.math4.util.MathUtils; * * <p>If the estimated error for ym+1 is such that * <pre> - * sqrt((sum (errEst_i / threshold_i)^2 ) / n) < 1 + * sqrt((sum (errEst_i / threshold_i)^2 ) / n) < 1 * </pre> * * (where n is the main set dimension) then the step is accepted, * otherwise the step is rejected and a new attempt is made with a new - * stepsize.</p> + * stepsize. * * @param <T> the type of the field elements * @since 3.6 http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/AdaptiveStepsizeIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/AdaptiveStepsizeIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/AdaptiveStepsizeIntegrator.java index 6dacc1a..7219383 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/AdaptiveStepsizeIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/AdaptiveStepsizeIntegrator.java @@ -40,7 +40,7 @@ import org.apache.commons.math4.util.FastMath; * state vector and relTol_i is the relative tolerance for the same * component. The user can also use only two scalar values absTol and * relTol which will be used for all components. - * </p> + * * <p> * If the Ordinary Differential Equations is an {@link ExpandableStatefulODE * extended ODE} rather than a {@link @@ -51,12 +51,12 @@ import org.apache.commons.math4.util.FastMath; * * <p>If the estimated error for ym+1 is such that * <pre> - * sqrt((sum (errEst_i / threshold_i)^2 ) / n) < 1 + * sqrt((sum (errEst_i / threshold_i)^2 ) / n) < 1 * </pre> * * (where n is the main set dimension) then the step is accepted, * otherwise the step is rejected and a new attempt is made with a new - * stepsize.</p> + * stepsize. * * @since 1.2 * http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaFieldIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaFieldIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaFieldIntegrator.java index 56add60..55a9dfd 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaFieldIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaFieldIntegrator.java @@ -38,7 +38,6 @@ import org.apache.commons.math4.util.MathArrays; * |-------------------- * | 1/6 1/3 1/3 1/6 * </pre> - * </p> * * @see EulerFieldIntegrator * @see GillFieldIntegrator http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaFieldStepInterpolator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaFieldStepInterpolator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaFieldStepInterpolator.java index c4d1263..79a744e 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaFieldStepInterpolator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaFieldStepInterpolator.java @@ -45,7 +45,6 @@ import org.apache.commons.math4.ode.FieldODEStateAndDerivative; * ] * </li> * </ul> - * </p> * * where θ belongs to [0 ; 1] and where y'<sub>1</sub> to y'<sub>4</sub> are the four * evaluations of the derivatives already computed during the http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaIntegrator.java index e6df204..68daf67 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaIntegrator.java @@ -33,7 +33,6 @@ package org.apache.commons.math4.ode.nonstiff; * |-------------------- * | 1/6 1/3 1/3 1/6 * </pre> - * </p> * * @see EulerIntegrator * @see GillIntegrator http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaStepInterpolator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaStepInterpolator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaStepInterpolator.java index d7704d7..8ae949a 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaStepInterpolator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/ClassicalRungeKuttaStepInterpolator.java @@ -42,7 +42,6 @@ import org.apache.commons.math4.ode.sampling.StepInterpolator; * ] * </li> * </ul> - * </p> * * where θ belongs to [0 ; 1] and where y'<sub>1</sub> to y'<sub>4</sub> are the four * evaluations of the derivatives already computed during the http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54FieldIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54FieldIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54FieldIntegrator.java index 12d7a64..e6f0dbc 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54FieldIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54FieldIntegrator.java @@ -45,7 +45,7 @@ import org.apache.commons.math4.util.MathUtils; * J. R. Dormand and P. J. Prince * Journal of Computational and Applied Mathematics * volume 6, no 1, 1980, pp. 19-26 - * </pre></p> + * </pre> * * @param <T> the type of the field elements * @since 3.6 http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54Integrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54Integrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54Integrator.java index 731ea93..5b4342d 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54Integrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/DormandPrince54Integrator.java @@ -40,7 +40,7 @@ import org.apache.commons.math4.util.FastMath; * J. R. Dormand and P. J. Prince * Journal of Computational and Applied Mathematics * volume 6, no 1, 1980, pp. 19-26 - * </pre></p> + * </pre> * * @since 1.2 */ http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/EmbeddedRungeKuttaFieldIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/EmbeddedRungeKuttaFieldIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/EmbeddedRungeKuttaFieldIntegrator.java index 6238953..16d8243 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/EmbeddedRungeKuttaFieldIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/EmbeddedRungeKuttaFieldIntegrator.java @@ -47,7 +47,6 @@ import org.apache.commons.math4.util.MathUtils; * | b1 b2 ... bs-1 bs * | b'1 b'2 ... b's-1 b's * </pre> - * </p> * * <p>In fact, we rather use the array defined by ej = bj - b'j to * compute directly the error rather than computing two estimates and http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/EmbeddedRungeKuttaIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/EmbeddedRungeKuttaIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/EmbeddedRungeKuttaIntegrator.java index a82f168..82cdfba 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/EmbeddedRungeKuttaIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/EmbeddedRungeKuttaIntegrator.java @@ -41,7 +41,6 @@ import org.apache.commons.math4.util.FastMath; * | b1 b2 ... bs-1 bs * | b'1 b'2 ... b's-1 b's * </pre> - * </p> * * <p>In fact, we rather use the array defined by ej = bj - b'j to * compute directly the error rather than computing two estimates and http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/EulerFieldStepInterpolator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/EulerFieldStepInterpolator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/EulerFieldStepInterpolator.java index 43b8a53..2b084aa 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/EulerFieldStepInterpolator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/EulerFieldStepInterpolator.java @@ -36,7 +36,6 @@ import org.apache.commons.math4.ode.FieldODEStateAndDerivative; * y(t<sub>n</sub> + θ h) = y (t<sub>n</sub> + h) - (1-θ) h y' * </li> * </ul> - * </p> * * where θ belongs to [0 ; 1] and where y' is the evaluation of * the derivatives already computed during the step.</p> http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/EulerStepInterpolator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/EulerStepInterpolator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/EulerStepInterpolator.java index 74691b5..b693a9d 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/EulerStepInterpolator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/EulerStepInterpolator.java @@ -33,7 +33,6 @@ import org.apache.commons.math4.ode.sampling.StepInterpolator; * y(t<sub>n</sub> + θ h) = y (t<sub>n</sub> + h) - (1-θ) h y' * </li> * </ul> - * </p> * * where θ belongs to [0 ; 1] and where y' is the evaluation of * the derivatives already computed during the step.</p> http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/GillFieldIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/GillFieldIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/GillFieldIntegrator.java index 0ee8b5d..e4a1294 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/GillFieldIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/GillFieldIntegrator.java @@ -38,7 +38,7 @@ import org.apache.commons.math4.util.MathArrays; * |------------------------------- * | 1/6 (2-q)/6 (2+q)/6 1/6 * </pre> - * where q = sqrt(2)</p> + * where q = sqrt(2) * * @see EulerFieldIntegrator * @see ClassicalRungeKuttaFieldIntegrator http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/GillFieldStepInterpolator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/GillFieldStepInterpolator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/GillFieldStepInterpolator.java index df47430..cbbffbf 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/GillFieldStepInterpolator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/GillFieldStepInterpolator.java @@ -45,7 +45,6 @@ import org.apache.commons.math4.ode.FieldODEStateAndDerivative; * ] * </li> * </ul> - * </p> * where θ belongs to [0 ; 1] and where y'<sub>1</sub> to y'<sub>4</sub> * are the four evaluations of the derivatives already computed during * the step.</p> http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/GillIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/GillIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/GillIntegrator.java index 1ebc48f..3da4483 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/GillIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/GillIntegrator.java @@ -34,7 +34,7 @@ import org.apache.commons.math4.util.FastMath; * |------------------------------- * | 1/6 (2-q)/6 (2+q)/6 1/6 * </pre> - * where q = sqrt(2)</p> + * where q = sqrt(2) * * @see EulerIntegrator * @see ClassicalRungeKuttaIntegrator http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/GillStepInterpolator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/GillStepInterpolator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/GillStepInterpolator.java index 435c5b2..033c367 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/GillStepInterpolator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/GillStepInterpolator.java @@ -43,7 +43,6 @@ import org.apache.commons.math4.util.FastMath; * ] * </li> * </ul> - * </p> * where θ belongs to [0 ; 1] and where y'<sub>1</sub> to y'<sub>4</sub> * are the four evaluations of the derivatives already computed during * the step.</p> http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/GraggBulirschStoerIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/GraggBulirschStoerIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/GraggBulirschStoerIntegrator.java index 47defd2..410dfa8 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/GraggBulirschStoerIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/GraggBulirschStoerIntegrator.java @@ -61,9 +61,8 @@ import org.apache.commons.math4.util.FastMath; * for this code is available <a * href="http://www.unige.ch/~hairer/prog/licence.txt";>here</a>, for * convenience, it is reproduced below.</p> - * </p> * - * <table border="0" width="80%" cellpadding="10" align="center" bgcolor="#E0E0E0"> + * <table border="0" width="80%" cellpadding="10" style="text-align: center; background-color: #E0E0E0" summary="odex redistribution policy"> * <tr><td>Copyright (c) 2004, Ernst Hairer</td></tr> * * <tr><td>Redistribution and use in source and binary forms, with or @@ -240,13 +239,13 @@ public class GraggBulirschStoerIntegrator extends AdaptiveStepsizeIntegrator { * </pre> * where err is the scaled error and k the iteration number of the * extrapolation scheme (counting from 0). The default values are - * 0.65 for stepControl1 and 0.94 for stepControl2.</p> + * 0.65 for stepControl1 and 0.94 for stepControl2. * <p>The step size is subject to the restriction: * <pre> - * stepControl3^(1/(2k+1))/stepControl4 <= hNew/h <= 1/stepControl3^(1/(2k+1)) + * stepControl3^(1/(2k+1))/stepControl4 <= hNew/h <= 1/stepControl3^(1/(2k+1)) * </pre> * The default values are 0.02 for stepControl3 and 4.0 for - * stepControl4.</p> + * stepControl4. * @param control1 first stepsize control factor (the factor is * reset to default if lower than 0.0001 or greater than 0.9999) * @param control2 second stepsize control factor (the factor @@ -292,8 +291,8 @@ public class GraggBulirschStoerIntegrator extends AdaptiveStepsizeIntegrator { * maximal order that will be used is always even, it is twice the * maximal number of columns in the extrapolation table.</p> * <pre> - * order is decreased if w(k-1) <= w(k) * orderControl1 - * order is increased if w(k) <= w(k-1) * orderControl2 + * order is decreased if w(k-1) <= w(k) * orderControl1 + * order is increased if w(k) <= w(k-1) * orderControl2 * </pre> * <p>where w is the table of work per unit step for each order * (number of function calls divided by the step length), and k is @@ -302,7 +301,7 @@ public class GraggBulirschStoerIntegrator extends AdaptiveStepsizeIntegrator { * maximal number of columns is 9). The default values are 0.8 for * orderControl1 and 0.9 for orderControl2.</p> * @param maximalOrder maximal order in the extrapolation table (the - * maximal order is reset to default if order <= 6 or odd) + * maximal order is reset to default if order <= 6 or odd) * @param control1 first order control factor (the factor is * reset to default if lower than 0.0001 or greater than 0.9999) * @param control2 second order control factor (the factor @@ -403,7 +402,7 @@ public class GraggBulirschStoerIntegrator extends AdaptiveStepsizeIntegrator { * @param useInterpolationErrorForControl if true, interpolation error is used * for stepsize control * @param mudifControlParameter interpolation order control parameter (the parameter - * is reset to default if <= 0 or >= 7) + * is reset to default if <= 0 or >= 7) */ public void setInterpolationControl(final boolean useInterpolationErrorForControl, final int mudifControlParameter) { http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/LutherFieldIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/LutherFieldIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/LutherFieldIntegrator.java index b3c1424..c6b2cee 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/LutherFieldIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/LutherFieldIntegrator.java @@ -47,7 +47,7 @@ import org.apache.commons.math4.util.MathArrays; * |-------------------------------------------------------------------------------------------------------------------------------------------------- * | 1/20 0 16/45 0 49/180 49/180 1/20 * </pre> - * where q = √21</p> + * where q = √21 * * @see EulerFieldIntegrator * @see ClassicalRungeKuttaFieldIntegrator http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/LutherIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/LutherIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/LutherIntegrator.java index 631d6b2..3154999 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/LutherIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/LutherIntegrator.java @@ -43,7 +43,7 @@ import org.apache.commons.math4.util.FastMath; * |-------------------------------------------------------------------------------------------------------------------------------------------------- * | 1/20 0 16/45 0 49/180 49/180 1/20 * </pre> - * where q = √21</p> + * where q = √21 * * @see EulerIntegrator * @see ClassicalRungeKuttaIntegrator http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldIntegrator.java index 3b604e3..06db924 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldIntegrator.java @@ -35,7 +35,6 @@ import org.apache.commons.math4.util.MathArrays; * |---------- * | 0 1 * </pre> - * </p> * * @see EulerFieldIntegrator * @see ClassicalRungeKuttaFieldIntegrator http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldStepInterpolator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldStepInterpolator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldStepInterpolator.java index f64012e..1222529 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldStepInterpolator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointFieldStepInterpolator.java @@ -37,7 +37,6 @@ import org.apache.commons.math4.ode.FieldODEStateAndDerivative; * y(t<sub>n</sub> + θ h) = y (t<sub>n</sub> + h) + (1-θ) h [θ y'<sub>1</sub> - (1+θ) y'<sub>2</sub>] * </li> * </ul> - * </p> * * where θ belongs to [0 ; 1] and where y'<sub>1</sub> and y'<sub>2</sub> are the two * evaluations of the derivatives already computed during the http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointIntegrator.java index ff41520..4abbebf 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointIntegrator.java @@ -30,7 +30,6 @@ package org.apache.commons.math4.ode.nonstiff; * |---------- * | 0 1 * </pre> - * </p> * * @see EulerIntegrator * @see ClassicalRungeKuttaIntegrator http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointStepInterpolator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointStepInterpolator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointStepInterpolator.java index 45014bb..96446b2 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointStepInterpolator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/MidpointStepInterpolator.java @@ -34,7 +34,6 @@ import org.apache.commons.math4.ode.sampling.StepInterpolator; * y(t<sub>n</sub> + θ h) = y (t<sub>n</sub> + h) + (1-θ) h [θ y'<sub>1</sub> - (1+θ) y'<sub>2</sub>] * </li> * </ul> - * </p> * * where θ belongs to [0 ; 1] and where y'<sub>1</sub> and y'<sub>2</sub> are the two * evaluations of the derivatives already computed during the http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/RungeKuttaFieldIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/RungeKuttaFieldIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/RungeKuttaFieldIntegrator.java index f07bbae..dc7714e 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/RungeKuttaFieldIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/RungeKuttaFieldIntegrator.java @@ -47,7 +47,6 @@ import org.apache.commons.math4.util.MathArrays; * |-------------------------- * | b1 b2 ... bs-1 bs * </pre> - * </p> * * @see EulerFieldIntegrator * @see ClassicalRungeKuttaFieldIntegrator http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/RungeKuttaIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/RungeKuttaIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/RungeKuttaIntegrator.java index 4b8b6c3..71aff79 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/RungeKuttaIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/RungeKuttaIntegrator.java @@ -42,7 +42,6 @@ import org.apache.commons.math4.util.FastMath; * |-------------------------- * | b1 b2 ... bs-1 bs * </pre> - * </p> * * @see EulerIntegrator * @see ClassicalRungeKuttaIntegrator http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldIntegrator.java index 8169d75..979bb1e 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldIntegrator.java @@ -37,7 +37,6 @@ import org.apache.commons.math4.util.MathArrays; * |-------------------- * | 1/8 3/8 3/8 1/8 * </pre> - * </p> * * @see EulerFieldIntegrator * @see ClassicalRungeKuttaFieldIntegrator http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldStepInterpolator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldStepInterpolator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldStepInterpolator.java index b41f91a..17d41cd 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldStepInterpolator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesFieldStepInterpolator.java @@ -47,7 +47,6 @@ import org.apache.commons.math4.ode.FieldODEStateAndDerivative; * ] * </li> * </ul> - * </p> * * where θ belongs to [0 ; 1] and where y'<sub>1</sub> to y'<sub>4</sub> are the four * evaluations of the derivatives already computed during the http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesIntegrator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesIntegrator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesIntegrator.java index cb14511..1250686 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesIntegrator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesIntegrator.java @@ -32,7 +32,6 @@ package org.apache.commons.math4.ode.nonstiff; * |-------------------- * | 1/8 3/8 3/8 1/8 * </pre> - * </p> * * @see EulerIntegrator * @see ClassicalRungeKuttaIntegrator http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesStepInterpolator.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesStepInterpolator.java b/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesStepInterpolator.java index c5a20e0..b94b61c 100644 --- a/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesStepInterpolator.java +++ b/src/main/java/org/apache/commons/math4/ode/nonstiff/ThreeEighthesStepInterpolator.java @@ -44,7 +44,6 @@ import org.apache.commons.math4.ode.sampling.StepInterpolator; * ] * </li> * </ul> - * </p> * * where θ belongs to [0 ; 1] and where y'<sub>1</sub> to y'<sub>4</sub> are the four * evaluations of the derivatives already computed during the http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/package-info.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/package-info.java b/src/main/java/org/apache/commons/math4/ode/package-info.java index 106a757..f905d77 100644 --- a/src/main/java/org/apache/commons/math4/ode/package-info.java +++ b/src/main/java/org/apache/commons/math4/ode/package-info.java @@ -127,10 +127,9 @@ * automatic guess is wrong. * </p> * - * <p> - * <table border="1" align="center"> - * <tr BGCOLOR="#CCCCFF"><td colspan=2><font size="+2">Fixed Step Integrators</font></td></tr> - * <tr BGCOLOR="#EEEEFF"><font size="+1"><td>Name</td><td>Order</td></font></tr> + * <table border="1" style="text-align: center" summary="Fixed Step Integrators"> + * <tr style="background-color: #CCCCFF"><td colspan=2 style="font-size: x-large">Fixed Step Integrators</td></tr> + * <tr style="background-color: #EEEEFF; font-size: larger"><td>Name</td><td>Order</td></tr> * <tr><td>{@link org.apache.commons.math4.ode.nonstiff.EulerIntegrator Euler}</td><td>1</td></tr> * <tr><td>{@link org.apache.commons.math4.ode.nonstiff.MidpointIntegrator Midpoint}</td><td>2</td></tr> * <tr><td>{@link org.apache.commons.math4.ode.nonstiff.ClassicalRungeKuttaIntegrator Classical Runge-Kutta}</td><td>4</td></tr> @@ -138,11 +137,10 @@ * <tr><td>{@link org.apache.commons.math4.ode.nonstiff.ThreeEighthesIntegrator 3/8}</td><td>4</td></tr> * <tr><td>{@link org.apache.commons.math4.ode.nonstiff.LutherIntegrator Luther}</td><td>6</td></tr> * </table> - * </p> * - * <table border="1" align="center"> - * <tr BGCOLOR="#CCCCFF"><td colspan=3><font size="+2">Adaptive Stepsize Integrators</font></td></tr> - * <tr BGCOLOR="#EEEEFF"><font size="+1"><td>Name</td><td>Integration Order</td><td>Error Estimation Order</td></font></tr> + * <table border="1" style="text-align: center" summary="Adaptive Stepsize Integrators"> + * <tr style="background-color: #CCCCFF"><td colspan=3 style="font-size: x-large">Adaptive Stepsize Integrators</td></tr> + * <tr style="background-color: #EEEEFF; font-size: larger"><td>Name</td><td>Integration Order</td><td>Error Estimation Order</td></tr> * <tr><td>{@link org.apache.commons.math4.ode.nonstiff.HighamHall54Integrator Higham and Hall}</td><td>5</td><td>4</td></tr> * <tr><td>{@link org.apache.commons.math4.ode.nonstiff.DormandPrince54Integrator Dormand-Prince 5(4)}</td><td>5</td><td>4</td></tr> * <tr><td>{@link org.apache.commons.math4.ode.nonstiff.DormandPrince853Integrator Dormand-Prince 8(5,3)}</td><td>8</td><td>5 and 3</td></tr> @@ -150,7 +148,6 @@ * <tr><td>{@link org.apache.commons.math4.ode.nonstiff.AdamsBashforthIntegrator Adams-Bashforth}</td><td>variable</td><td>variable</td></tr> * <tr><td>{@link org.apache.commons.math4.ode.nonstiff.AdamsMoultonIntegrator Adams-Moulton}</td><td>variable</td><td>variable</td></tr> * </table> - * </p> * * <p> * In the table above, the {@link org.apache.commons.math4.ode.nonstiff.AdamsBashforthIntegrator http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/sampling/FieldStepNormalizer.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/sampling/FieldStepNormalizer.java b/src/main/java/org/apache/commons/math4/ode/sampling/FieldStepNormalizer.java index bee9b1b..4729e17 100644 --- a/src/main/java/org/apache/commons/math4/ode/sampling/FieldStepNormalizer.java +++ b/src/main/java/org/apache/commons/math4/ode/sampling/FieldStepNormalizer.java @@ -42,12 +42,11 @@ import org.apache.commons.numbers.core.Precision; * it needs (time steps longer or shorter than the fixed time step and * non-integer ratios are all allowed).</p> * - * <p> - * <table border="1" align="center"> - * <tr BGCOLOR="#CCCCFF"><td colspan=6><font size="+2">Examples (step size = 0.5)</font></td></tr> - * <tr BGCOLOR="#EEEEFF"><font size="+1"><td>Start time</td><td>End time</td> + * <table border="1" style="text-align: center" summary="Examples (step size = 0.5)"> + * <tr style="background-color: #CCCCFF"><td colspan=6 style="font-size: x-large">Examples (step size = 0.5)</td></tr> + * <tr style="background-color: #EEEEFF; font-size: large"><td>Start time</td><td>End time</td> * <td>Direction</td><td>{@link StepNormalizerMode Mode}</td> - * <td>{@link StepNormalizerBounds Bounds}</td><td>Output</td></font></tr> + * <td>{@link StepNormalizerBounds Bounds}</td><td>Output</td></tr> * <tr><td>0.3</td><td>3.1</td><td>forward</td><td>{@link StepNormalizerMode#INCREMENT INCREMENT}</td><td>{@link StepNormalizerBounds#NEITHER NEITHER}</td><td>0.8, 1.3, 1.8, 2.3, 2.8</td></tr> * <tr><td>0.3</td><td>3.1</td><td>forward</td><td>{@link StepNormalizerMode#INCREMENT INCREMENT}</td><td>{@link StepNormalizerBounds#FIRST FIRST}</td><td>0.3, 0.8, 1.3, 1.8, 2.3, 2.8</td></tr> * <tr><td>0.3</td><td>3.1</td><td>forward</td><td>{@link StepNormalizerMode#INCREMENT INCREMENT}</td><td>{@link StepNormalizerBounds#LAST LAST}</td><td>0.8, 1.3, 1.8, 2.3, 2.8, 3.1</td></tr> @@ -81,7 +80,6 @@ import org.apache.commons.numbers.core.Precision; * <tr><td>3.0</td><td>0.0</td><td>backward</td><td>{@link StepNormalizerMode#MULTIPLES MULTIPLES}</td><td>{@link StepNormalizerBounds#LAST LAST}</td><td>2.5, 2.0, 1.5, 1.0, 0.5, 0.0</td></tr> * <tr><td>3.0</td><td>0.0</td><td>backward</td><td>{@link StepNormalizerMode#MULTIPLES MULTIPLES}</td><td>{@link StepNormalizerBounds#BOTH BOTH}</td><td>3.0, 2.5, 2.0, 1.5, 1.0, 0.5, 0.0</td></tr> * </table> - * </p> * * @param <T> the type of the field elements * @see FieldStepHandler http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/ode/sampling/StepNormalizer.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/ode/sampling/StepNormalizer.java b/src/main/java/org/apache/commons/math4/ode/sampling/StepNormalizer.java index edec00c..b9b5140 100644 --- a/src/main/java/org/apache/commons/math4/ode/sampling/StepNormalizer.java +++ b/src/main/java/org/apache/commons/math4/ode/sampling/StepNormalizer.java @@ -40,12 +40,11 @@ import org.apache.commons.numbers.core.Precision; * it needs (time steps longer or shorter than the fixed time step and * non-integer ratios are all allowed).</p> * - * <p> - * <table border="1" align="center"> - * <tr BGCOLOR="#CCCCFF"><td colspan=6><font size="+2">Examples (step size = 0.5)</font></td></tr> - * <tr BGCOLOR="#EEEEFF"><font size="+1"><td>Start time</td><td>End time</td> + * <table border="1" style="text-align: center" summary="Examples (step size = 0.5)"> + * <tr style="background-color: #CCCCFF"><td style="font-size: x-large">Examples (step size = 0.5)</td></tr> + * <tr style="background-color: #EEEEFF; font-size: large"><td>Start time</td><td>End time</td> * <td>Direction</td><td>{@link StepNormalizerMode Mode}</td> - * <td>{@link StepNormalizerBounds Bounds}</td><td>Output</td></font></tr> + * <td>{@link StepNormalizerBounds Bounds}</td><td>Output</td></tr> * <tr><td>0.3</td><td>3.1</td><td>forward</td><td>{@link StepNormalizerMode#INCREMENT INCREMENT}</td><td>{@link StepNormalizerBounds#NEITHER NEITHER}</td><td>0.8, 1.3, 1.8, 2.3, 2.8</td></tr> * <tr><td>0.3</td><td>3.1</td><td>forward</td><td>{@link StepNormalizerMode#INCREMENT INCREMENT}</td><td>{@link StepNormalizerBounds#FIRST FIRST}</td><td>0.3, 0.8, 1.3, 1.8, 2.3, 2.8</td></tr> * <tr><td>0.3</td><td>3.1</td><td>forward</td><td>{@link StepNormalizerMode#INCREMENT INCREMENT}</td><td>{@link StepNormalizerBounds#LAST LAST}</td><td>0.8, 1.3, 1.8, 2.3, 2.8, 3.1</td></tr> @@ -79,7 +78,6 @@ import org.apache.commons.numbers.core.Precision; * <tr><td>3.0</td><td>0.0</td><td>backward</td><td>{@link StepNormalizerMode#MULTIPLES MULTIPLES}</td><td>{@link StepNormalizerBounds#LAST LAST}</td><td>2.5, 2.0, 1.5, 1.0, 0.5, 0.0</td></tr> * <tr><td>3.0</td><td>0.0</td><td>backward</td><td>{@link StepNormalizerMode#MULTIPLES MULTIPLES}</td><td>{@link StepNormalizerBounds#BOTH BOTH}</td><td>3.0, 2.5, 2.0, 1.5, 1.0, 0.5, 0.0</td></tr> * </table> - * </p> * * @see StepHandler * @see FixedStepHandler http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/optim/BaseMultiStartMultivariateOptimizer.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optim/BaseMultiStartMultivariateOptimizer.java b/src/main/java/org/apache/commons/math4/optim/BaseMultiStartMultivariateOptimizer.java index 4ceab3e..937ff50 100644 --- a/src/main/java/org/apache/commons/math4/optim/BaseMultiStartMultivariateOptimizer.java +++ b/src/main/java/org/apache/commons/math4/optim/BaseMultiStartMultivariateOptimizer.java @@ -23,7 +23,7 @@ import org.apache.commons.math4.random.RandomVectorGenerator; /** * Base class multi-start optimizer for a multivariate function. - * <br/> + * <br> * This class wraps an optimizer in order to use it several times in * turn with different starting points (trying to avoid being trapped * in a local extremum when looking for a global one). @@ -101,7 +101,7 @@ public abstract class BaseMultiStartMultivariateOptimizer<PAIR> * restarts. The {@code optimize} method returns the best point only. * This method returns all the points found at the end of each starts, * including the best one already returned by the {@code optimize} method. - * <br/> + * <br> * The returned array as one element for each start as specified * in the constructor. It is ordered with the results from the * runs that did converge first, sorted from best to worst @@ -112,7 +112,7 @@ public abstract class BaseMultiStartMultivariateOptimizer<PAIR> * an exception. * This also means that if the first element is not {@code null}, it is * the best point found across all starts. - * <br/> + * <br> * The behaviour is undefined if this method is called before * {@code optimize}; it will likely throw {@code NullPointerException}. * http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/optim/ConvergenceChecker.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optim/ConvergenceChecker.java b/src/main/java/org/apache/commons/math4/optim/ConvergenceChecker.java index b61e419..c8507f5 100644 --- a/src/main/java/org/apache/commons/math4/optim/ConvergenceChecker.java +++ b/src/main/java/org/apache/commons/math4/optim/ConvergenceChecker.java @@ -20,11 +20,11 @@ package org.apache.commons.math4.optim; /** * This interface specifies how to check if an optimization algorithm has * converged. - * <br/> + * <br> * Deciding if convergence has been reached is a problem-dependent issue. The * user should provide a class implementing this interface to allow the * optimization algorithm to stop its search according to the problem at hand. - * <br/> + * <br> * For convenience, three implementations that fit simple needs are already * provided: {@link SimpleValueChecker}, {@link SimpleVectorValueChecker} and * {@link SimplePointChecker}. The first two consider that convergence is http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/optim/InitialGuess.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optim/InitialGuess.java b/src/main/java/org/apache/commons/math4/optim/InitialGuess.java index d1d8fe0..3377013 100644 --- a/src/main/java/org/apache/commons/math4/optim/InitialGuess.java +++ b/src/main/java/org/apache/commons/math4/optim/InitialGuess.java @@ -19,7 +19,7 @@ package org.apache.commons.math4.optim; /** * Starting point (first guess) of the optimization procedure. - * <br/> + * <br> * Immutable class. * * @since 3.1 http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/optim/SimpleBounds.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optim/SimpleBounds.java b/src/main/java/org/apache/commons/math4/optim/SimpleBounds.java index c166341..7922d5a 100644 --- a/src/main/java/org/apache/commons/math4/optim/SimpleBounds.java +++ b/src/main/java/org/apache/commons/math4/optim/SimpleBounds.java @@ -22,7 +22,7 @@ import java.util.Arrays; * Simple optimization constraints: lower and upper bounds. * The valid range of the parameters is an interval that can be infinite * (in one or both directions). - * <br/> + * <br> * Immutable class. * * @since 3.1 http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/optim/SimplePointChecker.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optim/SimplePointChecker.java b/src/main/java/org/apache/commons/math4/optim/SimplePointChecker.java index e1463c9..6bb1800 100644 --- a/src/main/java/org/apache/commons/math4/optim/SimplePointChecker.java +++ b/src/main/java/org/apache/commons/math4/optim/SimplePointChecker.java @@ -28,7 +28,7 @@ import org.apache.commons.math4.util.Pair; * difference between each point coordinate are smaller than a threshold * or if either the absolute difference between the point coordinates are * smaller than another threshold. - * <br/> + * <br> * The {@link #converged(int,Pair,Pair) converged} method will also return * {@code true} if the number of iterations has been set (see * {@link #SimplePointChecker(double,double,int) this constructor}). http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/optim/SimpleValueChecker.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optim/SimpleValueChecker.java b/src/main/java/org/apache/commons/math4/optim/SimpleValueChecker.java index a62c8ca..9e1379a 100644 --- a/src/main/java/org/apache/commons/math4/optim/SimpleValueChecker.java +++ b/src/main/java/org/apache/commons/math4/optim/SimpleValueChecker.java @@ -28,7 +28,7 @@ import org.apache.commons.math4.util.FastMath; * difference between the objective function values is smaller than a * threshold or if either the absolute difference between the objective * function values is smaller than another threshold. - * <br/> + * <br> * The {@link #converged(int,PointValuePair,PointValuePair) converged} * method will also return {@code true} if the number of iterations has been set * (see {@link #SimpleValueChecker(double,double,int) this constructor}). http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/optim/SimpleVectorValueChecker.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optim/SimpleVectorValueChecker.java b/src/main/java/org/apache/commons/math4/optim/SimpleVectorValueChecker.java index 460fb38..7d31520 100644 --- a/src/main/java/org/apache/commons/math4/optim/SimpleVectorValueChecker.java +++ b/src/main/java/org/apache/commons/math4/optim/SimpleVectorValueChecker.java @@ -28,7 +28,7 @@ import org.apache.commons.math4.util.FastMath; * difference between the objective function values is smaller than a * threshold or if either the absolute difference between the objective * function values is smaller than another threshold for all vectors elements. - * <br/> + * <br> * The {@link #converged(int,PointVectorValuePair,PointVectorValuePair) converged} * method will also return {@code true} if the number of iterations has been set * (see {@link #SimpleVectorValueChecker(double,double,int) this constructor}). http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/optim/linear/LinearConstraint.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optim/linear/LinearConstraint.java b/src/main/java/org/apache/commons/math4/optim/linear/LinearConstraint.java index 8e804e8..bd4b0b8 100644 --- a/src/main/java/org/apache/commons/math4/optim/linear/LinearConstraint.java +++ b/src/main/java/org/apache/commons/math4/optim/linear/LinearConstraint.java @@ -32,17 +32,16 @@ import org.apache.commons.math4.linear.RealVector; * <ul> * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> = v</li> * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> <= v</li> - * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> >= v</li> + * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> >= v</li> * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> = * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> <= * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> - * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> >= + * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> >= * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> * </ul> * The c<sub>i</sub>, l<sub>i</sub> or r<sub>i</sub> are the coefficients of the constraints, the x<sub>i</sub> * are the coordinates of the current point and v is the value of the constraint. - * </p> * * @since 2.0 */ @@ -63,9 +62,9 @@ public class LinearConstraint implements Serializable { * <ul> * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> = v</li> * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> <= v</li> - * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> >= v</li> + * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> >= v</li> * </ul> - * </p> + * * @param coefficients The coefficients of the constraint (left hand side) * @param relationship The type of (in)equality used in the constraint * @param value The value of the constraint (right hand side) @@ -83,9 +82,9 @@ public class LinearConstraint implements Serializable { * <ul> * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> = v</li> * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> <= v</li> - * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> >= v</li> + * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> >= v</li> * </ul> - * </p> + * * @param coefficients The coefficients of the constraint (left hand side) * @param relationship The type of (in)equality used in the constraint * @param value The value of the constraint (right hand side) @@ -107,10 +106,10 @@ public class LinearConstraint implements Serializable { * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> <= * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> - * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> >= + * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> >= * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> * </ul> - * </p> + * * @param lhsCoefficients The coefficients of the linear expression on the left hand side of the constraint * @param lhsConstant The constant term of the linear expression on the left hand side of the constraint * @param relationship The type of (in)equality used in the constraint @@ -138,10 +137,10 @@ public class LinearConstraint implements Serializable { * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> <= * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> - * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> >= + * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> >= * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> * </ul> - * </p> + * * @param lhsCoefficients The coefficients of the linear expression on the left hand side of the constraint * @param lhsConstant The constant term of the linear expression on the left hand side of the constraint * @param relationship The type of (in)equality used in the constraint http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/optim/linear/LinearObjectiveFunction.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optim/linear/LinearObjectiveFunction.java b/src/main/java/org/apache/commons/math4/optim/linear/LinearObjectiveFunction.java index 9bf1866..8a699fd 100644 --- a/src/main/java/org/apache/commons/math4/optim/linear/LinearObjectiveFunction.java +++ b/src/main/java/org/apache/commons/math4/optim/linear/LinearObjectiveFunction.java @@ -31,12 +31,11 @@ import org.apache.commons.math4.optim.OptimizationData; * An objective function for a linear optimization problem. * <p> * A linear objective function has one the form: - * <pre> + * <div style="white-space: pre"><code> * c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> + d - * </pre> + * </code></div> * The c<sub>i</sub> and d are the coefficients of the equation, * the x<sub>i</sub> are the coordinates of the current point. - * </p> * * @since 2.0 */ http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/optim/nonlinear/scalar/LeastSquaresConverter.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optim/nonlinear/scalar/LeastSquaresConverter.java b/src/main/java/org/apache/commons/math4/optim/nonlinear/scalar/LeastSquaresConverter.java index 3860cd5..98346ea 100644 --- a/src/main/java/org/apache/commons/math4/optim/nonlinear/scalar/LeastSquaresConverter.java +++ b/src/main/java/org/apache/commons/math4/optim/nonlinear/scalar/LeastSquaresConverter.java @@ -27,14 +27,14 @@ import org.apache.commons.math4.linear.RealMatrix; * {@link MultivariateVectorFunction vectorial objective functions} to * {@link MultivariateFunction scalar objective functions} * when the goal is to minimize them. - * <br/> + * <br> * This class is mostly used when the vectorial objective function represents * a theoretical result computed from a point set applied to a model and * the models point must be adjusted to fit the theoretical result to some * reference observations. The observations may be obtained for example from * physical measurements whether the model is built from theoretical * considerations. - * <br/> + * <br> * This class computes a possibly weighted squared sum of the residuals, which is * a scalar value. The residuals are the difference between the theoretical model * (i.e. the output of the vectorial objective function) and the observations. The @@ -43,7 +43,7 @@ import org.apache.commons.math4.linear.RealMatrix; * to perform a least square estimation. There are other ways to do this without using * this converter, as some optimization algorithms directly support vectorial objective * functions. - * <br/> + * <br> * This class support combination of residuals with or without weights and correlations. * * @see MultivariateFunction @@ -81,10 +81,10 @@ public class LeastSquaresConverter implements MultivariateFunction { * specified weights. * <p> * The scalar objective function value is computed as: - * <pre> + * <div style="white-space: pre"><code> * objective = ∑weight<sub>i</sub>(observation<sub>i</sub>-objective<sub>i</sub>)<sup>2</sup> - * </pre> - * </p> + * </code></div> + * * <p> * Weights can be used for example to combine residuals with different standard * deviations. As an example, consider a residuals array in which even elements @@ -124,10 +124,10 @@ public class LeastSquaresConverter implements MultivariateFunction { * specified weights. * <p> * The scalar objective function value is computed as: - * <pre> + * <div style="white-space: pre"><code> * objective = y<sup>T</sup>y with y = scale×(observation-objective) - * </pre> - * </p> + * </code></div> + * * <p> * The array computed by the objective function, the observations array and the * the scaling matrix must have consistent sizes or a {@link DimensionMismatchException} http://git-wip-us.apache.org/repos/asf/commons-math/blob/53ec46ba/src/main/java/org/apache/commons/math4/optim/nonlinear/scalar/MultivariateFunctionPenaltyAdapter.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optim/nonlinear/scalar/MultivariateFunctionPenaltyAdapter.java b/src/main/java/org/apache/commons/math4/optim/nonlinear/scalar/MultivariateFunctionPenaltyAdapter.java index 33bb852..37fe24d 100644 --- a/src/main/java/org/apache/commons/math4/optim/nonlinear/scalar/MultivariateFunctionPenaltyAdapter.java +++ b/src/main/java/org/apache/commons/math4/optim/nonlinear/scalar/MultivariateFunctionPenaltyAdapter.java @@ -85,11 +85,11 @@ public class MultivariateFunctionPenaltyAdapter * function. In order for this penalty to be effective in rejecting this * point during the optimization process, the penalty function value should * be defined with care. This value is computed as: - * <pre> + * <div style="white-space: pre"><code> * penalty(point) = offset + ∑<sub>i</sub>[scale[i] * √|point[i]-boundary[i]|] - * </pre> + * </code></div> * where indices i correspond to all the components that violates their boundaries. - * </p> + * * <p> * So when attempting a function minimization, offset should be larger than * the maximum expected value of the underlying function and scale components
