This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
The following commit(s) were added to refs/heads/master by this push:
new 03bbf4a3 Fix malformed Javadoc comments
03bbf4a3 is described below
commit 03bbf4a36487db39dcd5d2635f11120bae1efdae
Author: Gary Gregory <[email protected]>
AuthorDate: Sat Dec 13 15:48:05 2025 -0500
Fix malformed Javadoc comments
---
.../commons/numbers/arrays/IndexSupport.java | 8 +-
.../numbers/arrays/KeyUpdatingInterval.java | 6 +-
.../apache/commons/numbers/arrays/QuickSelect.java | 16 +-
.../apache/commons/numbers/arrays/Selection.java | 22 +-
.../commons/numbers/arrays/UpdatingInterval.java | 6 +-
.../commons/numbers/combinatorics/Stirling.java | 6 +-
.../apache/commons/numbers/complex/Complex.java | 316 ++++++++++-----------
.../commons/numbers/core/ArithmeticUtils.java | 30 +-
.../java/org/apache/commons/numbers/core/DD.java | 122 ++++----
.../org/apache/commons/numbers/core/DDMath.java | 10 +-
.../commons/numbers/core/ExtendedPrecision.java | 4 +-
.../org/apache/commons/numbers/core/Precision.java | 24 +-
.../examples/jmh/arrays/DualPivotingStrategy.java | 6 +-
.../examples/jmh/arrays/IntervalAnalysis.java | 4 +-
.../numbers/examples/jmh/arrays/KthSelector.java | 16 +-
.../numbers/examples/jmh/arrays/Partition.java | 82 +++---
.../examples/jmh/arrays/PartitionFactory.java | 40 +--
.../numbers/examples/jmh/arrays/PivotCache.java | 10 +-
.../examples/jmh/arrays/PivotingStrategy.java | 6 +-
.../examples/jmh/arrays/SearchableInterval.java | 6 +-
.../examples/jmh/arrays/SearchableInterval2.java | 8 +-
.../examples/jmh/arrays/SelectionPerformance.java | 14 +-
.../examples/jmh/arrays/SplittingInterval.java | 4 +-
.../examples/jmh/arrays/UpdatingInterval.java | 6 +-
.../numbers/examples/jmh/core/DoublePrecision.java | 28 +-
.../jmh/core/KolmogorovSmirnovDistribution.java | 4 +-
.../commons/numbers/examples/jmh/core/SDD.java | 38 +--
.../commons/numbers/fraction/BigFraction.java | 10 +-
.../apache/commons/numbers/fraction/Fraction.java | 10 +-
.../fraction/GeneralizedContinuedFraction.java | 18 +-
.../java/org/apache/commons/numbers/gamma/Erf.java | 8 +-
.../org/apache/commons/numbers/gamma/Erfc.java | 8 +-
.../org/apache/commons/numbers/gamma/Erfcx.java | 8 +-
.../org/apache/commons/numbers/gamma/Gamma.java | 4 +-
.../apache/commons/numbers/gamma/GammaRatio.java | 2 +-
.../apache/commons/numbers/gamma/InverseErf.java | 10 +-
.../apache/commons/numbers/gamma/InverseErfc.java | 10 +-
37 files changed, 465 insertions(+), 465 deletions(-)
diff --git
a/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/IndexSupport.java
b/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/IndexSupport.java
index f62818d7..18c2d61d 100644
---
a/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/IndexSupport.java
+++
b/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/IndexSupport.java
@@ -252,10 +252,10 @@ final class IndexSupport {
* <p>The sub-range is defined to be out of bounds if any of the following
* inequalities is true:
* <ul>
- * <li>{@code fromIndex < 0}
- * <li>{@code fromIndex > toIndex}
- * <li>{@code toIndex > length}
- * <li>{@code length < 0}, which is implied from the former inequalities
+ * <li>{@code fromIndex < 0}</li>
+ * <li>{@code fromIndex > toIndex}</li>
+ * <li>{@code toIndex > length}</li>
+ * <li>{@code length < 0}, which is implied from the former
inequalities</li>
* </ul>
*
* @param fromIndex Lower-bound (inclusive) of the sub-range.
diff --git
a/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/KeyUpdatingInterval.java
b/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/KeyUpdatingInterval.java
index 3ade5cb7..aa07c29a 100644
---
a/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/KeyUpdatingInterval.java
+++
b/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/KeyUpdatingInterval.java
@@ -143,10 +143,10 @@ final class KeyUpdatingInterval implements
UpdatingInterval {
* <p>This is similar to using {@link java.util.Arrays#binarySearch(int[],
int, int, int)
* Arrays.binarySearch}. The method differs in:
* <ul>
- * <li>use of an inclusive upper bound;
- * <li>returning the closest index with a value below {@code key} if no
match was not found;
+ * <li>use of an inclusive upper bound;</li>
+ * <li>returning the closest index with a value below {@code key} if no
match was not found;</li>
* <li>performing no range checks: it is assumed {@code left <= right} and
they are valid
- * indices into the array.
+ * indices into the array.</li>
* </ul>
*
* <p>An equivalent use of binary search is:
diff --git
a/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/QuickSelect.java
b/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/QuickSelect.java
index 894f9f69..aa7adbb0 100644
---
a/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/QuickSelect.java
+++
b/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/QuickSelect.java
@@ -1276,10 +1276,10 @@ final class QuickSelect {
* }</pre>
*
* <ul>
- * <li>k0: lower pivot1 point
- * <li>k1: upper pivot1 point (inclusive)
- * <li>k2: lower pivot2 point
- * <li>k3: upper pivot2 point (inclusive)
+ * <li>k0: lower pivot1 point</li>
+ * <li>k1: upper pivot1 point (inclusive)</li>
+ * <li>k2: lower pivot2 point</li>
+ * <li>k3: upper pivot2 point (inclusive)</li>
* </ul>
*
* <p>Bounds are set so {@code i < k0}, {@code i > k3} and {@code k1 < i <
k2} are
@@ -2535,10 +2535,10 @@ final class QuickSelect {
* }</pre>
*
* <ul>
- * <li>k0: lower pivot1 point
- * <li>k1: upper pivot1 point (inclusive)
- * <li>k2: lower pivot2 point
- * <li>k3: upper pivot2 point (inclusive)
+ * <li>k0: lower pivot1 point</li>
+ * <li>k1: upper pivot1 point (inclusive)</li>
+ * <li>k2: lower pivot2 point</li>
+ * <li>k3: upper pivot2 point (inclusive)</li>
* </ul>
*
* <p>Bounds are set so {@code i < k0}, {@code i > k3} and {@code k1 < i <
k2} are
diff --git
a/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/Selection.java
b/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/Selection.java
index 21c7dfcf..ec77017b 100644
---
a/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/Selection.java
+++
b/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/Selection.java
@@ -91,29 +91,29 @@ package org.apache.commons.numbers.arrays;
* <ol>
* <li>Hoare (1961)
* Algorithm 65: Find
- * <a href="https://doi.org/10.1145%2F366622.366647";>Comm. ACM. 4 (7):
321–322</a>
+ * <a href="https://doi.org/10.1145%2F366622.366647";>Comm. ACM. 4 (7):
321–322</a></li>
* <li>Musser (1999)
* Introspective Sorting and Selection Algorithms
* <a
href="https://doi.org/10.1002/(SICI)1097-024X(199708)27:8%3C983::AID-SPE117%3E3.0.CO;2-%23">
- * Software: Practice and Experience 27, 983-993.</a>
+ * Software: Practice and Experience 27, 983-993.</a></li>
* <li>Floyd and Rivest (1975)
* Algorithm 489: The Algorithm SELECT—for Finding the ith Smallest of n
elements.
- * Comm. ACM. 18 (3): 173.
+ * Comm. ACM. 18 (3): 173.</li>
* <li>Kiwiel (2005)
* On Floyd and Rivest's SELECT algorithm.
- * Theoretical Computer Science 347, 214-238.
+ * Theoretical Computer Science 347, 214-238.</li>
* <li>Blum, Floyd, Pratt, Rivest, and Tarjan (1973)
* Time bounds for selection.
* <a href="https://doi.org/10.1016%2FS0022-0000%2873%2980033-9";>
- * Journal of Computer and System Sciences. 7 (4): 448–461</a>.
+ * Journal of Computer and System Sciences. 7 (4): 448–461</a>.</li>
* <li>Alexandrescu (2016)
* Fast Deterministic Selection
- * <a href="https://arxiv.org/abs/1606.00484";>arXiv:1606.00484</a>.
- * <li><a href="https://en.wikipedia.org/wiki/Quickselect";>Quickselect
(Wikipedia)</a>
- * <li><a href="https://en.wikipedia.org/wiki/Introsort";>Introsort
(Wikipedia)</a>
- * <li><a href="https://en.wikipedia.org/wiki/Introselect";>Introselect
(Wikipedia)</a>
- * <li><a
href="https://en.wikipedia.org/wiki/Floyd%E2%80%93Rivest_algorithm";>Floyd-Rivest
algorithm (Wikipedia)</a>
- * <li><a href="https://en.wikipedia.org/wiki/Median_of_medians";>Median of
medians (Wikipedia)</a>
+ * <a href="https://arxiv.org/abs/1606.00484";>arXiv:1606.00484</a>.</li>
+ * <li><a href="https://en.wikipedia.org/wiki/Quickselect";>Quickselect
(Wikipedia)</a></li>
+ * <li><a href="https://en.wikipedia.org/wiki/Introsort";>Introsort
(Wikipedia)</a></li>
+ * <li><a href="https://en.wikipedia.org/wiki/Introselect";>Introselect
(Wikipedia)</a></li>
+ * <li><a
href="https://en.wikipedia.org/wiki/Floyd%E2%80%93Rivest_algorithm";>Floyd-Rivest
algorithm (Wikipedia)</a></li>
+ * <li><a href="https://en.wikipedia.org/wiki/Median_of_medians";>Median of
medians (Wikipedia)</a></li>
* </ol>
*
* @since 1.2
diff --git
a/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/UpdatingInterval.java
b/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/UpdatingInterval.java
index 5b8e82ff..c996f805 100644
---
a/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/UpdatingInterval.java
+++
b/commons-numbers-arrays/src/main/java/org/apache/commons/numbers/arrays/UpdatingInterval.java
@@ -22,9 +22,9 @@ package org.apache.commons.numbers.arrays;
* <p>The interval provides the following functionality:
*
* <ul>
- * <li>Return the supported bounds of the interval {@code [left <= right]}.
- * <li>Update the left or right bound of the interval using an index {@code k}
inside the interval.
- * <li>Split the interval around two indices {@code k1} and {@code k2}.
+ * <li>Return the supported bounds of the interval {@code [left <=
right]}.</li>
+ * <li>Update the left or right bound of the interval using an index {@code k}
inside the interval.</li>
+ * <li>Split the interval around two indices {@code k1} and {@code k2}.</li>
* </ul>
*
* <p>Note that the interval provides the supported bounds. If an search index
{@code k} is
diff --git
a/commons-numbers-combinatorics/src/main/java/org/apache/commons/numbers/combinatorics/Stirling.java
b/commons-numbers-combinatorics/src/main/java/org/apache/commons/numbers/combinatorics/Stirling.java
index 4415eafa..bad11ac5 100644
---
a/commons-numbers-combinatorics/src/main/java/org/apache/commons/numbers/combinatorics/Stirling.java
+++
b/commons-numbers-combinatorics/src/main/java/org/apache/commons/numbers/combinatorics/Stirling.java
@@ -271,9 +271,9 @@ public final class Stirling {
* Return {@code a*b/4} without intermediate overflow.
* It is assumed that:
* <ul>
- * <li>The coefficients a and b are positive
- * <li>The product (a*b) is an exact multiple of 4
- * <li>The result (a*b/4) is an exact integer that does not overflow a
{@code long}
+ * <li>The coefficients a and b are positive</li>
+ * <li>The product (a*b) is an exact multiple of 4</li>
+ * <li>The result (a*b/4) is an exact integer that does not overflow a
{@code long}</li>
* </ul>
*
* <p>A conditional branch is performed on the odd/even property of {@code
b}.
diff --git
a/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/Complex.java
b/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/Complex.java
index e22622a9..8f1e05f3 100644
---
a/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/Complex.java
+++
b/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/Complex.java
@@ -295,14 +295,14 @@ public final class Complex implements Serializable {
* following the rules for double arithmetic, for example:</p>
*
* <ul>
- * <li>{@code ofPolar(}\( -0.0 \){@code , }\( 0 \){@code ) = }\(
\text{NaN} + i \text{NaN} \)
- * <li>{@code ofPolar(}\( 0.0 \){@code , }\( 0 \){@code ) = }\( 0 + i 0 \)
- * <li>{@code ofPolar(}\( 1 \){@code , }\( 0 \){@code ) = }\( 1 + i 0 \)
- * <li>{@code ofPolar(}\( 1 \){@code , }\( \pi \){@code ) = }\( -1 + i
\sin(\pi) \)
- * <li>{@code ofPolar(}\( \infty \){@code , }\( \pi \){@code ) = }\(
-\infty + i \infty \)
- * <li>{@code ofPolar(}\( \infty \){@code , }\( 0 \){@code ) = }\( -\infty
+ i \text{NaN} \)
- * <li>{@code ofPolar(}\( \infty \){@code , }\( -\frac{\pi}{4} \){@code )
= }\( \infty - i \infty \)
- * <li>{@code ofPolar(}\( \infty \){@code , }\( 5\frac{\pi}{4} \){@code )
= }\( -\infty - i \infty \)
+ * <li>{@code ofPolar(}\( -0.0 \){@code , }\( 0 \){@code ) = }\(
\text{NaN} + i \text{NaN} \)</li>
+ * <li>{@code ofPolar(}\( 0.0 \){@code , }\( 0 \){@code ) = }\( 0 + i 0
\)</li>
+ * <li>{@code ofPolar(}\( 1 \){@code , }\( 0 \){@code ) = }\( 1 + i 0
\)</li>
+ * <li>{@code ofPolar(}\( 1 \){@code , }\( \pi \){@code ) = }\( -1 + i
\sin(\pi) \)</li>
+ * <li>{@code ofPolar(}\( \infty \){@code , }\( \pi \){@code ) = }\(
-\infty + i \infty \)</li>
+ * <li>{@code ofPolar(}\( \infty \){@code , }\( 0 \){@code ) = }\( -\infty
+ i \text{NaN} \)</li>
+ * <li>{@code ofPolar(}\( \infty \){@code , }\( -\frac{\pi}{4} \){@code )
= }\( \infty - i \infty \)</li>
+ * <li>{@code ofPolar(}\( \infty \){@code , }\( 5\frac{\pi}{4} \){@code )
= }\( -\infty - i \infty \)</li>
* </ul>
*
* <p>This method is the functional equivalent of the C++ method {@code
std::polar}.
@@ -491,10 +491,10 @@ public final class Complex implements Serializable {
* <p>Special cases:
*
* <ul>
- * <li>{@code abs(x + iy) == abs(y + ix) == abs(x - iy)}.
- * <li>If {@code z} is ±∞ + iy for any y, returns +∞.
- * <li>If {@code z} is x + iNaN for non-infinite x, returns NaN.
- * <li>If {@code z} is x + i0, returns |x|.
+ * <li>{@code abs(x + iy) == abs(y + ix) == abs(x - iy)}.</li>
+ * <li>If {@code z} is ±∞ + iy for any y, returns +∞.</li>
+ * <li>If {@code z} is x + iNaN for non-infinite x, returns NaN.</li>
+ * <li>If {@code z} is x + i0, returns |x|.</li>
* </ul>
*
* <p>The cases ensure that if either component is infinite then the
result is positive
@@ -525,9 +525,9 @@ public final class Complex implements Serializable {
* without undue overflow or underflow."
*
* <ul>
- * <li>hypot(x, y), hypot(y, x), and hypot(x, −y) are equivalent.
- * <li>hypot(x, ±0) is equivalent to |x|.
- * <li>hypot(±∞, y) returns +∞, even if y is a NaN.
+ * <li>hypot(x, y), hypot(y, x), and hypot(x, −y) are equivalent.</li>
+ * <li>hypot(x, ±0) is equivalent to |x|.</li>
+ * <li>hypot(±∞, y) returns +∞, even if y is a NaN.</li>
* </ul>
*
* <p>This method is called by all methods that require the absolute value
of the complex
@@ -606,9 +606,9 @@ public final class Complex implements Serializable {
*
* <p>Note that:
* <ul>
- * <li>There is more than one complex number that can return {@code
true}.
+ * <li>There is more than one complex number that can return {@code
true}.</li>
* <li>Different representations of NaN can be distinguished by the
- * {@link #equals(Object) Complex.equals(Object)} method.
+ * {@link #equals(Object) Complex.equals(Object)} method.</li>
* </ul>
*
* @return {@code true} if this instance contains NaN and no infinite
parts.
@@ -1222,20 +1222,20 @@ public final class Complex implements Serializable {
* Special cases:
*
* <ul>
- * <li>{@code z.conj().exp() == z.exp().conj()}.
- * <li>If {@code z} is ±0 + i0, returns 1 + i0.
- * <li>If {@code z} is x + i∞ for finite x, returns NaN + iNaN ("invalid"
floating-point operation).
- * <li>If {@code z} is x + iNaN for finite x, returns NaN + iNaN
("invalid" floating-point operation).
- * <li>If {@code z} is +∞ + i0, returns +∞ + i0.
- * <li>If {@code z} is −∞ + iy for finite y, returns +0 cis(y) (see {@link
#ofCis(double)}).
- * <li>If {@code z} is +∞ + iy for finite nonzero y, returns +∞ cis(y).
- * <li>If {@code z} is −∞ + i∞, returns ±0 ± i0 (where the signs of the
real and imaginary parts of the result are unspecified).
- * <li>If {@code z} is +∞ + i∞, returns ±∞ + iNaN (where the sign of the
real part of the result is unspecified; "invalid" floating-point operation).
- * <li>If {@code z} is −∞ + iNaN, returns ±0 ± i0 (where the signs of the
real and imaginary parts of the result are unspecified).
- * <li>If {@code z} is +∞ + iNaN, returns ±∞ + iNaN (where the sign of the
real part of the result is unspecified).
- * <li>If {@code z} is NaN + i0, returns NaN + i0.
- * <li>If {@code z} is NaN + iy for all nonzero numbers y, returns NaN +
iNaN ("invalid" floating-point operation).
- * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.
+ * <li>{@code z.conj().exp() == z.exp().conj()}.</li>
+ * <li>If {@code z} is ±0 + i0, returns 1 + i0.</li>
+ * <li>If {@code z} is x + i∞ for finite x, returns NaN + iNaN ("invalid"
floating-point operation).</li>
+ * <li>If {@code z} is x + iNaN for finite x, returns NaN + iNaN
("invalid" floating-point operation).</li>
+ * <li>If {@code z} is +∞ + i0, returns +∞ + i0.</li>
+ * <li>If {@code z} is −∞ + iy for finite y, returns +0 cis(y) (see {@link
#ofCis(double)}).</li>
+ * <li>If {@code z} is +∞ + iy for finite nonzero y, returns +∞
cis(y).</li>
+ * <li>If {@code z} is −∞ + i∞, returns ±0 ± i0 (where the signs of the
real and imaginary parts of the result are unspecified).</li>
+ * <li>If {@code z} is +∞ + i∞, returns ±∞ + iNaN (where the sign of the
real part of the result is unspecified; "invalid" floating-point
operation).</li>
+ * <li>If {@code z} is −∞ + iNaN, returns ±0 ± i0 (where the signs of the
real and imaginary parts of the result are unspecified).</li>
+ * <li>If {@code z} is +∞ + iNaN, returns ±∞ + iNaN (where the sign of the
real part of the result is unspecified).</li>
+ * <li>If {@code z} is NaN + i0, returns NaN + i0.</li>
+ * <li>If {@code z} is NaN + iy for all nonzero numbers y, returns NaN +
iNaN ("invalid" floating-point operation).</li>
+ * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.</li>
* </ul>
*
* <p>Implements the formula:
@@ -1308,19 +1308,19 @@ public final class Complex implements Serializable {
* Special cases:
*
* <ul>
- * <li>{@code z.conj().log() == z.log().conj()}.
- * <li>If {@code z} is −0 + i0, returns −∞ + iπ ("divide-by-zero"
floating-point operation).
- * <li>If {@code z} is +0 + i0, returns −∞ + i0 ("divide-by-zero"
floating-point operation).
- * <li>If {@code z} is x + i∞ for finite x, returns +∞ + iπ/2.
- * <li>If {@code z} is x + iNaN for finite x, returns NaN + iNaN
("invalid" floating-point operation).
- * <li>If {@code z} is −∞ + iy for finite positive-signed y, returns +∞ +
iπ.
- * <li>If {@code z} is +∞ + iy for finite positive-signed y, returns +∞ +
i0.
- * <li>If {@code z} is −∞ + i∞, returns +∞ + i3π/4.
- * <li>If {@code z} is +∞ + i∞, returns +∞ + iπ/4.
- * <li>If {@code z} is ±∞ + iNaN, returns +∞ + iNaN.
- * <li>If {@code z} is NaN + iy for finite y, returns NaN + iNaN
("invalid" floating-point operation).
- * <li>If {@code z} is NaN + i∞, returns +∞ + iNaN.
- * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.
+ * <li>{@code z.conj().log() == z.log().conj()}.</li>
+ * <li>If {@code z} is −0 + i0, returns −∞ + iπ ("divide-by-zero"
floating-point operation).</li>
+ * <li>If {@code z} is +0 + i0, returns −∞ + i0 ("divide-by-zero"
floating-point operation).</li>
+ * <li>If {@code z} is x + i∞ for finite x, returns +∞ + iπ/2.</li>
+ * <li>If {@code z} is x + iNaN for finite x, returns NaN + iNaN
("invalid" floating-point operation).</li>
+ * <li>If {@code z} is −∞ + iy for finite positive-signed y, returns +∞ +
iπ.</li>
+ * <li>If {@code z} is +∞ + iy for finite positive-signed y, returns +∞ +
i0.</li>
+ * <li>If {@code z} is −∞ + i∞, returns +∞ + i3π/4.</li>
+ * <li>If {@code z} is +∞ + i∞, returns +∞ + iπ/4.</li>
+ * <li>If {@code z} is ±∞ + iNaN, returns +∞ + iNaN.</li>
+ * <li>If {@code z} is NaN + iy for finite y, returns NaN + iNaN
("invalid" floating-point operation).</li>
+ * <li>If {@code z} is NaN + i∞, returns +∞ + iNaN.</li>
+ * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.</li>
* </ul>
*
* <p>Implements the formula:
@@ -1548,29 +1548,29 @@ public final class Complex implements Serializable {
* branch cut along the negative real axis \( (-infty,0) \). Special cases:
*
* <ul>
- * <li>{@code z.conj().sqrt() == z.sqrt().conj()}.
- * <li>If {@code z} is ±0 + i0, returns +0 + i0.
- * <li>If {@code z} is x + i∞ for all x (including NaN), returns +∞ + i∞.
- * <li>If {@code z} is x + iNaN for finite x, returns NaN + iNaN
("invalid" floating-point operation).
- * <li>If {@code z} is −∞ + iy for finite positive-signed y, returns +0 +
i∞.
- * <li>If {@code z} is +∞ + iy for finite positive-signed y, returns +∞ +
i0.
- * <li>If {@code z} is −∞ + iNaN, returns NaN ± i∞ (where the sign of the
imaginary part of the result is unspecified).
- * <li>If {@code z} is +∞ + iNaN, returns +∞ + iNaN.
- * <li>If {@code z} is NaN + iy for finite y, returns NaN + iNaN
("invalid" floating-point operation).
- * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.
+ * <li>{@code z.conj().sqrt() == z.sqrt().conj()}.</li>
+ * <li>If {@code z} is ±0 + i0, returns +0 + i0.</li>
+ * <li>If {@code z} is x + i∞ for all x (including NaN), returns +∞ +
i∞.</li>
+ * <li>If {@code z} is x + iNaN for finite x, returns NaN + iNaN
("invalid" floating-point operation).</li>
+ * <li>If {@code z} is −∞ + iy for finite positive-signed y, returns +0 +
i∞.</li>
+ * <li>If {@code z} is +∞ + iy for finite positive-signed y, returns +∞ +
i0.</li>
+ * <li>If {@code z} is −∞ + iNaN, returns NaN ± i∞ (where the sign of the
imaginary part of the result is unspecified).</li>
+ * <li>If {@code z} is +∞ + iNaN, returns +∞ + iNaN.</li>
+ * <li>If {@code z} is NaN + iy for finite y, returns NaN + iNaN
("invalid" floating-point operation).</li>
+ * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.</li>
* </ul>
*
* <p>Implements the following algorithm to compute \( \sqrt{x + iy} \):
* <ol>
- * <li>Let \( t = \sqrt{2 (|x| + |x + iy|)} \)
- * <li>if \( x \geq 0 \) return \( \frac{t}{2} + i \frac{y}{t} \)
- * <li>else return \( \frac{|y|}{t} + i\ \text{sgn}(y) \frac{t}{2} \)
+ * <li>Let \( t = \sqrt{2 (|x| + |x + iy|)} \)</li>
+ * <li>if \( x \geq 0 \) return \( \frac{t}{2} + i \frac{y}{t} \)</li>
+ * <li>else return \( \frac{|y|}{t} + i\ \text{sgn}(y) \frac{t}{2} \)</li>
* </ol>
* where:
* <ul>
- * <li>\( |x| =\ \){@link Math#abs(double) abs}(x)
- * <li>\( |x + y i| =\ \){@link Complex#abs}
- * <li>\( \text{sgn}(y) =\ \){@link Math#copySign(double,double)
copySign}(1.0, y)
+ * <li>\( |x| =\ \){@link Math#abs(double) abs}(x)</li>
+ * <li>\( |x + y i| =\ \){@link Complex#abs}</li>
+ * <li>\( \text{sgn}(y) =\ \){@link Math#copySign(double,double)
copySign}(1.0, y)</li>
* </ul>
*
* <p>The implementation is overflow and underflow safe based on the
method described in:</p>
@@ -1960,19 +1960,19 @@ public final class Complex implements Serializable {
* unbounded along the imaginary axis. Special cases:
*
* <ul>
- * <li>{@code z.conj().acos() == z.acos().conj()}.
- * <li>If {@code z} is ±0 + i0, returns π/2 − i0.
- * <li>If {@code z} is ±0 + iNaN, returns π/2 + iNaN.
- * <li>If {@code z} is x + i∞ for finite x, returns π/2 − i∞.
- * <li>If {@code z} is x + iNaN, returns NaN + iNaN ("invalid"
floating-point operation).
- * <li>If {@code z} is −∞ + iy for positive-signed finite y, returns π −
i∞.
- * <li>If {@code z} is +∞ + iy for positive-signed finite y, returns +0 −
i∞.
- * <li>If {@code z} is −∞ + i∞, returns 3π/4 − i∞.
- * <li>If {@code z} is +∞ + i∞, returns π/4 − i∞.
- * <li>If {@code z} is ±∞ + iNaN, returns NaN ± i∞ where the sign of the
imaginary part of the result is unspecified.
- * <li>If {@code z} is NaN + iy for finite y, returns NaN + iNaN
("invalid" floating-point operation).
- * <li>If {@code z} is NaN + i∞, returns NaN − i∞.
- * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.
+ * <li>{@code z.conj().acos() == z.acos().conj()}.</li>
+ * <li>If {@code z} is ±0 + i0, returns π/2 − i0.</li>
+ * <li>If {@code z} is ±0 + iNaN, returns π/2 + iNaN.</li>
+ * <li>If {@code z} is x + i∞ for finite x, returns π/2 − i∞.</li>
+ * <li>If {@code z} is x + iNaN, returns NaN + iNaN ("invalid"
floating-point operation).</li>
+ * <li>If {@code z} is −∞ + iy for positive-signed finite y, returns π −
i∞.</li>
+ * <li>If {@code z} is +∞ + iy for positive-signed finite y, returns +0 −
i∞.</li>
+ * <li>If {@code z} is −∞ + i∞, returns 3π/4 − i∞.</li>
+ * <li>If {@code z} is +∞ + i∞, returns π/4 − i∞.</li>
+ * <li>If {@code z} is ±∞ + iNaN, returns NaN ± i∞ where the sign of the
imaginary part of the result is unspecified.</li>
+ * <li>If {@code z} is NaN + iy for finite y, returns NaN + iNaN
("invalid" floating-point operation).</li>
+ * <li>If {@code z} is NaN + i∞, returns NaN − i∞.</li>
+ * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.</li>
* </ul>
*
* <p>The inverse cosine is a multivalued function and requires a branch
cut in
@@ -2181,20 +2181,20 @@ public final class Complex implements Serializable {
* Special cases:
*
* <ul>
- * <li>{@code z.conj().sinh() == z.sinh().conj()}.
- * <li>This is an odd function: \( \sinh(z) = -\sinh(-z) \).
- * <li>If {@code z} is +0 + i0, returns +0 + i0.
- * <li>If {@code z} is +0 + i∞, returns ±0 + iNaN (where the sign of the
real part of the result is unspecified; "invalid" floating-point operation).
- * <li>If {@code z} is +0 + iNaN, returns ±0 + iNaN (where the sign of the
real part of the result is unspecified).
- * <li>If {@code z} is x + i∞ for positive finite x, returns NaN + iNaN
("invalid" floating-point operation).
- * <li>If {@code z} is x + iNaN for finite nonzero x, returns NaN + iNaN
("invalid" floating-point operation).
- * <li>If {@code z} is +∞ + i0, returns +∞ + i0.
- * <li>If {@code z} is +∞ + iy for positive finite y, returns +∞ cis(y)
(see {@link #ofCis(double)}.
- * <li>If {@code z} is +∞ + i∞, returns ±∞ + iNaN (where the sign of the
real part of the result is unspecified; "invalid" floating-point operation).
- * <li>If {@code z} is +∞ + iNaN, returns ±∞ + iNaN (where the sign of the
real part of the result is unspecified).
- * <li>If {@code z} is NaN + i0, returns NaN + i0.
- * <li>If {@code z} is NaN + iy for all nonzero numbers y, returns NaN +
iNaN ("invalid" floating-point operation).
- * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.
+ * <li>{@code z.conj().sinh() == z.sinh().conj()}.</li>
+ * <li>This is an odd function: \( \sinh(z) = -\sinh(-z) \).</li>
+ * <li>If {@code z} is +0 + i0, returns +0 + i0.</li>
+ * <li>If {@code z} is +0 + i∞, returns ±0 + iNaN (where the sign of the
real part of the result is unspecified; "invalid" floating-point
operation).</li>
+ * <li>If {@code z} is +0 + iNaN, returns ±0 + iNaN (where the sign of the
real part of the result is unspecified).</li>
+ * <li>If {@code z} is x + i∞ for positive finite x, returns NaN + iNaN
("invalid" floating-point operation).</li>
+ * <li>If {@code z} is x + iNaN for finite nonzero x, returns NaN + iNaN
("invalid" floating-point operation).</li>
+ * <li>If {@code z} is +∞ + i0, returns +∞ + i0.</li>
+ * <li>If {@code z} is +∞ + iy for positive finite y, returns +∞ cis(y)
(see {@link #ofCis(double)}.</li>
+ * <li>If {@code z} is +∞ + i∞, returns ±∞ + iNaN (where the sign of the
real part of the result is unspecified; "invalid" floating-point
operation).</li>
+ * <li>If {@code z} is +∞ + iNaN, returns ±∞ + iNaN (where the sign of the
real part of the result is unspecified).</li>
+ * <li>If {@code z} is NaN + i0, returns NaN + i0.</li>
+ * <li>If {@code z} is NaN + iy for all nonzero numbers y, returns NaN +
iNaN ("invalid" floating-point operation).</li>
+ * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.</li>
* </ul>
*
* <p>This is implemented using real \( x \) and imaginary \( y \) parts:
@@ -2262,20 +2262,20 @@ public final class Complex implements Serializable {
* Special cases:
*
* <ul>
- * <li>{@code z.conj().cosh() == z.cosh().conj()}.
- * <li>This is an even function: \( \cosh(z) = \cosh(-z) \).
- * <li>If {@code z} is +0 + i0, returns 1 + i0.
- * <li>If {@code z} is +0 + i∞, returns NaN ± i0 (where the sign of the
imaginary part of the result is unspecified; "invalid" floating-point
operation).
- * <li>If {@code z} is +0 + iNaN, returns NaN ± i0 (where the sign of the
imaginary part of the result is unspecified).
- * <li>If {@code z} is x + i∞ for finite nonzero x, returns NaN + iNaN
("invalid" floating-point operation).
- * <li>If {@code z} is x + iNaN for finite nonzero x, returns NaN + iNaN
("invalid" floating-point operation).
- * <li>If {@code z} is +∞ + i0, returns +∞ + i0.
- * <li>If {@code z} is +∞ + iy for finite nonzero y, returns +∞ cis(y)
(see {@link #ofCis(double)}).
- * <li>If {@code z} is +∞ + i∞, returns ±∞ + iNaN (where the sign of the
real part of the result is unspecified).
- * <li>If {@code z} is +∞ + iNaN, returns +∞ + iNaN.
- * <li>If {@code z} is NaN + i0, returns NaN ± i0 (where the sign of the
imaginary part of the result is unspecified).
- * <li>If {@code z} is NaN + iy for all nonzero numbers y, returns NaN +
iNaN ("invalid" floating-point operation).
- * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.
+ * <li>{@code z.conj().cosh() == z.cosh().conj()}.</li>
+ * <li>This is an even function: \( \cosh(z) = \cosh(-z) \).</li>
+ * <li>If {@code z} is +0 + i0, returns 1 + i0.</li>
+ * <li>If {@code z} is +0 + i∞, returns NaN ± i0 (where the sign of the
imaginary part of the result is unspecified; "invalid" floating-point
operation).</li>
+ * <li>If {@code z} is +0 + iNaN, returns NaN ± i0 (where the sign of the
imaginary part of the result is unspecified).</li>
+ * <li>If {@code z} is x + i∞ for finite nonzero x, returns NaN + iNaN
("invalid" floating-point operation).</li>
+ * <li>If {@code z} is x + iNaN for finite nonzero x, returns NaN + iNaN
("invalid" floating-point operation).</li>
+ * <li>If {@code z} is +∞ + i0, returns +∞ + i0.</li>
+ * <li>If {@code z} is +∞ + iy for finite nonzero y, returns +∞ cis(y)
(see {@link #ofCis(double)}).</li>
+ * <li>If {@code z} is +∞ + i∞, returns ±∞ + iNaN (where the sign of the
real part of the result is unspecified).</li>
+ * <li>If {@code z} is +∞ + iNaN, returns +∞ + iNaN.</li>
+ * <li>If {@code z} is NaN + i0, returns NaN ± i0 (where the sign of the
imaginary part of the result is unspecified).</li>
+ * <li>If {@code z} is NaN + iy for all nonzero numbers y, returns NaN +
iNaN ("invalid" floating-point operation).</li>
+ * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.</li>
* </ul>
*
* <p>This is implemented using real \( x \) and imaginary \( y \) parts:
@@ -2412,19 +2412,19 @@ public final class Complex implements Serializable {
* \( \pi/2 \) and there is no value for which a pole error occurs.
Special cases:
*
* <ul>
- * <li>{@code z.conj().tanh() == z.tanh().conj()}.
- * <li>This is an odd function: \( \tanh(z) = -\tanh(-z) \).
- * <li>If {@code z} is +0 + i0, returns +0 + i0.
- * <li>If {@code z} is 0 + i∞, returns 0 + iNaN.
- * <li>If {@code z} is x + i∞ for finite non-zero x, returns NaN + iNaN
("invalid" floating-point operation).
- * <li>If {@code z} is 0 + iNaN, returns 0 + iNAN.
- * <li>If {@code z} is x + iNaN for finite non-zero x, returns NaN + iNaN
("invalid" floating-point operation).
- * <li>If {@code z} is +∞ + iy for positive-signed finite y, returns 1 +
i0 sin(2y).
- * <li>If {@code z} is +∞ + i∞, returns 1 ± i0 (where the sign of the
imaginary part of the result is unspecified).
- * <li>If {@code z} is +∞ + iNaN, returns 1 ± i0 (where the sign of the
imaginary part of the result is unspecified).
- * <li>If {@code z} is NaN + i0, returns NaN + i0.
- * <li>If {@code z} is NaN + iy for all nonzero numbers y, returns NaN +
iNaN ("invalid" floating-point operation).
- * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.
+ * <li>{@code z.conj().tanh() == z.tanh().conj()}.</li>
+ * <li>This is an odd function: \( \tanh(z) = -\tanh(-z) \).</li>
+ * <li>If {@code z} is +0 + i0, returns +0 + i0.</li>
+ * <li>If {@code z} is 0 + i∞, returns 0 + iNaN.</li>
+ * <li>If {@code z} is x + i∞ for finite non-zero x, returns NaN + iNaN
("invalid" floating-point operation).</li>
+ * <li>If {@code z} is 0 + iNaN, returns 0 + iNAN.</li>
+ * <li>If {@code z} is x + iNaN for finite non-zero x, returns NaN + iNaN
("invalid" floating-point operation).</li>
+ * <li>If {@code z} is +∞ + iy for positive-signed finite y, returns 1 +
i0 sin(2y).</li>
+ * <li>If {@code z} is +∞ + i∞, returns 1 ± i0 (where the sign of the
imaginary part of the result is unspecified).</li>
+ * <li>If {@code z} is +∞ + iNaN, returns 1 ± i0 (where the sign of the
imaginary part of the result is unspecified).</li>
+ * <li>If {@code z} is NaN + i0, returns NaN + i0.</li>
+ * <li>If {@code z} is NaN + iy for all nonzero numbers y, returns NaN +
iNaN ("invalid" floating-point operation).</li>
+ * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.</li>
* </ul>
*
* <p>Special cases include the technical corrigendum
@@ -2562,18 +2562,18 @@ public final class Complex implements Serializable {
* in the range \( [-\pi, \pi] \) along the imaginary axis. Special cases:
*
* <ul>
- * <li>{@code z.conj().asinh() == z.asinh().conj()}.
- * <li>This is an odd function: \( \sinh^{-1}(z) = -\sinh^{-1}(-z) \).
- * <li>If {@code z} is +0 + i0, returns 0 + i0.
- * <li>If {@code z} is x + i∞ for positive-signed finite x, returns +∞ +
iπ/2.
- * <li>If {@code z} is x + iNaN for finite x, returns NaN + iNaN
("invalid" floating-point operation).
- * <li>If {@code z} is +∞ + iy for positive-signed finite y, returns +∞ +
i0.
- * <li>If {@code z} is +∞ + i∞, returns +∞ + iπ/4.
- * <li>If {@code z} is +∞ + iNaN, returns +∞ + iNaN.
- * <li>If {@code z} is NaN + i0, returns NaN + i0.
- * <li>If {@code z} is NaN + iy for finite nonzero y, returns NaN + iNaN
("invalid" floating-point operation).
- * <li>If {@code z} is NaN + i∞, returns ±∞ + iNaN (where the sign of the
real part of the result is unspecified).
- * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.
+ * <li>{@code z.conj().asinh() == z.asinh().conj()}.</li>
+ * <li>This is an odd function: \( \sinh^{-1}(z) = -\sinh^{-1}(-z) \).</li>
+ * <li>If {@code z} is +0 + i0, returns 0 + i0.</li>
+ * <li>If {@code z} is x + i∞ for positive-signed finite x, returns +∞ +
iπ/2.</li>
+ * <li>If {@code z} is x + iNaN for finite x, returns NaN + iNaN
("invalid" floating-point operation).</li>
+ * <li>If {@code z} is +∞ + iy for positive-signed finite y, returns +∞ +
i0.</li>
+ * <li>If {@code z} is +∞ + i∞, returns +∞ + iπ/4.</li>
+ * <li>If {@code z} is +∞ + iNaN, returns +∞ + iNaN.</li>
+ * <li>If {@code z} is NaN + i0, returns NaN + i0.</li>
+ * <li>If {@code z} is NaN + iy for finite nonzero y, returns NaN + iNaN
("invalid" floating-point operation).</li>
+ * <li>If {@code z} is NaN + i∞, returns ±∞ + iNaN (where the sign of the
real part of the result is unspecified).</li>
+ * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.</li>
* </ul>
*
* <p>The inverse hyperbolic sine is a multivalued function and requires a
branch cut in
@@ -2607,19 +2607,19 @@ public final class Complex implements Serializable {
* real axis and in the range \( [-\pi, \pi] \) along the imaginary axis.
Special cases:
*
* <ul>
- * <li>{@code z.conj().acosh() == z.acosh().conj()}.
- * <li>If {@code z} is ±0 + i0, returns +0 + iπ/2.
- * <li>If {@code z} is x + i∞ for finite x, returns +∞ + iπ/2.
- * <li>If {@code z} is 0 + iNaN, returns NaN + iπ/2 <sup>[1]</sup>.
- * <li>If {@code z} is x + iNaN for finite non-zero x, returns NaN + iNaN
("invalid" floating-point operation).
- * <li>If {@code z} is −∞ + iy for positive-signed finite y, returns +∞ +
iπ.
- * <li>If {@code z} is +∞ + iy for positive-signed finite y, returns +∞ +
i0.
- * <li>If {@code z} is −∞ + i∞, returns +∞ + i3π/4.
- * <li>If {@code z} is +∞ + i∞, returns +∞ + iπ/4.
- * <li>If {@code z} is ±∞ + iNaN, returns +∞ + iNaN.
- * <li>If {@code z} is NaN + iy for finite y, returns NaN + iNaN
("invalid" floating-point operation).
- * <li>If {@code z} is NaN + i∞, returns +∞ + iNaN.
- * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.
+ * <li>{@code z.conj().acosh() == z.acosh().conj()}.</li>
+ * <li>If {@code z} is ±0 + i0, returns +0 + iπ/2.</li>
+ * <li>If {@code z} is x + i∞ for finite x, returns +∞ + iπ/2.</li>
+ * <li>If {@code z} is 0 + iNaN, returns NaN + iπ/2 <sup>[1]</sup>.</li>
+ * <li>If {@code z} is x + iNaN for finite non-zero x, returns NaN + iNaN
("invalid" floating-point operation).</li>
+ * <li>If {@code z} is −∞ + iy for positive-signed finite y, returns +∞ +
iπ.</li>
+ * <li>If {@code z} is +∞ + iy for positive-signed finite y, returns +∞ +
i0.</li>
+ * <li>If {@code z} is −∞ + i∞, returns +∞ + i3π/4.</li>
+ * <li>If {@code z} is +∞ + i∞, returns +∞ + iπ/4.</li>
+ * <li>If {@code z} is ±∞ + iNaN, returns +∞ + iNaN.</li>
+ * <li>If {@code z} is NaN + iy for finite y, returns NaN + iNaN
("invalid" floating-point operation).</li>
+ * <li>If {@code z} is NaN + i∞, returns +∞ + iNaN.</li>
+ * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.</li>
* </ul>
*
* <p>Special cases include the technical corrigendum
@@ -2672,19 +2672,19 @@ public final class Complex implements Serializable {
* in the range \( [-\pi/2, \pi/2] \) along the imaginary axis. Special
cases:
*
* <ul>
- * <li>{@code z.conj().atanh() == z.atanh().conj()}.
- * <li>This is an odd function: \( \tanh^{-1}(z) = -\tanh^{-1}(-z) \).
- * <li>If {@code z} is +0 + i0, returns +0 + i0.
- * <li>If {@code z} is +0 + iNaN, returns +0 + iNaN.
- * <li>If {@code z} is +1 + i0, returns +∞ + i0 ("divide-by-zero"
floating-point operation).
- * <li>If {@code z} is x + i∞ for finite positive-signed x, returns +0 +
iπ/2.
- * <li>If {@code z} is x+iNaN for nonzero finite x, returns NaN+iNaN
("invalid" floating-point operation).
- * <li>If {@code z} is +∞ + iy for finite positive-signed y, returns +0 +
iπ/2.
- * <li>If {@code z} is +∞ + i∞, returns +0 + iπ/2.
- * <li>If {@code z} is +∞ + iNaN, returns +0 + iNaN.
- * <li>If {@code z} is NaN+iy for finite y, returns NaN+iNaN ("invalid"
floating-point operation).
- * <li>If {@code z} is NaN + i∞, returns ±0 + iπ/2 (where the sign of the
real part of the result is unspecified).
- * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.
+ * <li>{@code z.conj().atanh() == z.atanh().conj()}.</li>
+ * <li>This is an odd function: \( \tanh^{-1}(z) = -\tanh^{-1}(-z) \).</li>
+ * <li>If {@code z} is +0 + i0, returns +0 + i0.</li>
+ * <li>If {@code z} is +0 + iNaN, returns +0 + iNaN.</li>
+ * <li>If {@code z} is +1 + i0, returns +∞ + i0 ("divide-by-zero"
floating-point operation).</li>
+ * <li>If {@code z} is x + i∞ for finite positive-signed x, returns +0 +
iπ/2.</li>
+ * <li>If {@code z} is x+iNaN for nonzero finite x, returns NaN+iNaN
("invalid" floating-point operation).</li>
+ * <li>If {@code z} is +∞ + iy for finite positive-signed y, returns +0 +
iπ/2.</li>
+ * <li>If {@code z} is +∞ + i∞, returns +0 + iπ/2.</li>
+ * <li>If {@code z} is +∞ + iNaN, returns +0 + iNaN.</li>
+ * <li>If {@code z} is NaN+iy for finite y, returns NaN+iNaN ("invalid"
floating-point operation).</li>
+ * <li>If {@code z} is NaN + i∞, returns ±0 + iπ/2 (where the sign of the
real part of the result is unspecified).</li>
+ * <li>If {@code z} is NaN + iNaN, returns NaN + iNaN.</li>
* </ul>
*
* <p>The inverse hyperbolic tangent is a multivalued function and
requires a branch cut in
@@ -3384,9 +3384,9 @@ public final class Complex implements Serializable {
*
* <ul>
* <li>If either argument is NaN or infinite, then the result is
- * {@link Double#MAX_EXPONENT} + 1.
+ * {@link Double#MAX_EXPONENT} + 1.</li>
* <li>If both arguments are zero, then the result is
- * {@link Double#MAX_EXPONENT} + 1.
+ * {@link Double#MAX_EXPONENT} + 1.</li>
* </ul>
*
* @param a the first value
@@ -3428,9 +3428,9 @@ public final class Complex implements Serializable {
*
* <ul>
* <li>If either argument is NaN or infinite, then the result is
- * {@link Double#MAX_EXPONENT} + 1.
+ * {@link Double#MAX_EXPONENT} + 1.</li>
* <li>If both arguments are zero or subnormal, then the result is
- * {@link Double#MIN_EXPONENT} -1.
+ * {@link Double#MIN_EXPONENT} -1.</li>
* </ul>
*
* <p>This is used by {@link #divide(double, double, double, double)} as
@@ -3468,8 +3468,8 @@ public final class Complex implements Serializable {
*
* <p>Special cases:
* <ul>
- * <li>If either argument is infinite, then the result is positive
infinity.
- * <li>If either argument is NaN and neither argument is infinite, then
the result is NaN.
+ * <li>If either argument is infinite, then the result is positive
infinity.</li>
+ * <li>If either argument is NaN and neither argument is infinite, then
the result is NaN.</li>
* </ul>
*
* <p>The computed result is expected to be within 1 ulp of the exact
result.
diff --git
a/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/ArithmeticUtils.java
b/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/ArithmeticUtils.java
index cf605761..153b3202 100644
---
a/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/ArithmeticUtils.java
+++
b/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/ArithmeticUtils.java
@@ -125,7 +125,7 @@ public final class ArithmeticUtils {
* is too large for a long value.</li>
* <li>The result of {@code gcd(x, x)}, {@code gcd(0L, x)} and
* {@code gcd(x, 0L)} is the absolute value of {@code x}, except
- * for the special cases above.
+ * for the special cases above.</li>
* <li>The invocation {@code gcd(0L, 0L)} is the only one which returns
* {@code 0L}.</li>
* </ul>
@@ -203,7 +203,7 @@ public final class ArithmeticUtils {
* power of 2, throw an {@code ArithmeticException}, because the result
* would be 2^31, which is too large for an int value.</li>
* <li>The result of {@code lcm(0, x)} and {@code lcm(x, 0)} is
- * {@code 0} for any {@code x}.
+ * {@code 0} for any {@code x}.</li>
* </ul>
*
* @param a Number.
@@ -236,7 +236,7 @@ public final class ArithmeticUtils {
* power of 2, throw an {@code ArithmeticException}, because the result
* would be 2^63, which is too large for an int value.</li>
* <li>The result of {@code lcm(0L, x)} and {@code lcm(x, 0L)} is
- * {@code 0L} for any {@code x}.
+ * {@code 0L} for any {@code x}.</li>
* </ul>
*
* @param a Number.
@@ -262,12 +262,12 @@ public final class ArithmeticUtils {
*
* <p>Special cases:</p>
* <ul>
- * <li>{@code k^0} returns {@code 1} (including {@code k=0})
- * <li>{@code k^1} returns {@code k} (including {@code k=0})
- * <li>{@code 0^0} returns {@code 1}
- * <li>{@code 0^e} returns {@code 0}
- * <li>{@code 1^e} returns {@code 1}
- * <li>{@code (-1)^e} returns {@code -1 or 1} if {@code e} is odd or even
+ * <li>{@code k^0} returns {@code 1} (including {@code k=0})</li>
+ * <li>{@code k^1} returns {@code k} (including {@code k=0})</li>
+ * <li>{@code 0^0} returns {@code 1}</li>
+ * <li>{@code 0^e} returns {@code 0}</li>
+ * <li>{@code 1^e} returns {@code 1}</li>
+ * <li>{@code (-1)^e} returns {@code -1 or 1} if {@code e} is odd or
even</li>
* </ul>
*
* @param k Number to raise.
@@ -322,12 +322,12 @@ public final class ArithmeticUtils {
*
* <p>Special cases:</p>
* <ul>
- * <li>{@code k^0} returns {@code 1} (including {@code k=0})
- * <li>{@code k^1} returns {@code k} (including {@code k=0})
- * <li>{@code 0^0} returns {@code 1}
- * <li>{@code 0^e} returns {@code 0}
- * <li>{@code 1^e} returns {@code 1}
- * <li>{@code (-1)^e} returns {@code -1 or 1} if {@code e} is odd or even
+ * <li>{@code k^0} returns {@code 1} (including {@code k=0})</li>
+ * <li>{@code k^1} returns {@code k} (including {@code k=0})</li>
+ * <li>{@code 0^0} returns {@code 1}</li>
+ * <li>{@code 0^e} returns {@code 0}</li>
+ * <li>{@code 1^e} returns {@code 1}</li>
+ * <li>{@code (-1)^e} returns {@code -1 or 1} if {@code e} is odd or
even</li>
* </ul>
*
* @param k Number to raise.
diff --git
a/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/DD.java
b/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/DD.java
index d8d5ede6..5b3dbc45 100644
--- a/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/DD.java
+++ b/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/DD.java
@@ -153,15 +153,15 @@ import java.util.function.DoubleUnaryOperator;
* Dekker, T.J. (1971)
* <a href="https://doi.org/10.1007/BF01397083";>
* A floating-point technique for extending the available precision</a>
- * Numerische Mathematik, 18:224–242.
+ * Numerische Mathematik, 18:224–242.</li>
* <li>
* Shewchuk, J.R. (1997)
* <a
href="https://www-2.cs.cmu.edu/afs/cs/project/quake/public/papers/robust-arithmetic.ps";>
- * Arbitrary Precision Floating-Point Arithmetic</a>.
+ * Arbitrary Precision Floating-Point Arithmetic</a>.</li>
* <li>
* Hide, Y, Li, X.S. and Bailey, D.H. (2008)
* <a href="https://www.davidhbailey.com/dhbpapers/qd.pdf";>
- * Library for Double-Double and Quad-Double Arithmetic</a>.
+ * Library for Double-Double and Quad-Double Arithmetic</a>.</li>
* </ol>
*
* @since 1.2
@@ -398,9 +398,9 @@ public final class DD
* This creates the following special cases:
*
* <ul>
- * <li>If {@code x + y} is infinite then the low part is NaN.
- * <li>If {@code x} or {@code y} is infinite or NaN then the low part is
NaN.
- * <li>If {@code x + y} is sub-normal or zero then the low part is +/-0.0.
+ * <li>If {@code x + y} is infinite then the low part is NaN.</li>
+ * <li>If {@code x} or {@code y} is infinite or NaN then the low part is
NaN.</li>
+ * <li>If {@code x + y} is sub-normal or zero then the low part is
+/-0.0.</li>
* </ul>
*
* <p>An invalid result can be identified using {@link #isFinite()}.
@@ -446,10 +446,10 @@ public final class DD
*
* <ul>
* <li>If either {@code |x|} or {@code |y|} multiplied by {@code 1 + 2^27}
- * is infinite (intermediate overflow) then the low part is NaN.
- * <li>If {@code x * y} is infinite then the low part is NaN.
- * <li>If {@code x} or {@code y} is infinite or NaN then the low part is
NaN.
- * <li>If {@code x * y} is sub-normal or zero then the low part is +/-0.0.
+ * is infinite (intermediate overflow) then the low part is NaN.</li>
+ * <li>If {@code x * y} is infinite then the low part is NaN.</li>
+ * <li>If {@code x} or {@code y} is infinite or NaN then the low part is
NaN.</li>
+ * <li>If {@code x * y} is sub-normal or zero then the low part is
+/-0.0.</li>
* </ul>
*
* <p>An invalid result can be identified using {@link #isFinite()}.
@@ -496,11 +496,11 @@ public final class DD
*
* <ul>
* <li>If either {@code |x / y|} or {@code |y|} multiplied by {@code 1 +
2^27}
- * is infinite (intermediate overflow) then the low part is NaN.
- * <li>If {@code x / y} is infinite then the low part is NaN.
- * <li>If {@code x} or {@code y} is infinite or NaN then the low part is
NaN.
+ * is infinite (intermediate overflow) then the low part is NaN.</li>
+ * <li>If {@code x / y} is infinite then the low part is NaN.</li>
+ * <li>If {@code x} or {@code y} is infinite or NaN then the low part is
NaN.</li>
* <li>If {@code x / y} is sub-normal or zero, excluding the previous
cases,
- * then the low part is +/-0.0.
+ * then the low part is +/-0.0.</li>
* </ul>
*
* <p>An invalid result can be identified using {@link #isFinite()}.
@@ -625,9 +625,9 @@ public final class DD
*
* <p>Special cases:
* <ul>
- * <li>If the {@code DD} value is infinite the result is {@link
Integer#MAX_VALUE}.
- * <li>If the {@code DD} value is -infinite the result is {@link
Integer#MIN_VALUE}.
- * <li>If the {@code DD} value is NaN the result is 0.
+ * <li>If the {@code DD} value is infinite the result is {@link
Integer#MAX_VALUE}.</li>
+ * <li>If the {@code DD} value is -infinite the result is {@link
Integer#MIN_VALUE}.</li>
+ * <li>If the {@code DD} value is NaN the result is 0.</li>
* </ul>
*
* <p>Conversion of a finite {@code DD} can also be performed using the
@@ -658,9 +658,9 @@ public final class DD
*
* <p>Special cases:
* <ul>
- * <li>If the {@code DD} value is infinite the result is {@link
Long#MAX_VALUE}.
- * <li>If the {@code DD} value is -infinite the result is {@link
Long#MIN_VALUE}.
- * <li>If the {@code DD} value is NaN the result is 0.
+ * <li>If the {@code DD} value is infinite the result is {@link
Long#MAX_VALUE}.</li>
+ * <li>If the {@code DD} value is -infinite the result is {@link
Long#MIN_VALUE}.</li>
+ * <li>If the {@code DD} value is NaN the result is 0.</li>
* </ul>
*
* <p>Conversion of a finite {@code DD} can also be performed using the
@@ -895,11 +895,11 @@ public final class DD
* This creates the following special cases:
*
* <ul>
- * <li>If {@code x * y} is sub-normal or zero then the low part is +/-0.0.
- * <li>If {@code x * y} is infinite then the low part is NaN.
- * <li>If {@code x} or {@code y} is infinite or NaN then the low part is
NaN.
+ * <li>If {@code x * y} is sub-normal or zero then the low part is
+/-0.0.</li>
+ * <li>If {@code x * y} is infinite then the low part is NaN.</li>
+ * <li>If {@code x} or {@code y} is infinite or NaN then the low part is
NaN.</li>
* <li>If either {@code |x|} or {@code |y|} multiplied by {@code 1 + 2^27}
- * is infinite (intermediate overflow) then the low part is NaN.
+ * is infinite (intermediate overflow) then the low part is NaN.</li>
* </ul>
*
* <p>Note: Ignoring special cases is a design choice for performance. The
@@ -1069,10 +1069,10 @@ public final class DD
*
* <p>Cases:
* <ul>
- * <li>If the {@code x} value is negative the result is {@code (-x, -xx)}.
+ * <li>If the {@code x} value is negative the result is {@code (-x,
-xx)}.</li>
* <li>If the {@code x} value is +/- 0.0 the result is {@code (0.0,
0.0)}; this
- * will remove sign information from the round-off component assumed
to be zero.
- * <li>Otherwise the result is {@code this}.
+ * will remove sign information from the round-off component assumed
to be zero.</li>
+ * <li>Otherwise the result is {@code this}.</li>
* </ul>
*
* @return the absolute value
@@ -1098,12 +1098,12 @@ public final class DD
*
* <p>Cases:
* <ul>
- * <li>If {@code x} is NaN, then the result is {@code (NaN, 0)}.
- * <li>If {@code x} is infinite, then the result is {@code (x, 0)}.
- * <li>If {@code x} is +/-0.0, then the result is {@code (x, 0)}.
- * <li>If {@code x != Math.floor(x)}, then the result is {@code
(Math.floor(x), 0)}.
+ * <li>If {@code x} is NaN, then the result is {@code (NaN, 0)}.</li>
+ * <li>If {@code x} is infinite, then the result is {@code (x, 0)}.</li>
+ * <li>If {@code x} is +/-0.0, then the result is {@code (x, 0)}.</li>
+ * <li>If {@code x != Math.floor(x)}, then the result is {@code
(Math.floor(x), 0)}.</li>
* <li>Otherwise the result is the {@code DD} value equal to the sum
- * {@code Math.floor(x) + Math.floor(xx)}.
+ * {@code Math.floor(x) + Math.floor(xx)}.</li>
* </ul>
*
* <p>The result may generate a high part smaller (closer to negative
infinity) than
@@ -1128,12 +1128,12 @@ public final class DD
*
* <p>Cases:
* <ul>
- * <li>If {@code x} is NaN, then the result is {@code (NaN, 0)}.
- * <li>If {@code x} is infinite, then the result is {@code (x, 0)}.
- * <li>If {@code x} is +/-0.0, then the result is {@code (x, 0)}.
- * <li>If {@code x != Math.ceil(x)}, then the result is {@code
(Math.ceil(x), 0)}.
+ * <li>If {@code x} is NaN, then the result is {@code (NaN, 0)}.</li>
+ * <li>If {@code x} is infinite, then the result is {@code (x, 0)}.</li>
+ * <li>If {@code x} is +/-0.0, then the result is {@code (x, 0)}.</li>
+ * <li>If {@code x != Math.ceil(x)}, then the result is {@code
(Math.ceil(x), 0)}.</li>
* <li>Otherwise the result is the {@code DD} value equal to the sum
- * {@code Math.ceil(x) + Math.ceil(xx)}.
+ * {@code Math.ceil(x) + Math.ceil(xx)}.</li>
* </ul>
*
* <p>The result may generate a high part larger (closer to positive
infinity) than
@@ -1154,10 +1154,10 @@ public final class DD
*
* <p>Cases:
* <ul>
- * <li>If {@code x} is non-finite or zero, then the result is {@code (x,
0)}.
+ * <li>If {@code x} is non-finite or zero, then the result is {@code (x,
0)}.</li>
* <li>If {@code x} is rounded by the operator to a new value {@code y},
then the
- * result is {@code (y, 0)}.
- * <li>Otherwise the result is the {@code DD} value equal to the sum
{@code op(x) + op(xx)}.
+ * result is {@code (y, 0)}.</li>
+ * <li>Otherwise the result is the {@code DD} value equal to the sum
{@code op(x) + op(xx)}.</li>
* </ul>
*
* @param x High part of x.
@@ -1602,9 +1602,9 @@ public final class DD
*
* <p>Special cases:
* <ul>
- * <li>If {@code x} is NaN or less than zero, then the result is {@code
(NaN, 0)}.
- * <li>If {@code x} is positive infinity, then the result is {@code
(+infinity, 0)}.
- * <li>If {@code x} is positive zero or negative zero, then the result is
{@code (x, 0)}.
+ * <li>If {@code x} is NaN or less than zero, then the result is {@code
(NaN, 0)}.</li>
+ * <li>If {@code x} is positive infinity, then the result is {@code
(+infinity, 0)}.</li>
+ * <li>If {@code x} is positive zero or negative zero, then the result is
{@code (x, 0)}.</li>
* </ul>
*
* <p>The computed result is within 4 eps of the exact result where eps is
2<sup>-106</sup>.
@@ -1774,12 +1774,12 @@ public final class DD
*
* <p>Special cases:
* <ul>
- * <li>If {@code x} is zero, then the normalized fraction is zero and the
exponent is zero.
- * <li>If {@code x} is NaN, then the normalized fraction is NaN and the
exponent is unspecified.
- * <li>If {@code x} is infinite, then the normalized fraction is infinite
and the exponent is unspecified.
+ * <li>If {@code x} is zero, then the normalized fraction is zero and the
exponent is zero.</li>
+ * <li>If {@code x} is NaN, then the normalized fraction is NaN and the
exponent is unspecified.</li>
+ * <li>If {@code x} is infinite, then the normalized fraction is infinite
and the exponent is unspecified.</li>
* <li>If high-part {@code x} is an exact power of 2 and the low-part
{@code xx} has an opposite
* signed non-zero magnitude then fraction high-part {@code f} will
be {@code +/-1} such that
- * the double-double number is in the range {@code [0.5, 1)}.
+ * the double-double number is in the range {@code [0.5, 1)}.</li>
* </ul>
*
* <p>This is named using the equivalent function in the standard C math.h
library.
@@ -1833,8 +1833,8 @@ public final class DD
*
* <p>Special cases:
* <ul>
- * <li>If the argument is NaN or infinite, then the result is {@link
Double#MAX_EXPONENT} + 1.
- * <li>If the argument is zero, then the result is {@link
Double#MAX_EXPONENT} + 1.
+ * <li>If the argument is NaN or infinite, then the result is {@link
Double#MAX_EXPONENT} + 1.</li>
+ * <li>If the argument is zero, then the result is {@link
Double#MAX_EXPONENT} + 1.</li>
* </ul>
*
* @param a Value.
@@ -1872,11 +1872,11 @@ public final class DD
* <p>Special cases:
* <ul>
* <li>If {@code x} is not a finite normalized {@code double}, the low
part {@code xx}
- * is ignored and the result is {@link Math#pow(double, double)
Math.pow(x, n)}.
- * <li>If {@code n = 0} the result is {@code (1, 0)}.
- * <li>If {@code n = 1} the result is {@code (x, xx)}.
- * <li>If {@code n = -1} the result is the {@link #reciprocal()
reciprocal}.
- * <li>If the computation overflows the result is undefined.
+ * is ignored and the result is {@link Math#pow(double, double)
Math.pow(x, n)}.</li>
+ * <li>If {@code n = 0} the result is {@code (1, 0)}.</li>
+ * <li>If {@code n = 1} the result is {@code (x, xx)}.</li>
+ * <li>If {@code n = -1} the result is the {@link #reciprocal()
reciprocal}.</li>
+ * <li>If the computation overflows the result is undefined.</li>
* </ul>
*
* <p>Computation uses multiplication by factors generated by repeat
squaring of the value.
@@ -2009,15 +2009,15 @@ public final class DD
* <p>Special cases:
* <ul>
* <li>If {@code (x, xx)} is zero the high part of the fractional part is
- * computed using {@link Math#pow(double, double) Math.pow(x, n)} and
the exponent is 0.
- * <li>If {@code n = 0} the fractional part is 0.5 and the exponent is 1.
+ * computed using {@link Math#pow(double, double) Math.pow(x, n)} and
the exponent is 0.</li>
+ * <li>If {@code n = 0} the fractional part is 0.5 and the exponent is
1.</li>
* <li>If {@code (x, xx)} is an exact power of 2 the fractional part is
0.5 and the exponent
- * is the power of 2 minus 1.
+ * is the power of 2 minus 1.</li>
* <li>If the result high-part is an exact power of 2 and the low-part
has an opposite
* signed non-zero magnitude then the fraction high-part {@code f}
will be {@code +/-1} such that
- * the double-double number is in the range {@code [0.5, 1)}.
+ * the double-double number is in the range {@code [0.5, 1)}.</li>
* <li>If the argument is not finite then a fractional representation is
not possible.
- * In this case the fraction and the scale factor is undefined.
+ * In this case the fraction and the scale factor is undefined.</li>
* </ul>
*
* <p>The computed result is approximately {@code 16 * (n - 1) * eps} of
the exact result
@@ -2187,9 +2187,9 @@ public final class DD
* <ul>
* <li>Instances that contain {@code NaN} values in the same part
* are considered to be equal for that part, even though {@code
Double.NaN == Double.NaN}
- * has the value {@code false}.
+ * has the value {@code false}.</li>
* <li>Instances that share a {@code NaN} value in one part
- * but have different values in the other part are <em>not</em>
considered equal.
+ * but have different values in the other part are <em>not</em>
considered equal.</li>
* </ul>
*
* <p>The behavior is the same as if the components of the two
double-double numbers were passed
diff --git
a/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/DDMath.java
b/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/DDMath.java
index f118e9aa..135681ab 100644
---
a/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/DDMath.java
+++
b/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/DDMath.java
@@ -62,15 +62,15 @@ public final class DDMath {
* <p>Special cases:
* <ul>
* <li>If {@code (x, xx)} is zero the high part of the fractional part is
- * computed using {@link Math#pow(double, double) Math.pow(x, n)} and
the exponent is 0.
- * <li>If {@code n = 0} the fractional part is 0.5 and the exponent is 1.
+ * computed using {@link Math#pow(double, double) Math.pow(x, n)} and
the exponent is 0.</li>
+ * <li>If {@code n = 0} the fractional part is 0.5 and the exponent is
1.</li>
* <li>If {@code (x, xx)} is an exact power of 2 the fractional part is
0.5 and the exponent
- * is the power of 2 minus 1.
+ * is the power of 2 minus 1.</li>
* <li>If the result high-part is an exact power of 2 and the low-part
has an opposite
* signed non-zero magnitude then the fraction high-part {@code f}
will be {@code +/-1} such that
- * the double-double number is in the range {@code [0.5, 1)}.
+ * the double-double number is in the range {@code [0.5, 1)}.</li>
* <li>If the argument is not finite then a fractional representation is
not possible.
- * In this case the fraction and the scale factor is undefined.
+ * In this case the fraction and the scale factor is undefined.</li>
* </ul>
*
* <p>The computed result is within 1 eps of the exact result where eps is
2<sup>-106</sup>.
diff --git
a/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/ExtendedPrecision.java
b/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/ExtendedPrecision.java
index 5417d70f..4c47cd9d 100644
---
a/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/ExtendedPrecision.java
+++
b/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/ExtendedPrecision.java
@@ -73,8 +73,8 @@ final class ExtendedPrecision {
* <p>Special cases:
*
* <ul>
- * <li>If {@code x * y} is sub-normal or zero then the result is 0.0.
- * <li>If {@code x * y} is infinite or NaN then the result is NaN.
+ * <li>If {@code x * y} is sub-normal or zero then the result is 0.0.</li>
+ * <li>If {@code x * y} is infinite or NaN then the result is NaN.</li>
* </ul>
*
* <p>This method delegates to {@link DD#twoProductLow(double, double,
double)} but uses
diff --git
a/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/Precision.java
b/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/Precision.java
index 283df914..af4712d8 100644
---
a/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/Precision.java
+++
b/commons-numbers-core/src/main/java/org/apache/commons/numbers/core/Precision.java
@@ -72,17 +72,17 @@ public final class Precision {
* Compares two numbers given some amount of allowed error.
* The returned value is:
* <ul>
- * <li>zero if considered equal using {@link
#equals(double,double,double) equals(x, y, eps)}
- * <li>negative if not equal and {@code x < y}
- * <li>positive if not equal and {@code x > y}
+ * <li>zero if considered equal using {@link
#equals(double,double,double) equals(x, y, eps)}</li>
+ * <li>negative if not equal and {@code x < y}</li>
+ * <li>positive if not equal and {@code x > y}</li>
* </ul>
*
* <p>NaN values are handled as if using {@link Double#compare(double,
double)} where the
* returned value is:
* <ul>
- * <li>zero if {@code NaN, NaN}
- * <li>negative if {@code !NaN, NaN}
- * <li>positive if {@code NaN, !NaN}
+ * <li>zero if {@code NaN, NaN}</li>
+ * <li>negative if {@code !NaN, NaN}</li>
+ * <li>positive if {@code NaN, !NaN}</li>
* </ul>
*
* @param x First value.
@@ -108,17 +108,17 @@ public final class Precision {
* Compares two numbers given some amount of allowed error.
* The returned value is:
* <ul>
- * <li>zero if considered equal using {@link #equals(double,double,int)
equals(x, y, maxUlps)}
- * <li>negative if not equal and {@code x < y}
- * <li>positive if not equal and {@code x > y}
+ * <li>zero if considered equal using {@link #equals(double,double,int)
equals(x, y, maxUlps)}</li>
+ * <li>negative if not equal and {@code x < y}</li>
+ * <li>positive if not equal and {@code x > y}</li>
* </ul>
*
* <p>NaN values are handled as if using {@link Double#compare(double,
double)} where the
* returned value is:
* <ul>
- * <li>zero if {@code NaN, NaN}
- * <li>negative if {@code !NaN, NaN}
- * <li>positive if {@code NaN, !NaN}
+ * <li>zero if {@code NaN, NaN}</li>
+ * <li>negative if {@code !NaN, NaN}</li>
+ * <li>positive if {@code NaN, !NaN}</li>
* </ul>
*
* @param x First value.
diff --git
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/DualPivotingStrategy.java
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/DualPivotingStrategy.java
index 5b2a99ee..edf8fe84 100644
---
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/DualPivotingStrategy.java
+++
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/DualPivotingStrategy.java
@@ -806,9 +806,9 @@ enum DualPivotingStrategy {
/**
* Get the effect on the sampled points.
* <ul>
- * <li>0 - Unchanged
- * <li>1 - Partially sorted
- * <li>2 - Sorted
+ * <li>0 - Unchanged</li>
+ * <li>1 - Partially sorted</li>
+ * <li>2 - Sorted</li>
* </ul>
*
* @return the effect
diff --git
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/IntervalAnalysis.java
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/IntervalAnalysis.java
index 393fbbc1..c1053def 100644
---
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/IntervalAnalysis.java
+++
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/IntervalAnalysis.java
@@ -35,10 +35,10 @@ interface IntervalAnalysis {
* <ol>
* <li>Use approximations for performance, for example
* compressing indices into blocks of the defined separation.
- * <pre>{@code c = (i - left) >> separation}</pre>
+ * <pre>{@code c = (i - left) >> separation}</pre></li>
* <li>Support only a range of the possible
* {@code separation} values in {@code [0, 30]}. Unsupported {@code
separation}
- * values should return {@code false}.
+ * values should return {@code false}.</li>
* </ol>
*
* @param separation Log2 of the maximum separation between indices.
diff --git
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/KthSelector.java
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/KthSelector.java
index d9652052..74d3e114 100644
---
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/KthSelector.java
+++
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/KthSelector.java
@@ -1521,10 +1521,10 @@ class KthSelector {
* <p>This method returns 4 points: the lower and upper pivots and bounds
for
* the internal range of unsorted values.
* <ul>
- * <li>k0: lower pivot point: {@code a[k] < a[k0]} for {@code k < k0}.
- * <li>k1: the start (inclusive) of the unsorted range: {@code k0 < k1}.
- * <li>k2: the end (inclusive) of the unsorted range: {@code k2 <= k3}.
- * <li>k3: upper pivot point: {@code a[k3] < a[k]} for {@code k3 < k}.
+ * <li>k0: lower pivot point: {@code a[k] < a[k0]} for {@code k < k0}.</li>
+ * <li>k1: the start (inclusive) of the unsorted range: {@code k0 <
k1}.</li>
+ * <li>k2: the end (inclusive) of the unsorted range: {@code k2 <=
k3}.</li>
+ * <li>k3: upper pivot point: {@code a[k3] < a[k]} for {@code k3 < k}.</li>
* </ul>
*
* <p>Bounds are set so {@code [k0, k1)} and {@code (k2, k3]} are fully
sorted.
@@ -1908,10 +1908,10 @@ class KthSelector {
* <p>This method returns 4 points: the lower and upper pivots and bounds
for
* the internal range of unsorted values.
* <ul>
- * <li>k0: lower pivot point: {@code a[k] < a[k0]} for {@code k < k0}.
- * <li>k1: the start (inclusive) of the unsorted range: {@code k0 < k1}.
- * <li>k2: the end (inclusive) of the unsorted range: {@code k2 <= k3}.
- * <li>k3: upper pivot point: {@code a[k3] < a[k]} for {@code k3 < k}.
+ * <li>k0: lower pivot point: {@code a[k] < a[k0]} for {@code k < k0}.</li>
+ * <li>k1: the start (inclusive) of the unsorted range: {@code k0 <
k1}.</li>
+ * <li>k2: the end (inclusive) of the unsorted range: {@code k2 <=
k3}.</li>
+ * <li>k3: upper pivot point: {@code a[k3] < a[k]} for {@code k3 < k}.</li>
* </ul>
*
* <p>Bounds are set so {@code [k0, k1)} and {@code (k2, k3]} are fully
sorted.
diff --git
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/Partition.java
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/Partition.java
index 2377254b..ce748984 100644
---
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/Partition.java
+++
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/Partition.java
@@ -86,38 +86,38 @@ import org.apache.commons.rng.simple.RandomSource;
* <li>
* Hoare (1961)
* Algorithm 65: Find
- * <a href="https://doi.org/10.1145%2F366622.366647";>Comm. ACM. 4 (7):
321–322</a>
+ * <a href="https://doi.org/10.1145%2F366622.366647";>Comm. ACM. 4 (7):
321–322</a></li>
* <li>
* Musser (1999)
* Introspective Sorting and Selection Algorithms
* <a
href="https://doi.org/10.1002/(SICI)1097-024X(199708)27:8%3C983::AID-SPE117%3E3.0.CO;2-%23">
- * Software: Practice and Experience 27, 983-993.</a>
+ * Software: Practice and Experience 27, 983-993.</a></li>
* <li>
* Wild, Nebel and Mahmoud (2013)
* Analysis of Quickselect under Yaroslavskiy's Dual-Pivoting Algorithm
- * <a href="https://doi.org/10.48550/arXiv.1306.3819";>arXiv:1306.3819</a>
+ * <a href="https://doi.org/10.48550/arXiv.1306.3819";>arXiv:1306.3819</a></li>
* <li>Floyd and Rivest (1975)
* Algorithm 489: The Algorithm SELECT - for Finding the ith Smallest of n
elements.
- * Comm. ACM. 18 (3): 173.
+ * Comm. ACM. 18 (3): 173.</li>
* <li>Kiwiel (2005)
* On Floyd and Rivest's SELECT algorithm.
* <a href="https://doi.org/10.1016/j.tcs.2005.06.032";>
- * Theoretical Computer Science 347, 214-238</a>.
+ * Theoretical Computer Science 347, 214-238</a>.</li>
* <li>Valois (2000)
* Introspective sorting and selection revisited
* <a
href="https://doi.org/10.1002/(SICI)1097-024X(200005)30:6%3C617::AID-SPE311%3E3.0.CO;2-A">
- * Software: Practice and Experience 30, 617-638.</a>
+ * Software: Practice and Experience 30, 617-638.</a></li>
* <li>Blum, Floyd, Pratt, Rivest, and Tarjan (1973)
* Time bounds for selection.
* <a href="https://doi.org/10.1016%2FS0022-0000%2873%2980033-9";>
- * Journal of Computer and System Sciences. 7 (4): 448–461</a>.
+ * Journal of Computer and System Sciences. 7 (4): 448–461</a>.</li>
* <li>Alexandrescu (2016)
* Fast Deterministic Selection
- * <a href="https://arxiv.org/abs/1606.00484";>arXiv:1606.00484</a>.
- * <li><a href="https://en.wikipedia.org/wiki/Quickselect";>Quickselect
(Wikipedia)</a>
- * <li><a href="https://en.wikipedia.org/wiki/Introsort";>Introsort
(Wikipedia)</a>
- * <li><a href="https://en.wikipedia.org/wiki/Introselect";>Introselect
(Wikipedia)</a>
- * <li><a href="https://en.wikipedia.org/wiki/Median_of_medians";>Median of
medians (Wikipedia)</a>
+ * <a href="https://arxiv.org/abs/1606.00484";>arXiv:1606.00484</a>.</li>
+ * <li><a href="https://en.wikipedia.org/wiki/Quickselect";>Quickselect
(Wikipedia)</a></li>
+ * <li><a href="https://en.wikipedia.org/wiki/Introsort";>Introsort
(Wikipedia)</a></li>
+ * <li><a href="https://en.wikipedia.org/wiki/Introselect";>Introselect
(Wikipedia)</a></li>
+ * <li><a href="https://en.wikipedia.org/wiki/Median_of_medians";>Median of
medians (Wikipedia)</a></li>
* </ol>
*
* @since 1.2
@@ -154,11 +154,11 @@ final class Partition {
*
* <p>If using insertion sort as the stopper for quickselect:
* <ul>
- * <li>Single-pivot: Benchmarking random data in range [96, 192] suggests
a value of ~16 for n=1.
+ * <li>Single-pivot: Benchmarking random data in range [96, 192] suggests
a value of ~16 for n=1.</li>
* <li>Dual-pivot: Benchmarking random data in range [162, 486] suggests a
value of ~27 for n=1
* and increasing with higher n in the same range.
* Dual-pivot sorting requires a value of ~120. If keys are saturated
between k1 and kn
- * an increase to this threshold will gain full sort performance.
+ * an increase to this threshold will gain full sort performance.</li>
* </ul> */
static final int MIN_QUICKSELECT_SIZE = 0;
/** Minimum size for heapselect.
@@ -842,8 +842,8 @@ final class Partition {
* | <P | ==P | >P |
* }</pre>
* <ul>
- * <li>k0: lower pivot point
- * <li>k1: upper pivot point
+ * <li>k0: lower pivot point</li>
+ * <li>k1: upper pivot point</li>
* </ul>
*
* @param a Data array.
@@ -1002,8 +1002,8 @@ final class Partition {
* | <P | ==P | >P |
* }</pre>
* <ul>
- * <li>k0: lower pivot point
- * <li>k1: upper pivot point (inclusive)
+ * <li>k0: lower pivot point</li>
+ * <li>k1: upper pivot point (inclusive)</li>
* </ul>
*
* @param a Data array.
@@ -1032,10 +1032,10 @@ final class Partition {
* | <P | ==P1 | <P1 && <P2 | ==P2 | >P |
* }</pre>
* <ul>
- * <li>k0: lower pivot1 point
- * <li>k1: upper pivot1 point (inclusive)
- * <li>k2: lower pivot2 point
- * <li>k3: upper pivot2 point (inclusive)
+ * <li>k0: lower pivot1 point</li>
+ * <li>k1: upper pivot1 point (inclusive)</li>
+ * <li>k2: lower pivot2 point</li>
+ * <li>k3: upper pivot2 point (inclusive)</li>
* </ul>
*
* <p>Bounds are set so {@code i < k0}, {@code i > k3} and {@code k1 <
i < k2} are
@@ -1100,8 +1100,8 @@ final class Partition {
* | <P | ==P | >P |
* }</pre>
* <ul>
- * <li>k0: lower pivot point
- * <li>k1: upper pivot point (inclusive)
+ * <li>k0: lower pivot point</li>
+ * <li>k1: upper pivot point (inclusive)</li>
* </ul>
*
* @param a Data array.
@@ -1197,12 +1197,12 @@ final class Partition {
* <ul>
* <li>Sample mode: Do not use all the data to create the pivot sample.
This is less expensive
* to compute but invalidates strict margins. The margin quality is better
than a random pivot
- * due to sampling a reasonable range of the data and using medians to
create the sample.
+ * due to sampling a reasonable range of the data and using medians to
create the sample.</li>
* <li>Adaption mode: Map the target {@code k} from the current range to
the size of the pivot
* sample. This create asymmetric margins and adapts the larger margin to
the position of
* {@code k} thus increasing the chance of eliminating a large amount of
data. However data
* randomness can create a larger margin so large it includes {@code k}
and partitioning
- * must eliminate a possibly very small other side.
+ * must eliminate a possibly very small other side.</li>
* </ul>
*
* <p>The quickselect adaptive paper suggests sampling mode is turned off
when margins are not
@@ -2698,18 +2698,18 @@ final class Partition {
* require a full sort. Start-up cost is higher. In practice the indices
do not saturate
* the range if the length is reasonable and it is typically possible to
cut between indices
* during partitioning to create regions that do not require visiting.
Thus trying to identify
- * regions for a full sort is a waste of resources.
+ * regions for a full sort is a waste of resources.</li>
* <li>{@link KeyStrategy#INDEX_SET}: Uses a {@code BitSet}-type structure
to store
* pivots during a call to partition. These can be used to bracket the
search for the next index.
* Storage of sparse indices is inefficient as it will require up to
length bits of the memory
- * of the input array length. Sparse ranges cannot be efficiently searched.
+ * of the input array length. Sparse ranges cannot be efficiently
searched.</li>
* <li>{@link KeyStrategy#PIVOT_CACHE}: The {@link PivotCache} interface
abstracts
* methods from a {@code BitSet}. Indices can be stored and searched. The
abstraction allows
* the pivots to be stored efficiently. However there are no sparse
implementations
* of the interface other than 1 or 2 points. So performance is similar to
the INDEX_SET
* method. One difference is the method finds the outer indices first and
then
* only searches the internal region for the rest of the indices. This
makes no difference
- * to performance.
+ * to performance.</li>
* </ul>
*
* <p>Note: In each method indices are processed independently. Thus each
bracket around an
@@ -6056,10 +6056,10 @@ final class Partition {
* <ul>
* <li>Floyd and Rivest (1975)
* Algorithm 489: The Algorithm SELECT—for Finding the ith Smallest of n
elements.
- * Comm. ACM. 18 (3): 173.
+ * Comm. ACM. 18 (3): 173.</li>
* <li>Kiwiel (2005)
* On Floyd and Rivest's SELECT algorithm.
- * Theoretical Computer Science 347, 214-238.
+ * Theoretical Computer Science 347, 214-238.</li>
* </ul>
*
* @param x Values.
@@ -8154,10 +8154,10 @@ final class Partition {
* }</pre>
*
* <ul>
- * <li>k0: lower pivot1 point
- * <li>k1: upper pivot1 point (inclusive)
- * <li>k2: lower pivot2 point
- * <li>k3: upper pivot2 point (inclusive)
+ * <li>k0: lower pivot1 point</li>
+ * <li>k1: upper pivot1 point (inclusive)</li>
+ * <li>k2: lower pivot2 point</li>
+ * <li>k3: upper pivot2 point (inclusive)</li>
* </ul>
*
* <p>Bounds are set so {@code i < k0}, {@code i > k3} and {@code k1 < i
< k2} are
@@ -10135,10 +10135,10 @@ final class Partition {
* <p>This is similar to using {@link java.util.Arrays#binarySearch(int[],
int, int, int)
* Arrays.binarySearch}. The method differs in:
* <ul>
- * <li>use of an inclusive upper bound;
- * <li>returning the closest index with a value below {@code key} if no
match was not found;
+ * <li>use of an inclusive upper bound;</li>
+ * <li>returning the closest index with a value below {@code key} if no
match was not found;</li>
* <li>performing no range checks: it is assumed {@code left <= right} and
they are valid
- * indices into the array.
+ * indices into the array.</li>
* </ul>
*
* <p>An equivalent use of binary search is:
@@ -10220,10 +10220,10 @@ final class Partition {
* <p>This is similar to using {@link java.util.Arrays#binarySearch(int[],
int, int, int)
* Arrays.binarySearch}. The method differs in:
* <ul>
- * <li>use of an inclusive upper bound;
- * <li>returning the closest index with a value above {@code key} if no
match was not found;
+ * <li>use of an inclusive upper bound;</li>
+ * <li>returning the closest index with a value above {@code key} if no
match was not found;</li>
* <li>performing no range checks: it is assumed {@code left <= right} and
they are valid
- * indices into the array.
+ * indices into the array.</li>
* </ul>
*
* <p>An equivalent use of binary search is:
diff --git
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/PartitionFactory.java
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/PartitionFactory.java
index 3ec33d64..ded8ee69 100644
---
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/PartitionFactory.java
+++
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/PartitionFactory.java
@@ -87,8 +87,8 @@ final class PartitionFactory {
*
* <p>Harvests:
* <ul>
- * <li>PivotingStrategy : enum name
- * <li>QSnn : minimum quickselect size of n
+ * <li>PivotingStrategy : enum name</li>
+ * <li>QSnn : minimum quickselect size of n</li>
* </ul>
*
* @param name Name.
@@ -139,24 +139,24 @@ final class PartitionFactory {
*
* <p>Harvests:
* <ul>
- * <li>PivotingStrategy : enum name
- * <li>DualPivotingStrategy : enum name
- * <li>QSn : minimum quickselect size of n
- * <li>ECn : minimum edgeselect constant of n
- * <li>LCn : minimum sortselect constant of n for linear selection
algorithms
- * <li>SUn : minimum sub-sampling size of n (for the Floyd-Rivest
algorithm)
- * <li>KeyStrategy : enum name
- * <li>PairedKeyStrategy : enum name
- * <li>RMn.n : recursion multiple of n.n (optional floating point) used to
set recursion limit for introspection
- * <li>RCn : recursion constant of n used to set recursion limit for
introspection
- * <li>CLn : compression level of n for compressed keys
- * <li>CFn : control flags of n
- * <li>SPStrategy : enum name
- * <li>ExpandStrategy : enum name
- * <li>LinearStrategy : enum name
- * <li>EdgeSelectStrategy : enum name
- * <li>StopperStrategy : enum name
- * <li>AdaptMode : enum name
+ * <li>PivotingStrategy : enum name</li>
+ * <li>DualPivotingStrategy : enum name</li>
+ * <li>QSn : minimum quickselect size of n</li>
+ * <li>ECn : minimum edgeselect constant of n</li>
+ * <li>LCn : minimum sortselect constant of n for linear selection
algorithms</li>
+ * <li>SUn : minimum sub-sampling size of n (for the Floyd-Rivest
algorithm)</li>
+ * <li>KeyStrategy : enum name</li>
+ * <li>PairedKeyStrategy : enum name</li>
+ * <li>RMn.n : recursion multiple of n.n (optional floating point) used to
set recursion limit for introspection</li>
+ * <li>RCn : recursion constant of n used to set recursion limit for
introspection</li>
+ * <li>CLn : compression level of n for compressed keys</li>
+ * <li>CFn : control flags of n</li>
+ * <li>SPStrategy : enum name</li>
+ * <li>ExpandStrategy : enum name</li>
+ * <li>LinearStrategy : enum name</li>
+ * <li>EdgeSelectStrategy : enum name</li>
+ * <li>StopperStrategy : enum name</li>
+ * <li>AdaptMode : enum name</li>
* </ul>
*
* @param name Name.
diff --git
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/PivotCache.java
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/PivotCache.java
index 89953c24..084894d5 100644
---
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/PivotCache.java
+++
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/PivotCache.java
@@ -45,9 +45,9 @@ package org.apache.commons.numbers.examples.jmh.arrays;
* <p>The cache provides the following functionality:
*
* <ul>
- * <li>Test if an index {@code [left <= k <= right]} is a known pivot.
- * <li>Return a {@code lower} bounding pivot for a partition of an index
{@code [left <= k <= right]}.
- * <li>Return an {@code upper} bounding pivot for a partition of an index
{@code [left <= k <= right]}.
+ * <li>Test if an index {@code [left <= k <= right]} is a known pivot.</li>
+ * <li>Return a {@code lower} bounding pivot for a partition of an index
{@code [left <= k <= right]}.</li>
+ * <li>Return an {@code upper} bounding pivot for a partition of an index
{@code [left <= k <= right]}.</li>
* </ul>
*
* <p>Note that searching with the bound {@code [lower, upper]} will reorder
data
@@ -58,11 +58,11 @@ package org.apache.commons.numbers.examples.jmh.arrays;
*
* <ol>
* <li>Process {@code k} indices in any order. Store all pivots during the
partitioning.
- * Each subsequent search after the first can use adjacent pivots to bracket
the search.
+ * Each subsequent search after the first can use adjacent pivots to bracket
the search.</li>
* <li>Process {@code k} indices in sorted order. The {@code lower} bound for
{@code k+1}
* will be {@code k <= lower}. This does not require a cache as {@code upper}
can be set
* using the end of the data {@code n}. For this case a cache can store pivots
which can
- * be used to bracket the search for {@code k+1}.
+ * be used to bracket the search for {@code k+1}.</li>
* </ol>
*
* <p>Implementations may assume indices are positive.
diff --git
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/PivotingStrategy.java
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/PivotingStrategy.java
index 59f2c0f5..e99c38b1 100644
---
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/PivotingStrategy.java
+++
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/PivotingStrategy.java
@@ -334,9 +334,9 @@ enum PivotingStrategy {
/**
* Get the effect on the sampled points.
* <ul>
- * <li>0 - Unchanged
- * <li>1 - Partially sorted
- * <li>2 - Sorted
+ * <li>0 - Unchanged</li>
+ * <li>1 - Partially sorted</li>
+ * <li>2 - Sorted</li>
* </ul>
*
* @return the effect
diff --git
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/SearchableInterval.java
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/SearchableInterval.java
index 541fac7c..1d703a33 100644
---
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/SearchableInterval.java
+++
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/SearchableInterval.java
@@ -22,9 +22,9 @@ package org.apache.commons.numbers.examples.jmh.arrays;
* <p>The interval provides the following functionality:
*
* <ul>
- * <li>Return the supported bounds of the search {@code [left <= right]}.
- * <li>Return the previous index contained in the interval from a search point
{@code k}.
- * <li>Return the next index contained in the interval from a search point
{@code k}.
+ * <li>Return the supported bounds of the search {@code [left <= right]}.</li>
+ * <li>Return the previous index contained in the interval from a search point
{@code k}.</li>
+ * <li>Return the next index contained in the interval from a search point
{@code k}.</li>
* </ul>
*
* <p>Note that the interval provides the supported bounds. If a search begins
outside
diff --git
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/SearchableInterval2.java
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/SearchableInterval2.java
index 13ae9c3e..3a78c9be 100644
---
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/SearchableInterval2.java
+++
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/SearchableInterval2.java
@@ -25,10 +25,10 @@ package org.apache.commons.numbers.examples.jmh.arrays;
* <p>The interval provides the following functionality:
*
* <ul>
- * <li>Return the supported bounds of the search pointers {@code [start <=
end]}.
- * <li>Return a pointer {@code j} to the previous index contained in the
interval from a search point {@code i}.
- * <li>Return a pointer {@code j} to the next index contained in the interval
from a search point {@code i}.
- * <li>Split the interval around two indices given search points {@code i1}
and {@code i2}.
+ * <li>Return the supported bounds of the search pointers {@code [start <=
end]}.</li>
+ * <li>Return a pointer {@code j} to the previous index contained in the
interval from a search point {@code i}.</li>
+ * <li>Return a pointer {@code j} to the next index contained in the interval
from a search point {@code i}.</li>
+ * <li>Split the interval around two indices given search points {@code i1}
and {@code i2}.</li>
* </ul>
*
* <p>Note that the interval provides the supported bounds. If a search begins
outside
diff --git
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/SelectionPerformance.java
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/SelectionPerformance.java
index 4f9cfed6..ecdbf4d2 100644
---
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/SelectionPerformance.java
+++
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/SelectionPerformance.java
@@ -167,9 +167,9 @@ public class SelectionPerformance {
* defaults for convenience. Re-use requires:
*
* <ol>
- * <li>Creating an instance of the abstract class that provides the data
length
- * <li>Calling {@link #setup()} to create the data
- * <li>Iterating over the data
+ * <li>Creating an instance of the abstract class that provides the data
length</li>
+ * <li>Calling {@link #setup()} to create the data</li>
+ * <li>Iterating over the data</li>
* </ol>
*
* <pre>
@@ -1201,13 +1201,13 @@ public class SelectionPerformance {
private int repeats;
/** Distribution mode. K indices can be distributed randomly or
uniformly.
* <ul>
- * <li>"random": distribute k indices randomly
- * <li>"uniform": distribute k indices uniformly but with a random
start point
- * <li>"index": Use a single index at k
+ * <li>"random": distribute k indices randomly</li>
+ * <li>"uniform": distribute k indices uniformly but with a random
start point</li>
+ * <li>"index": Use a single index at k</li>
* <li>"single": Use a single index at k uniformly spaced points. This
mode
* first generates the spacing for the indices. Then samples from that
spacing
* using the configured repeats. Common usage of k=10 will have 10
samples with a
- * single index, each in a different position.
+ * single index, each in a different position.</li>
* </ul>
* <p>If the mode ends with a "s" then the indices are sorted. For
example "randoms"
* will sort the random indices.
diff --git
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/SplittingInterval.java
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/SplittingInterval.java
index 1504f23c..07b630dd 100644
---
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/SplittingInterval.java
+++
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/SplittingInterval.java
@@ -22,8 +22,8 @@ package org.apache.commons.numbers.examples.jmh.arrays;
* <p>The interval provides the following functionality:
*
* <ul>
- * <li>Return the supported bounds of the interval {@code [left <= right]}.
- * <li>Split the interval around two indices {@code k1} and {@code k2}.
+ * <li>Return the supported bounds of the interval {@code [left <=
right]}.</li>
+ * <li>Split the interval around two indices {@code k1} and {@code k2}.</li>
* </ul>
*
* <p>Note that the interval provides the supported bounds. If a split
invalidates an interval
diff --git
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/UpdatingInterval.java
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/UpdatingInterval.java
index 7f2e6406..2097ec47 100644
---
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/UpdatingInterval.java
+++
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/arrays/UpdatingInterval.java
@@ -22,9 +22,9 @@ package org.apache.commons.numbers.examples.jmh.arrays;
* <p>The interval provides the following functionality:
*
* <ul>
- * <li>Return the supported bounds of the interval {@code [left <= right]}.
- * <li>Update the left or right bound of the interval using an index {@code k}
inside the interval.
- * <li>Split the interval around two indices {@code k1} and {@code k2}.
+ * <li>Return the supported bounds of the interval {@code [left <=
right]}.</li>
+ * <li>Update the left or right bound of the interval using an index {@code k}
inside the interval.</li>
+ * <li>Split the interval around two indices {@code k1} and {@code k2}.</li>
* </ul>
*
* <p>Note that the interval provides the supported bounds. If an index {@code
k} is
diff --git
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/core/DoublePrecision.java
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/core/DoublePrecision.java
index 0902c302..67a4cba5 100644
---
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/core/DoublePrecision.java
+++
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/core/DoublePrecision.java
@@ -151,8 +151,8 @@ final class DoublePrecision {
* <p>Special cases:
*
* <ul>
- * <li>If {@code x * y} is sub-normal or zero then the low part is 0.0.
- * <li>If {@code x * y} is infinite or NaN then the low part is NaN.
+ * <li>If {@code x * y} is sub-normal or zero then the low part is
0.0.</li>
+ * <li>If {@code x * y} is infinite or NaN then the low part is NaN.</li>
* </ul>
*
* <p>Note: This does not represent the low part of infinity with zero.
This is because the
@@ -379,8 +379,8 @@ final class DoublePrecision {
* <p>Special cases:
*
* <ul>
- * <li>If {@code x * y} is sub-normal or zero then the result is 0.0.
- * <li>If {@code x * y} is infinite or NaN then the result is NaN.
+ * <li>If {@code x * y} is sub-normal or zero then the result is 0.0.</li>
+ * <li>If {@code x * y} is infinite or NaN then the result is NaN.</li>
* </ul>
*
* @param x First factor.
@@ -459,8 +459,8 @@ final class DoublePrecision {
* <p>Special cases:
*
* <ul>
- * <li>If {@code x * y} is sub-normal or zero then the result is 0.0.
- * <li>If {@code x * y} is infinite or NaN then the result is NaN.
+ * <li>If {@code x * y} is sub-normal or zero then the result is 0.0.</li>
+ * <li>If {@code x * y} is infinite or NaN then the result is NaN.</li>
* </ul>
*
* @param x First factor.
@@ -531,8 +531,8 @@ final class DoublePrecision {
* <p>Special cases:
*
* <ul>
- * <li>If {@code x * y} is sub-normal or zero then the result is 0.0.
- * <li>If {@code x * y} is infinite or NaN then the result is NaN.
+ * <li>If {@code x * y} is sub-normal or zero then the result is 0.0.</li>
+ * <li>If {@code x * y} is infinite or NaN then the result is NaN.</li>
* </ul>
*
* @param x First factor.
@@ -589,11 +589,11 @@ final class DoublePrecision {
* <p>Special cases:
*
* <ul>
- * <li>If {@code x * y} is sub-normal or zero then the result is 0.0.
+ * <li>If {@code x * y} is sub-normal or zero then the result is 0.0.</li>
* <li>If {@code x * y} is infinite, and {@code x} and {@code y} are
finite then the
- * result is the opposite infinity.
- * <li>If {@code x} or {@code y} are infinite then the result is NaN.
- * <li>If {@code x * y} is NaN then the result is NaN.
+ * result is the opposite infinity.</li>
+ * <li>If {@code x} or {@code y} are infinite then the result is NaN.</li>
+ * <li>If {@code x * y} is NaN then the result is NaN.</li>
* </ul>
*
* @param x First factor.
@@ -641,8 +641,8 @@ final class DoublePrecision {
* <p>Special cases:
*
* <ul>
- * <li>If {@code x * y} is sub-normal or zero then the result is 0.0.
- * <li>If {@code x * y} is infinite or NaN then the result is NaN.
+ * <li>If {@code x * y} is sub-normal or zero then the result is 0.0.</li>
+ * <li>If {@code x * y} is infinite or NaN then the result is NaN.</li>
* </ul>
*
* @param x First factor.
diff --git
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/core/KolmogorovSmirnovDistribution.java
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/core/KolmogorovSmirnovDistribution.java
index c57fc507..d3bb2886 100644
---
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/core/KolmogorovSmirnovDistribution.java
+++
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/core/KolmogorovSmirnovDistribution.java
@@ -61,10 +61,10 @@ final class KolmogorovSmirnovDistribution {
* <li>
* van Mulbregt, P. (2018).
* <a href="https://doi.org/10.48550/arxiv.1802.06966";>Computing the
Cumulative Distribution Function and Quantiles of the One-sided
Kolmogorov-Smirnov Statistic</a>
- * arxiv:1802.06966.
+ * arxiv:1802.06966.</li>
* <li>Magg & Dicaire (1971).
* <a href="https://doi.org/10.1093/biomet/58.3.653";>On Kolmogorov-Smirnov
Type One-Sample Statistics</a>
- * Biometrika 58.3 pp. 653–656.
+ * Biometrika 58.3 pp. 653–656.</li>
* </ol>
*
* @since 1.1
diff --git
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/core/SDD.java
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/core/SDD.java
index d3413fa3..e3435443 100644
---
a/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/core/SDD.java
+++
b/commons-numbers-examples/examples-jmh/src/main/java/org/apache/commons/numbers/examples/jmh/core/SDD.java
@@ -44,15 +44,15 @@ package org.apache.commons.numbers.examples.jmh.core;
* Dekker, T.J. (1971)
* <a href="https://doi.org/10.1007/BF01397083";>
* A floating-point technique for extending the available precision</a>
- * Numerische Mathematik, 18:224–242.
+ * Numerische Mathematik, 18:224–242.</li>
* <li>
* Shewchuk, J.R. (1997)
* <a
href="https://www-2.cs.cmu.edu/afs/cs/project/quake/public/papers/robust-arithmetic.ps";>
- * Arbitrary Precision Floating-Point Arithmetic</a>.
+ * Arbitrary Precision Floating-Point Arithmetic</a>.</li>
* <li>
* Hide, Y, Li, X.S. and Bailey, D.H. (2008)
* <a href="https://www.davidhbailey.com/dhbpapers/qd.pdf";>
- * Library for Double-Double and Quad-Double Arithmetic</a>.
+ * Library for Double-Double and Quad-Double Arithmetic</a>.</li>
* </ol>
*
* @since 1.2
@@ -427,8 +427,8 @@ final class SDD {
* <p>This creates the following special cases:
*
* <ul>
- * <li>If {@code x * y} is sub-normal or zero then the low part is 0.0.
- * <li>If {@code x * y} is infinite or NaN then the low part is NaN.
+ * <li>If {@code x * y} is sub-normal or zero then the low part is
0.0.</li>
+ * <li>If {@code x * y} is infinite or NaN then the low part is NaN.</li>
* </ul>
*
* @param x First factor.
@@ -1036,12 +1036,12 @@ final class SDD {
*
* <p>Special cases:
* <ul>
- * <li>If {@code x} is zero, then the normalized fraction is zero and the
exponent is zero.
- * <li>If {@code x} is NaN, then the normalized fraction is NaN and the
exponent is unspecified.
- * <li>If {@code x} is infinite, then the normalized fraction is infinite
and the exponent is unspecified.
+ * <li>If {@code x} is zero, then the normalized fraction is zero and the
exponent is zero.</li>
+ * <li>If {@code x} is NaN, then the normalized fraction is NaN and the
exponent is unspecified.</li>
+ * <li>If {@code x} is infinite, then the normalized fraction is infinite
and the exponent is unspecified.</li>
* <li>If high-part {@code x} is an exact power of 2 and the low-part
{@code xx} has an opposite
* signed non-zero magnitude then fraction high-part {@code f} will be
{@code +/-1} such that
- * the double-double number is in the range {@code [0.5, 1)}.
+ * the double-double number is in the range {@code [0.5, 1)}.</li>
* </ul>
*
* <p>This is named using the equivalent function in the standard C math.h
library.
@@ -1102,8 +1102,8 @@ final class SDD {
*
* <p>Special cases:
* <ul>
- * <li>If the argument is NaN or infinite, then the result is {@link
Double#MAX_EXPONENT} + 1.
- * <li>If the argument is zero, then the result is {@link
Double#MAX_EXPONENT} + 1.
+ * <li>If the argument is NaN or infinite, then the result is {@link
Double#MAX_EXPONENT} + 1.</li>
+ * <li>If the argument is zero, then the result is {@link
Double#MAX_EXPONENT} + 1.</li>
* </ul>
*
* @param a Value.
@@ -1149,15 +1149,15 @@ final class SDD {
* <p>Special cases:
* <ul>
* <li>If {@code (x, xx)} is zero the high part of the fractional part is
- * computed using {@link Math#pow(double, double) Math.pow(x, n)} and the
exponent is 0.
- * <li>If {@code n = 0} the fractional part is 0.5 and the exponent is 1.
+ * computed using {@link Math#pow(double, double) Math.pow(x, n)} and the
exponent is 0.</li>
+ * <li>If {@code n = 0} the fractional part is 0.5 and the exponent is
1.</li>
* <li>If {@code (x, xx)} is an exact power of 2 the fractional part is
0.5 and the exponent
- * is the power of 2 minus 1.
+ * is the power of 2 minus 1.</li>
* <li>If the result high-part is an exact power of 2 and the low-part has
an opposite
* signed non-zero magnitude then the fraction high-part {@code f} will be
{@code +/-1} such that
* the double-double number is in the range {@code [0.5, 1)}.
* <p>If the argument is not finite then a fractional representation is
not possible.
- * In this case the fraction and the scale factor is undefined.
+ * In this case the fraction and the scale factor is undefined.</li>
* </ul>
*
* <p>Note: This method returns the exponent to avoid using an {@code
long[] exp} argument
@@ -1314,15 +1314,15 @@ final class SDD {
* <p>Special cases:
* <ul>
* <li>If {@code (x, xx)} is zero the high part of the fractional part is
- * computed using {@link Math#pow(double, double) Math.pow(x, n)} and the
exponent is 0.
- * <li>If {@code n = 0} the fractional part is 0.5 and the exponent is 1.
+ * computed using {@link Math#pow(double, double) Math.pow(x, n)} and the
exponent is 0.</li>
+ * <li>If {@code n = 0} the fractional part is 0.5 and the exponent is
1.</li>
* <li>If {@code (x, xx)} is an exact power of 2 the fractional part is
0.5 and the exponent
- * is the power of 2 minus 1.
+ * is the power of 2 minus 1.</li>
* <li>If the result high-part is an exact power of 2 and the low-part has
an opposite
* signed non-zero magnitude then the fraction high-part {@code f} will be
{@code +/-1} such that
* the double-double number is in the range {@code [0.5, 1)}.
* <p>If the argument is not finite then a fractional representation is
not possible.
- * In this case the fraction and the scale factor is undefined.
+ * In this case the fraction and the scale factor is undefined.</li>
* </ul>
*
* <p>Note: This method returns the exponent to avoid using an {@code
long[] exp} argument
diff --git
a/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/BigFraction.java
b/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/BigFraction.java
index 2bf62154..611d868f 100644
---
a/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/BigFraction.java
+++
b/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/BigFraction.java
@@ -110,10 +110,10 @@ public final class BigFraction
* </p>
* <ul>
* <li>EITHER a valid epsilon value and the maxDenominator set to
- * Integer.MAX_VALUE (that way the maxDenominator has no effect)
+ * Integer.MAX_VALUE (that way the maxDenominator has no effect)</li>
* <li>OR a valid maxDenominator value and the epsilon value set to
* zero (that way epsilon only has effect if there is an exact
- * match before the maxDenominator value is reached).
+ * match before the maxDenominator value is reached).</li>
* </ul>
* <p>
* It has been done this way so that the same code can be reused for
@@ -1022,9 +1022,9 @@ public final class BigFraction
* Returns the {@code String} representing this fraction.
* Uses:
* <ul>
- * <li>{@code "0"} if {@code numerator} is zero.
- * <li>{@code "numerator"} if {@code denominator} is one.
- * <li>{@code "numerator / denominator"} for all other cases.
+ * <li>{@code "0"} if {@code numerator} is zero.</li>
+ * <li>{@code "numerator"} if {@code denominator} is one.</li>
+ * <li>{@code "numerator / denominator"} for all other cases.</li>
* </ul>
*
* @return a string representation of the fraction.
diff --git
a/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/Fraction.java
b/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/Fraction.java
index e9280ff9..38f16024 100644
---
a/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/Fraction.java
+++
b/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/Fraction.java
@@ -125,10 +125,10 @@ public final class Fraction
* NOTE: This constructor is called with:
* <ul>
* <li>EITHER a valid epsilon value and the maxDenominator set to
- * Integer.MAX_VALUE (that way the maxDenominator has no effect)
+ * Integer.MAX_VALUE (that way the maxDenominator has no effect)</li>
* <li>OR a valid maxDenominator value and the epsilon value set to
* zero (that way epsilon only has effect if there is an exact
- * match before the maxDenominator value is reached).
+ * match before the maxDenominator value is reached).</li>
* </ul>
* <p>
* It has been done this way so that the same code can be reused for
@@ -827,9 +827,9 @@ public final class Fraction
* Returns the {@code String} representing this fraction.
* Uses:
* <ul>
- * <li>{@code "0"} if {@code numerator} is zero.
- * <li>{@code "numerator"} if {@code denominator} is one.
- * <li>{@code "numerator / denominator"} for all other cases.
+ * <li>{@code "0"} if {@code numerator} is zero.</li>
+ * <li>{@code "numerator"} if {@code denominator} is one.</li>
+ * <li>{@code "numerator / denominator"} for all other cases.</li>
* </ul>
*
* @return a string representation of the fraction.
diff --git
a/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/GeneralizedContinuedFraction.java
b/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/GeneralizedContinuedFraction.java
index abe68401..130f772d 100644
---
a/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/GeneralizedContinuedFraction.java
+++
b/commons-numbers-fraction/src/main/java/org/apache/commons/numbers/fraction/GeneralizedContinuedFraction.java
@@ -222,9 +222,9 @@ public final class GeneralizedContinuedFraction {
* Both of the first generated terms a and b are used. This fraction
evaluation
* can be used when:
* <ul>
- * <li>b<sub>0</sub> is not part of a regular series
- * <li>b<sub>0</sub> is zero and the result will evaluate only the
continued fraction component
- * <li>b<sub>0</sub> is very small and the result is expected to approach
zero
+ * <li>b<sub>0</sub> is not part of a regular series</li>
+ * <li>b<sub>0</sub> is zero and the result will evaluate only the
continued fraction component</li>
+ * <li>b<sub>0</sub> is very small and the result is expected to approach
zero</li>
* </ul>
*
* @param b0 Coefficient b<sub>0</sub>.
@@ -245,9 +245,9 @@ public final class GeneralizedContinuedFraction {
* Both of the first generated terms a and b are used. This fraction
evaluation
* can be used when:
* <ul>
- * <li>b<sub>0</sub> is not part of a regular series
- * <li>b<sub>0</sub> is zero and the result will evaluate only the
continued fraction component
- * <li>b<sub>0</sub> is very small and the result is expected to approach
zero
+ * <li>b<sub>0</sub> is not part of a regular series</li>
+ * <li>b<sub>0</sub> is zero and the result will evaluate only the
continued fraction component</li>
+ * <li>b<sub>0</sub> is very small and the result is expected to approach
zero</li>
* </ul>
*
* @param b0 Coefficient b<sub>0</sub>.
@@ -280,9 +280,9 @@ public final class GeneralizedContinuedFraction {
* Both of the first generated terms a and b are used. This fraction
evaluation
* can be used when:
* <ul>
- * <li>b<sub>0</sub> is not part of a regular series
- * <li>b<sub>0</sub> is zero and the result will evaluate only the
continued fraction component
- * <li>b<sub>0</sub> is very small and the result is expected to approach
zero
+ * <li>b<sub>0</sub> is not part of a regular series</li>
+ * <li>b<sub>0</sub> is zero and the result will evaluate only the
continued fraction component</li>
+ * <li>b<sub>0</sub> is very small and the result is expected to approach
zero</li>
* </ul>
*
* <p><b>Usage Note</b>
diff --git
a/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/Erf.java
b/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/Erf.java
index 6d86f6e1..02845317 100644
---
a/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/Erf.java
+++
b/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/Erf.java
@@ -36,10 +36,10 @@ public final class Erf {
*
* <p>Special cases:
* <ul>
- * <li>If the argument is 0, then the result is 0.
- * <li>If the argument is {@code > 6}, then the result is 1.
- * <li>If the argument is {@code < 6}, then the result is -1.
- * <li>If the argument is nan, then the result is nan.
+ * <li>If the argument is 0, then the result is 0.</li>
+ * <li>If the argument is {@code > 6}, then the result is 1.</li>
+ * <li>If the argument is {@code < 6}, then the result is -1.</li>
+ * <li>If the argument is nan, then the result is nan.</li>
* </ul>
*
* @param x the value.
diff --git
a/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/Erfc.java
b/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/Erfc.java
index 1becf570..c74197ec 100644
---
a/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/Erfc.java
+++
b/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/Erfc.java
@@ -39,10 +39,10 @@ public final class Erfc {
*
* <p>Special cases:
* <ul>
- * <li>If the argument is 0, then the result is 1.
- * <li>If the argument is {@code > 28}, then the result is 0.
- * <li>If the argument is {@code < 6}, then the result is 2.
- * <li>If the argument is nan, then the result is nan.
+ * <li>If the argument is 0, then the result is 1.</li>
+ * <li>If the argument is {@code > 28}, then the result is 0.</li>
+ * <li>If the argument is {@code < 6}, then the result is 2.</li>
+ * <li>If the argument is nan, then the result is nan.</li>
* </ul>
*
* @param x Value.
diff --git
a/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/Erfcx.java
b/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/Erfcx.java
index 486eb1ad..65509789 100644
---
a/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/Erfcx.java
+++
b/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/Erfcx.java
@@ -39,10 +39,10 @@ public final class Erfcx {
*
* <p>Special cases:
* <ul>
- * <li>If the argument is 0, then the result is 1.
- * <li>If the argument is +infinity, then the result is 0.
- * <li>If the argument is negative and {@code exp(x*x)} is infinite, then
the result is +infinity.
- * <li>If the argument is nan, then the result is nan.
+ * <li>If the argument is 0, then the result is 1.</li>
+ * <li>If the argument is +infinity, then the result is 0.</li>
+ * <li>If the argument is negative and {@code exp(x*x)} is infinite, then
the result is +infinity.</li>
+ * <li>If the argument is nan, then the result is nan.</li>
* </ul>
*
* @param x Value.
diff --git
a/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/Gamma.java
b/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/Gamma.java
index 5a9a58e3..c0186ffb 100644
---
a/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/Gamma.java
+++
b/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/Gamma.java
@@ -28,9 +28,9 @@ package org.apache.commons.numbers.gamma;
* <p>This code has been adapted from:
* <ul>
* <li>The <a href="https://www.boost.org/";>Boost</a>
- * {@code c++} implementation {@code
<boost/math/special_functions/gamma.hpp>}.
+ * {@code c++} implementation {@code
<boost/math/special_functions/gamma.hpp>}.</li>
* <li>The <em>NSWC Library of Mathematics Subroutines</em> double
- * precision implementation, {@code DGAMMA}.
+ * precision implementation, {@code DGAMMA}.</li>
* </ul>
*
* @see
diff --git
a/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/GammaRatio.java
b/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/GammaRatio.java
index f9247638..c6a1f424 100644
---
a/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/GammaRatio.java
+++
b/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/GammaRatio.java
@@ -25,7 +25,7 @@ package org.apache.commons.numbers.gamma;
* <p>This code has been adapted from:
* <ul>
* <li>The <a href="https://www.boost.org/";>Boost</a>
- * {@code c++} implementation {@code
<boost/math/special_functions/gamma.hpp>}.
+ * {@code c++} implementation {@code
<boost/math/special_functions/gamma.hpp>}.</li>
* </ul>
*
* @see
diff --git
a/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/InverseErf.java
b/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/InverseErf.java
index e264b4be..e9b378aa 100644
---
a/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/InverseErf.java
+++
b/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/InverseErf.java
@@ -30,11 +30,11 @@ public final class InverseErf {
*
* <p>Special cases:
* <ul>
- * <li>If the argument is 0, then the result is 0.
- * <li>If the argument is 1, then the result is positive infinity.
- * <li>If the argument is -1, then the result is negative infinity.
- * <li>If the argument is outside the interval {@code [-1, 1]}, then the
result is nan.
- * <li>If the argument is nan, then the result is nan.
+ * <li>If the argument is 0, then the result is 0.</li>
+ * <li>If the argument is 1, then the result is positive infinity.</li>
+ * <li>If the argument is -1, then the result is negative infinity.</li>
+ * <li>If the argument is outside the interval {@code [-1, 1]}, then the
result is nan.</li>
+ * <li>If the argument is nan, then the result is nan.</li>
* </ul>
*
* @param x Value (in {@code [-1, 1]})
diff --git
a/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/InverseErfc.java
b/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/InverseErfc.java
index 8ac7c252..53503cc3 100644
---
a/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/InverseErfc.java
+++
b/commons-numbers-gamma/src/main/java/org/apache/commons/numbers/gamma/InverseErfc.java
@@ -30,11 +30,11 @@ public final class InverseErfc {
*
* <p>Special cases:
* <ul>
- * <li>If the argument is 1, then the result is 0.
- * <li>If the argument is 0, then the result is positive infinity.
- * <li>If the argument is 2, then the result is negative infinity.
- * <li>If the argument is outside the interval {@code [0, 2]}, then the
result is nan.
- * <li>If the argument is nan, then the result is nan.
+ * <li>If the argument is 1, then the result is 0.</li>
+ * <li>If the argument is 0, then the result is positive infinity.</li>
+ * <li>If the argument is 2, then the result is negative infinity.</li>
+ * <li>If the argument is outside the interval {@code [0, 2]}, then the
result is nan.</li>
+ * <li>If the argument is nan, then the result is nan.</li>
* </ul>
*
* @param x Value (in {@code [0, 2]})
