You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by ra...@apache.org on 2017/05/07 16:36:55 UTC
[4/5] [math] Fix some javadoc issues.
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