svn commit: r1087362 [19/50] - in /websites/production/commons/content/proper/commons-lang: ./ apidocs/ apidocs/org/apache/commons/lang3/ apidocs/org/apache/commons/lang3/arch/ apidocs/org/apache/commons/lang3/arch/class-use/ apidocs/org/apache/commons...

Thu, 29 Aug 2024 12:59:45 -0700 

Modified: 
websites/production/commons/content/proper/commons-lang/apidocs/src-html/org/apache/commons/lang3/math/NumberUtils.html
==============================================================================
--- 
websites/production/commons/content/proper/commons-lang/apidocs/src-html/org/apache/commons/lang3/math/NumberUtils.html
 (original)
+++ 
websites/production/commons/content/proper/commons-lang/apidocs/src-html/org/apache/commons/lang3/math/NumberUtils.html
 Thu Aug 29 19:59:17 2024
@@ -797,1083 +797,1045 @@
 <span class="source-line-no">784</span><span id="line-784">    public static 
byte max(final byte... array) {</span>
 <span class="source-line-no">785</span><span id="line-785">        // 
Validates input</span>
 <span class="source-line-no">786</span><span id="line-786">        
validateArray(array);</span>
-<span class="source-line-no">787</span><span id="line-787"></span>
-<span class="source-line-no">788</span><span id="line-788">        // Finds 
and returns max</span>
-<span class="source-line-no">789</span><span id="line-789">        byte max = 
array[0];</span>
-<span class="source-line-no">790</span><span id="line-790">        for (int i 
= 1; i &lt; array.length; i++) {</span>
-<span class="source-line-no">791</span><span id="line-791">            if 
(array[i] &gt; max) {</span>
-<span class="source-line-no">792</span><span id="line-792">                max 
= array[i];</span>
-<span class="source-line-no">793</span><span id="line-793">            }</span>
-<span class="source-line-no">794</span><span id="line-794">        }</span>
-<span class="source-line-no">795</span><span id="line-795"></span>
-<span class="source-line-no">796</span><span id="line-796">        return 
max;</span>
-<span class="source-line-no">797</span><span id="line-797">    }</span>
-<span class="source-line-no">798</span><span id="line-798"></span>
-<span class="source-line-no">799</span><span id="line-799">    /**</span>
-<span class="source-line-no">800</span><span id="line-800">     * Gets the 
maximum of three {@code byte} values.</span>
-<span class="source-line-no">801</span><span id="line-801">     *</span>
-<span class="source-line-no">802</span><span id="line-802">     * @param a  
value 1</span>
-<span class="source-line-no">803</span><span id="line-803">     * @param b  
value 2</span>
-<span class="source-line-no">804</span><span id="line-804">     * @param c  
value 3</span>
-<span class="source-line-no">805</span><span id="line-805">     * @return  the 
largest of the values</span>
-<span class="source-line-no">806</span><span id="line-806">     */</span>
-<span class="source-line-no">807</span><span id="line-807">    public static 
byte max(byte a, final byte b, final byte c) {</span>
-<span class="source-line-no">808</span><span id="line-808">        if (b &gt; 
a) {</span>
-<span class="source-line-no">809</span><span id="line-809">            a = 
b;</span>
-<span class="source-line-no">810</span><span id="line-810">        }</span>
-<span class="source-line-no">811</span><span id="line-811">        if (c &gt; 
a) {</span>
-<span class="source-line-no">812</span><span id="line-812">            a = 
c;</span>
-<span class="source-line-no">813</span><span id="line-813">        }</span>
-<span class="source-line-no">814</span><span id="line-814">        return 
a;</span>
-<span class="source-line-no">815</span><span id="line-815">    }</span>
-<span class="source-line-no">816</span><span id="line-816"></span>
-<span class="source-line-no">817</span><span id="line-817">    /**</span>
-<span class="source-line-no">818</span><span id="line-818">     * Returns the 
maximum value in an array.</span>
-<span class="source-line-no">819</span><span id="line-819">     *</span>
-<span class="source-line-no">820</span><span id="line-820">     * @param array 
 an array, must not be null or empty</span>
-<span class="source-line-no">821</span><span id="line-821">     * @return the 
maximum value in the array</span>
-<span class="source-line-no">822</span><span id="line-822">     * @throws 
NullPointerException if {@code array} is {@code null}</span>
-<span class="source-line-no">823</span><span id="line-823">     * @throws 
IllegalArgumentException if {@code array} is empty</span>
-<span class="source-line-no">824</span><span id="line-824">     * @see 
IEEE754rUtils#max(double[]) IEEE754rUtils for a version of this method that 
handles NaN differently</span>
-<span class="source-line-no">825</span><span id="line-825">     * @since 3.4 
Changed signature from max(double[]) to max(double...)</span>
-<span class="source-line-no">826</span><span id="line-826">     */</span>
-<span class="source-line-no">827</span><span id="line-827">    public static 
double max(final double... array) {</span>
-<span class="source-line-no">828</span><span id="line-828">        // 
Validates input</span>
-<span class="source-line-no">829</span><span id="line-829">        
validateArray(array);</span>
-<span class="source-line-no">830</span><span id="line-830"></span>
-<span class="source-line-no">831</span><span id="line-831">        // Finds 
and returns max</span>
-<span class="source-line-no">832</span><span id="line-832">        double max 
= array[0];</span>
-<span class="source-line-no">833</span><span id="line-833">        for (int j 
= 1; j &lt; array.length; j++) {</span>
-<span class="source-line-no">834</span><span id="line-834">            if 
(Double.isNaN(array[j])) {</span>
-<span class="source-line-no">835</span><span id="line-835">                
return Double.NaN;</span>
+<span class="source-line-no">787</span><span id="line-787">        // Finds 
and returns max</span>
+<span class="source-line-no">788</span><span id="line-788">        byte max = 
array[0];</span>
+<span class="source-line-no">789</span><span id="line-789">        for (int i 
= 1; i &lt; array.length; i++) {</span>
+<span class="source-line-no">790</span><span id="line-790">            if 
(array[i] &gt; max) {</span>
+<span class="source-line-no">791</span><span id="line-791">                max 
= array[i];</span>
+<span class="source-line-no">792</span><span id="line-792">            }</span>
+<span class="source-line-no">793</span><span id="line-793">        }</span>
+<span class="source-line-no">794</span><span id="line-794">        return 
max;</span>
+<span class="source-line-no">795</span><span id="line-795">    }</span>
+<span class="source-line-no">796</span><span id="line-796"></span>
+<span class="source-line-no">797</span><span id="line-797">    /**</span>
+<span class="source-line-no">798</span><span id="line-798">     * Gets the 
maximum of three {@code byte} values.</span>
+<span class="source-line-no">799</span><span id="line-799">     *</span>
+<span class="source-line-no">800</span><span id="line-800">     * @param a  
value 1</span>
+<span class="source-line-no">801</span><span id="line-801">     * @param b  
value 2</span>
+<span class="source-line-no">802</span><span id="line-802">     * @param c  
value 3</span>
+<span class="source-line-no">803</span><span id="line-803">     * @return  the 
largest of the values</span>
+<span class="source-line-no">804</span><span id="line-804">     */</span>
+<span class="source-line-no">805</span><span id="line-805">    public static 
byte max(byte a, final byte b, final byte c) {</span>
+<span class="source-line-no">806</span><span id="line-806">        if (b &gt; 
a) {</span>
+<span class="source-line-no">807</span><span id="line-807">            a = 
b;</span>
+<span class="source-line-no">808</span><span id="line-808">        }</span>
+<span class="source-line-no">809</span><span id="line-809">        if (c &gt; 
a) {</span>
+<span class="source-line-no">810</span><span id="line-810">            a = 
c;</span>
+<span class="source-line-no">811</span><span id="line-811">        }</span>
+<span class="source-line-no">812</span><span id="line-812">        return 
a;</span>
+<span class="source-line-no">813</span><span id="line-813">    }</span>
+<span class="source-line-no">814</span><span id="line-814"></span>
+<span class="source-line-no">815</span><span id="line-815">    /**</span>
+<span class="source-line-no">816</span><span id="line-816">     * Returns the 
maximum value in an array.</span>
+<span class="source-line-no">817</span><span id="line-817">     *</span>
+<span class="source-line-no">818</span><span id="line-818">     * @param array 
 an array, must not be null or empty</span>
+<span class="source-line-no">819</span><span id="line-819">     * @return the 
maximum value in the array</span>
+<span class="source-line-no">820</span><span id="line-820">     * @throws 
NullPointerException if {@code array} is {@code null}</span>
+<span class="source-line-no">821</span><span id="line-821">     * @throws 
IllegalArgumentException if {@code array} is empty</span>
+<span class="source-line-no">822</span><span id="line-822">     * @see 
IEEE754rUtils#max(double[]) IEEE754rUtils for a version of this method that 
handles NaN differently</span>
+<span class="source-line-no">823</span><span id="line-823">     * @since 3.4 
Changed signature from max(double[]) to max(double...)</span>
+<span class="source-line-no">824</span><span id="line-824">     */</span>
+<span class="source-line-no">825</span><span id="line-825">    public static 
double max(final double... array) {</span>
+<span class="source-line-no">826</span><span id="line-826">        // 
Validates input</span>
+<span class="source-line-no">827</span><span id="line-827">        
validateArray(array);</span>
+<span class="source-line-no">828</span><span id="line-828">        // Finds 
and returns max</span>
+<span class="source-line-no">829</span><span id="line-829">        double max 
= array[0];</span>
+<span class="source-line-no">830</span><span id="line-830">        for (int j 
= 1; j &lt; array.length; j++) {</span>
+<span class="source-line-no">831</span><span id="line-831">            if 
(Double.isNaN(array[j])) {</span>
+<span class="source-line-no">832</span><span id="line-832">                
return Double.NaN;</span>
+<span class="source-line-no">833</span><span id="line-833">            }</span>
+<span class="source-line-no">834</span><span id="line-834">            if 
(array[j] &gt; max) {</span>
+<span class="source-line-no">835</span><span id="line-835">                max 
= array[j];</span>
 <span class="source-line-no">836</span><span id="line-836">            }</span>
-<span class="source-line-no">837</span><span id="line-837">            if 
(array[j] &gt; max) {</span>
-<span class="source-line-no">838</span><span id="line-838">                max 
= array[j];</span>
-<span class="source-line-no">839</span><span id="line-839">            }</span>
-<span class="source-line-no">840</span><span id="line-840">        }</span>
-<span class="source-line-no">841</span><span id="line-841"></span>
-<span class="source-line-no">842</span><span id="line-842">        return 
max;</span>
-<span class="source-line-no">843</span><span id="line-843">    }</span>
-<span class="source-line-no">844</span><span id="line-844"></span>
-<span class="source-line-no">845</span><span id="line-845">    /**</span>
-<span class="source-line-no">846</span><span id="line-846">     * Gets the 
maximum of three {@code double} values.</span>
-<span class="source-line-no">847</span><span id="line-847">     *</span>
-<span class="source-line-no">848</span><span id="line-848">     * &lt;p&gt;If 
any value is {@code NaN}, {@code NaN} is</span>
-<span class="source-line-no">849</span><span id="line-849">     * returned. 
Infinity is handled.&lt;/p&gt;</span>
-<span class="source-line-no">850</span><span id="line-850">     *</span>
-<span class="source-line-no">851</span><span id="line-851">     * @param a  
value 1</span>
-<span class="source-line-no">852</span><span id="line-852">     * @param b  
value 2</span>
-<span class="source-line-no">853</span><span id="line-853">     * @param c  
value 3</span>
-<span class="source-line-no">854</span><span id="line-854">     * @return  the 
largest of the values</span>
-<span class="source-line-no">855</span><span id="line-855">     * @see 
IEEE754rUtils#max(double, double, double) for a version of this method that 
handles NaN differently</span>
-<span class="source-line-no">856</span><span id="line-856">     */</span>
-<span class="source-line-no">857</span><span id="line-857">    public static 
double max(final double a, final double b, final double c) {</span>
-<span class="source-line-no">858</span><span id="line-858">        return 
Math.max(Math.max(a, b), c);</span>
-<span class="source-line-no">859</span><span id="line-859">    }</span>
-<span class="source-line-no">860</span><span id="line-860"></span>
-<span class="source-line-no">861</span><span id="line-861">    /**</span>
-<span class="source-line-no">862</span><span id="line-862">     * Returns the 
maximum value in an array.</span>
-<span class="source-line-no">863</span><span id="line-863">     *</span>
-<span class="source-line-no">864</span><span id="line-864">     * @param array 
 an array, must not be null or empty</span>
-<span class="source-line-no">865</span><span id="line-865">     * @return the 
maximum value in the array</span>
-<span class="source-line-no">866</span><span id="line-866">     * @throws 
NullPointerException if {@code array} is {@code null}</span>
-<span class="source-line-no">867</span><span id="line-867">     * @throws 
IllegalArgumentException if {@code array} is empty</span>
-<span class="source-line-no">868</span><span id="line-868">     * @see 
IEEE754rUtils#max(float[]) IEEE754rUtils for a version of this method that 
handles NaN differently</span>
-<span class="source-line-no">869</span><span id="line-869">     * @since 3.4 
Changed signature from max(float[]) to max(float...)</span>
-<span class="source-line-no">870</span><span id="line-870">     */</span>
-<span class="source-line-no">871</span><span id="line-871">    public static 
float max(final float... array) {</span>
-<span class="source-line-no">872</span><span id="line-872">        // 
Validates input</span>
-<span class="source-line-no">873</span><span id="line-873">        
validateArray(array);</span>
-<span class="source-line-no">874</span><span id="line-874"></span>
-<span class="source-line-no">875</span><span id="line-875">        // Finds 
and returns max</span>
-<span class="source-line-no">876</span><span id="line-876">        float max = 
array[0];</span>
-<span class="source-line-no">877</span><span id="line-877">        for (int j 
= 1; j &lt; array.length; j++) {</span>
-<span class="source-line-no">878</span><span id="line-878">            if 
(Float.isNaN(array[j])) {</span>
-<span class="source-line-no">879</span><span id="line-879">                
return Float.NaN;</span>
-<span class="source-line-no">880</span><span id="line-880">            }</span>
-<span class="source-line-no">881</span><span id="line-881">            if 
(array[j] &gt; max) {</span>
-<span class="source-line-no">882</span><span id="line-882">                max 
= array[j];</span>
-<span class="source-line-no">883</span><span id="line-883">            }</span>
-<span class="source-line-no">884</span><span id="line-884">        }</span>
-<span class="source-line-no">885</span><span id="line-885"></span>
-<span class="source-line-no">886</span><span id="line-886">        return 
max;</span>
-<span class="source-line-no">887</span><span id="line-887">    }</span>
-<span class="source-line-no">888</span><span id="line-888"></span>
-<span class="source-line-no">889</span><span id="line-889">    // must handle 
Long, Float, Integer, Float, Short,</span>
-<span class="source-line-no">890</span><span id="line-890">    //              
    BigDecimal, BigInteger and Byte</span>
-<span class="source-line-no">891</span><span id="line-891">    // useful 
methods:</span>
-<span class="source-line-no">892</span><span id="line-892">    // 
Byte.decode(String)</span>
-<span class="source-line-no">893</span><span id="line-893">    // 
Byte.valueOf(String, int radix)</span>
-<span class="source-line-no">894</span><span id="line-894">    // 
Byte.valueOf(String)</span>
-<span class="source-line-no">895</span><span id="line-895">    // 
Double.valueOf(String)</span>
-<span class="source-line-no">896</span><span id="line-896">    // 
Float.valueOf(String)</span>
-<span class="source-line-no">897</span><span id="line-897">    // 
Float.valueOf(String)</span>
-<span class="source-line-no">898</span><span id="line-898">    // 
Integer.valueOf(String, int radix)</span>
-<span class="source-line-no">899</span><span id="line-899">    // 
Integer.valueOf(String)</span>
-<span class="source-line-no">900</span><span id="line-900">    // 
Integer.decode(String)</span>
-<span class="source-line-no">901</span><span id="line-901">    // 
Integer.getInteger(String)</span>
-<span class="source-line-no">902</span><span id="line-902">    // 
Integer.getInteger(String, int val)</span>
-<span class="source-line-no">903</span><span id="line-903">    // 
Integer.getInteger(String, Integer val)</span>
-<span class="source-line-no">904</span><span id="line-904">    // 
Integer.valueOf(String)</span>
-<span class="source-line-no">905</span><span id="line-905">    // 
Double.valueOf(String)</span>
-<span class="source-line-no">906</span><span id="line-906">    // new 
Byte(String)</span>
-<span class="source-line-no">907</span><span id="line-907">    // 
Long.valueOf(String)</span>
-<span class="source-line-no">908</span><span id="line-908">    // 
Long.getLong(String)</span>
-<span class="source-line-no">909</span><span id="line-909">    // 
Long.getLong(String, int)</span>
-<span class="source-line-no">910</span><span id="line-910">    // 
Long.getLong(String, Integer)</span>
-<span class="source-line-no">911</span><span id="line-911">    // 
Long.valueOf(String, int)</span>
-<span class="source-line-no">912</span><span id="line-912">    // 
Long.valueOf(String)</span>
-<span class="source-line-no">913</span><span id="line-913">    // 
Short.valueOf(String)</span>
-<span class="source-line-no">914</span><span id="line-914">    // 
Short.decode(String)</span>
-<span class="source-line-no">915</span><span id="line-915">    // 
Short.valueOf(String, int)</span>
-<span class="source-line-no">916</span><span id="line-916">    // 
Short.valueOf(String)</span>
-<span class="source-line-no">917</span><span id="line-917">    // new 
BigDecimal(String)</span>
-<span class="source-line-no">918</span><span id="line-918">    // new 
BigInteger(String)</span>
-<span class="source-line-no">919</span><span id="line-919">    // new 
BigInteger(String, int radix)</span>
-<span class="source-line-no">920</span><span id="line-920">    // Possible 
inputs:</span>
-<span class="source-line-no">921</span><span id="line-921">    // 45 45.5 45E7 
4.5E7 Hex Oct Binary xxxF xxxD xxxf xxxd</span>
-<span class="source-line-no">922</span><span id="line-922">    // plus minus 
everything. Prolly more. A lot are not separable.</span>
-<span class="source-line-no">923</span><span id="line-923"></span>
-<span class="source-line-no">924</span><span id="line-924">    /**</span>
-<span class="source-line-no">925</span><span id="line-925">     * Gets the 
maximum of three {@code float} values.</span>
-<span class="source-line-no">926</span><span id="line-926">     *</span>
-<span class="source-line-no">927</span><span id="line-927">     * &lt;p&gt;If 
any value is {@code NaN}, {@code NaN} is</span>
-<span class="source-line-no">928</span><span id="line-928">     * returned. 
Infinity is handled.&lt;/p&gt;</span>
-<span class="source-line-no">929</span><span id="line-929">     *</span>
-<span class="source-line-no">930</span><span id="line-930">     * @param a  
value 1</span>
-<span class="source-line-no">931</span><span id="line-931">     * @param b  
value 2</span>
-<span class="source-line-no">932</span><span id="line-932">     * @param c  
value 3</span>
-<span class="source-line-no">933</span><span id="line-933">     * @return  the 
largest of the values</span>
-<span class="source-line-no">934</span><span id="line-934">     * @see 
IEEE754rUtils#max(float, float, float) for a version of this method that 
handles NaN differently</span>
-<span class="source-line-no">935</span><span id="line-935">     */</span>
-<span class="source-line-no">936</span><span id="line-936">    public static 
float max(final float a, final float b, final float c) {</span>
-<span class="source-line-no">937</span><span id="line-937">        return 
Math.max(Math.max(a, b), c);</span>
-<span class="source-line-no">938</span><span id="line-938">    }</span>
-<span class="source-line-no">939</span><span id="line-939"></span>
-<span class="source-line-no">940</span><span id="line-940">    /**</span>
-<span class="source-line-no">941</span><span id="line-941">     * Returns the 
maximum value in an array.</span>
-<span class="source-line-no">942</span><span id="line-942">     *</span>
-<span class="source-line-no">943</span><span id="line-943">     * @param array 
 an array, must not be null or empty</span>
-<span class="source-line-no">944</span><span id="line-944">     * @return the 
maximum value in the array</span>
-<span class="source-line-no">945</span><span id="line-945">     * @throws 
NullPointerException if {@code array} is {@code null}</span>
-<span class="source-line-no">946</span><span id="line-946">     * @throws 
IllegalArgumentException if {@code array} is empty</span>
-<span class="source-line-no">947</span><span id="line-947">     * @since 3.4 
Changed signature from max(int[]) to max(int...)</span>
-<span class="source-line-no">948</span><span id="line-948">     */</span>
-<span class="source-line-no">949</span><span id="line-949">    public static 
int max(final int... array) {</span>
-<span class="source-line-no">950</span><span id="line-950">        // 
Validates input</span>
-<span class="source-line-no">951</span><span id="line-951">        
validateArray(array);</span>
-<span class="source-line-no">952</span><span id="line-952"></span>
-<span class="source-line-no">953</span><span id="line-953">        // Finds 
and returns max</span>
-<span class="source-line-no">954</span><span id="line-954">        int max = 
array[0];</span>
-<span class="source-line-no">955</span><span id="line-955">        for (int j 
= 1; j &lt; array.length; j++) {</span>
-<span class="source-line-no">956</span><span id="line-956">            if 
(array[j] &gt; max) {</span>
-<span class="source-line-no">957</span><span id="line-957">                max 
= array[j];</span>
-<span class="source-line-no">958</span><span id="line-958">            }</span>
-<span class="source-line-no">959</span><span id="line-959">        }</span>
-<span class="source-line-no">960</span><span id="line-960"></span>
-<span class="source-line-no">961</span><span id="line-961">        return 
max;</span>
-<span class="source-line-no">962</span><span id="line-962">    }</span>
-<span class="source-line-no">963</span><span id="line-963"></span>
-<span class="source-line-no">964</span><span id="line-964">    /**</span>
-<span class="source-line-no">965</span><span id="line-965">     * Gets the 
maximum of three {@code int} values.</span>
-<span class="source-line-no">966</span><span id="line-966">     *</span>
-<span class="source-line-no">967</span><span id="line-967">     * @param a  
value 1</span>
-<span class="source-line-no">968</span><span id="line-968">     * @param b  
value 2</span>
-<span class="source-line-no">969</span><span id="line-969">     * @param c  
value 3</span>
-<span class="source-line-no">970</span><span id="line-970">     * @return  the 
largest of the values</span>
-<span class="source-line-no">971</span><span id="line-971">     */</span>
-<span class="source-line-no">972</span><span id="line-972">    public static 
int max(int a, final int b, final int c) {</span>
-<span class="source-line-no">973</span><span id="line-973">        if (b &gt; 
a) {</span>
-<span class="source-line-no">974</span><span id="line-974">            a = 
b;</span>
-<span class="source-line-no">975</span><span id="line-975">        }</span>
-<span class="source-line-no">976</span><span id="line-976">        if (c &gt; 
a) {</span>
-<span class="source-line-no">977</span><span id="line-977">            a = 
c;</span>
-<span class="source-line-no">978</span><span id="line-978">        }</span>
-<span class="source-line-no">979</span><span id="line-979">        return 
a;</span>
-<span class="source-line-no">980</span><span id="line-980">    }</span>
-<span class="source-line-no">981</span><span id="line-981"></span>
-<span class="source-line-no">982</span><span id="line-982">    /**</span>
-<span class="source-line-no">983</span><span id="line-983">     * Returns the 
maximum value in an array.</span>
-<span class="source-line-no">984</span><span id="line-984">     *</span>
-<span class="source-line-no">985</span><span id="line-985">     * @param array 
 an array, must not be null or empty</span>
-<span class="source-line-no">986</span><span id="line-986">     * @return the 
maximum value in the array</span>
-<span class="source-line-no">987</span><span id="line-987">     * @throws 
NullPointerException if {@code array} is {@code null}</span>
-<span class="source-line-no">988</span><span id="line-988">     * @throws 
IllegalArgumentException if {@code array} is empty</span>
-<span class="source-line-no">989</span><span id="line-989">     * @since 3.4 
Changed signature from max(long[]) to max(long...)</span>
-<span class="source-line-no">990</span><span id="line-990">     */</span>
-<span class="source-line-no">991</span><span id="line-991">    public static 
long max(final long... array) {</span>
-<span class="source-line-no">992</span><span id="line-992">        // 
Validates input</span>
-<span class="source-line-no">993</span><span id="line-993">        
validateArray(array);</span>
-<span class="source-line-no">994</span><span id="line-994"></span>
-<span class="source-line-no">995</span><span id="line-995">        // Finds 
and returns max</span>
-<span class="source-line-no">996</span><span id="line-996">        long max = 
array[0];</span>
-<span class="source-line-no">997</span><span id="line-997">        for (int j 
= 1; j &lt; array.length; j++) {</span>
-<span class="source-line-no">998</span><span id="line-998">            if 
(array[j] &gt; max) {</span>
-<span class="source-line-no">999</span><span id="line-999">                max 
= array[j];</span>
-<span class="source-line-no">1000</span><span id="line-1000">            
}</span>
-<span class="source-line-no">1001</span><span id="line-1001">        }</span>
-<span class="source-line-no">1002</span><span id="line-1002"></span>
-<span class="source-line-no">1003</span><span id="line-1003">        return 
max;</span>
-<span class="source-line-no">1004</span><span id="line-1004">    }</span>
-<span class="source-line-no">1005</span><span id="line-1005"></span>
-<span class="source-line-no">1006</span><span id="line-1006">    // 3 param 
max</span>
-<span class="source-line-no">1007</span><span id="line-1007">    /**</span>
-<span class="source-line-no">1008</span><span id="line-1008">     * Gets the 
maximum of three {@code long} values.</span>
-<span class="source-line-no">1009</span><span id="line-1009">     *</span>
-<span class="source-line-no">1010</span><span id="line-1010">     * @param a  
value 1</span>
-<span class="source-line-no">1011</span><span id="line-1011">     * @param b  
value 2</span>
-<span class="source-line-no">1012</span><span id="line-1012">     * @param c  
value 3</span>
-<span class="source-line-no">1013</span><span id="line-1013">     * @return  
the largest of the values</span>
-<span class="source-line-no">1014</span><span id="line-1014">     */</span>
-<span class="source-line-no">1015</span><span id="line-1015">    public static 
long max(long a, final long b, final long c) {</span>
-<span class="source-line-no">1016</span><span id="line-1016">        if (b 
&gt; a) {</span>
-<span class="source-line-no">1017</span><span id="line-1017">            a = 
b;</span>
-<span class="source-line-no">1018</span><span id="line-1018">        }</span>
-<span class="source-line-no">1019</span><span id="line-1019">        if (c 
&gt; a) {</span>
-<span class="source-line-no">1020</span><span id="line-1020">            a = 
c;</span>
-<span class="source-line-no">1021</span><span id="line-1021">        }</span>
-<span class="source-line-no">1022</span><span id="line-1022">        return 
a;</span>
-<span class="source-line-no">1023</span><span id="line-1023">    }</span>
-<span class="source-line-no">1024</span><span id="line-1024"></span>
-<span class="source-line-no">1025</span><span id="line-1025">    /**</span>
-<span class="source-line-no">1026</span><span id="line-1026">     * Returns 
the maximum value in an array.</span>
-<span class="source-line-no">1027</span><span id="line-1027">     *</span>
-<span class="source-line-no">1028</span><span id="line-1028">     * @param 
array  an array, must not be null or empty</span>
-<span class="source-line-no">1029</span><span id="line-1029">     * @return 
the maximum value in the array</span>
-<span class="source-line-no">1030</span><span id="line-1030">     * @throws 
NullPointerException if {@code array} is {@code null}</span>
-<span class="source-line-no">1031</span><span id="line-1031">     * @throws 
IllegalArgumentException if {@code array} is empty</span>
-<span class="source-line-no">1032</span><span id="line-1032">     * @since 3.4 
Changed signature from max(short[]) to max(short...)</span>
-<span class="source-line-no">1033</span><span id="line-1033">     */</span>
-<span class="source-line-no">1034</span><span id="line-1034">    public static 
short max(final short... array) {</span>
-<span class="source-line-no">1035</span><span id="line-1035">        // 
Validates input</span>
-<span class="source-line-no">1036</span><span id="line-1036">        
validateArray(array);</span>
+<span class="source-line-no">837</span><span id="line-837">        }</span>
+<span class="source-line-no">838</span><span id="line-838">        return 
max;</span>
+<span class="source-line-no">839</span><span id="line-839">    }</span>
+<span class="source-line-no">840</span><span id="line-840"></span>
+<span class="source-line-no">841</span><span id="line-841">    /**</span>
+<span class="source-line-no">842</span><span id="line-842">     * Gets the 
maximum of three {@code double} values.</span>
+<span class="source-line-no">843</span><span id="line-843">     *</span>
+<span class="source-line-no">844</span><span id="line-844">     * &lt;p&gt;If 
any value is {@code NaN}, {@code NaN} is</span>
+<span class="source-line-no">845</span><span id="line-845">     * returned. 
Infinity is handled.&lt;/p&gt;</span>
+<span class="source-line-no">846</span><span id="line-846">     *</span>
+<span class="source-line-no">847</span><span id="line-847">     * @param a  
value 1</span>
+<span class="source-line-no">848</span><span id="line-848">     * @param b  
value 2</span>
+<span class="source-line-no">849</span><span id="line-849">     * @param c  
value 3</span>
+<span class="source-line-no">850</span><span id="line-850">     * @return  the 
largest of the values</span>
+<span class="source-line-no">851</span><span id="line-851">     * @see 
IEEE754rUtils#max(double, double, double) for a version of this method that 
handles NaN differently</span>
+<span class="source-line-no">852</span><span id="line-852">     */</span>
+<span class="source-line-no">853</span><span id="line-853">    public static 
double max(final double a, final double b, final double c) {</span>
+<span class="source-line-no">854</span><span id="line-854">        return 
Math.max(Math.max(a, b), c);</span>
+<span class="source-line-no">855</span><span id="line-855">    }</span>
+<span class="source-line-no">856</span><span id="line-856"></span>
+<span class="source-line-no">857</span><span id="line-857">    /**</span>
+<span class="source-line-no">858</span><span id="line-858">     * Returns the 
maximum value in an array.</span>
+<span class="source-line-no">859</span><span id="line-859">     *</span>
+<span class="source-line-no">860</span><span id="line-860">     * @param array 
 an array, must not be null or empty</span>
+<span class="source-line-no">861</span><span id="line-861">     * @return the 
maximum value in the array</span>
+<span class="source-line-no">862</span><span id="line-862">     * @throws 
NullPointerException if {@code array} is {@code null}</span>
+<span class="source-line-no">863</span><span id="line-863">     * @throws 
IllegalArgumentException if {@code array} is empty</span>
+<span class="source-line-no">864</span><span id="line-864">     * @see 
IEEE754rUtils#max(float[]) IEEE754rUtils for a version of this method that 
handles NaN differently</span>
+<span class="source-line-no">865</span><span id="line-865">     * @since 3.4 
Changed signature from max(float[]) to max(float...)</span>
+<span class="source-line-no">866</span><span id="line-866">     */</span>
+<span class="source-line-no">867</span><span id="line-867">    public static 
float max(final float... array) {</span>
+<span class="source-line-no">868</span><span id="line-868">        // 
Validates input</span>
+<span class="source-line-no">869</span><span id="line-869">        
validateArray(array);</span>
+<span class="source-line-no">870</span><span id="line-870">        // Finds 
and returns max</span>
+<span class="source-line-no">871</span><span id="line-871">        float max = 
array[0];</span>
+<span class="source-line-no">872</span><span id="line-872">        for (int j 
= 1; j &lt; array.length; j++) {</span>
+<span class="source-line-no">873</span><span id="line-873">            if 
(Float.isNaN(array[j])) {</span>
+<span class="source-line-no">874</span><span id="line-874">                
return Float.NaN;</span>
+<span class="source-line-no">875</span><span id="line-875">            }</span>
+<span class="source-line-no">876</span><span id="line-876">            if 
(array[j] &gt; max) {</span>
+<span class="source-line-no">877</span><span id="line-877">                max 
= array[j];</span>
+<span class="source-line-no">878</span><span id="line-878">            }</span>
+<span class="source-line-no">879</span><span id="line-879">        }</span>
+<span class="source-line-no">880</span><span id="line-880">        return 
max;</span>
+<span class="source-line-no">881</span><span id="line-881">    }</span>
+<span class="source-line-no">882</span><span id="line-882"></span>
+<span class="source-line-no">883</span><span id="line-883">    // must handle 
Long, Float, Integer, Float, Short,</span>
+<span class="source-line-no">884</span><span id="line-884">    //              
    BigDecimal, BigInteger and Byte</span>
+<span class="source-line-no">885</span><span id="line-885">    // useful 
methods:</span>
+<span class="source-line-no">886</span><span id="line-886">    // 
Byte.decode(String)</span>
+<span class="source-line-no">887</span><span id="line-887">    // 
Byte.valueOf(String, int radix)</span>
+<span class="source-line-no">888</span><span id="line-888">    // 
Byte.valueOf(String)</span>
+<span class="source-line-no">889</span><span id="line-889">    // 
Double.valueOf(String)</span>
+<span class="source-line-no">890</span><span id="line-890">    // 
Float.valueOf(String)</span>
+<span class="source-line-no">891</span><span id="line-891">    // 
Float.valueOf(String)</span>
+<span class="source-line-no">892</span><span id="line-892">    // 
Integer.valueOf(String, int radix)</span>
+<span class="source-line-no">893</span><span id="line-893">    // 
Integer.valueOf(String)</span>
+<span class="source-line-no">894</span><span id="line-894">    // 
Integer.decode(String)</span>
+<span class="source-line-no">895</span><span id="line-895">    // 
Integer.getInteger(String)</span>
+<span class="source-line-no">896</span><span id="line-896">    // 
Integer.getInteger(String, int val)</span>
+<span class="source-line-no">897</span><span id="line-897">    // 
Integer.getInteger(String, Integer val)</span>
+<span class="source-line-no">898</span><span id="line-898">    // 
Integer.valueOf(String)</span>
+<span class="source-line-no">899</span><span id="line-899">    // 
Double.valueOf(String)</span>
+<span class="source-line-no">900</span><span id="line-900">    // new 
Byte(String)</span>
+<span class="source-line-no">901</span><span id="line-901">    // 
Long.valueOf(String)</span>
+<span class="source-line-no">902</span><span id="line-902">    // 
Long.getLong(String)</span>
+<span class="source-line-no">903</span><span id="line-903">    // 
Long.getLong(String, int)</span>
+<span class="source-line-no">904</span><span id="line-904">    // 
Long.getLong(String, Integer)</span>
+<span class="source-line-no">905</span><span id="line-905">    // 
Long.valueOf(String, int)</span>
+<span class="source-line-no">906</span><span id="line-906">    // 
Long.valueOf(String)</span>
+<span class="source-line-no">907</span><span id="line-907">    // 
Short.valueOf(String)</span>
+<span class="source-line-no">908</span><span id="line-908">    // 
Short.decode(String)</span>
+<span class="source-line-no">909</span><span id="line-909">    // 
Short.valueOf(String, int)</span>
+<span class="source-line-no">910</span><span id="line-910">    // 
Short.valueOf(String)</span>
+<span class="source-line-no">911</span><span id="line-911">    // new 
BigDecimal(String)</span>
+<span class="source-line-no">912</span><span id="line-912">    // new 
BigInteger(String)</span>
+<span class="source-line-no">913</span><span id="line-913">    // new 
BigInteger(String, int radix)</span>
+<span class="source-line-no">914</span><span id="line-914">    // Possible 
inputs:</span>
+<span class="source-line-no">915</span><span id="line-915">    // 45 45.5 45E7 
4.5E7 Hex Oct Binary xxxF xxxD xxxf xxxd</span>
+<span class="source-line-no">916</span><span id="line-916">    // plus minus 
everything. Prolly more. A lot are not separable.</span>
+<span class="source-line-no">917</span><span id="line-917"></span>
+<span class="source-line-no">918</span><span id="line-918">    /**</span>
+<span class="source-line-no">919</span><span id="line-919">     * Gets the 
maximum of three {@code float} values.</span>
+<span class="source-line-no">920</span><span id="line-920">     *</span>
+<span class="source-line-no">921</span><span id="line-921">     * &lt;p&gt;If 
any value is {@code NaN}, {@code NaN} is</span>
+<span class="source-line-no">922</span><span id="line-922">     * returned. 
Infinity is handled.&lt;/p&gt;</span>
+<span class="source-line-no">923</span><span id="line-923">     *</span>
+<span class="source-line-no">924</span><span id="line-924">     * @param a  
value 1</span>
+<span class="source-line-no">925</span><span id="line-925">     * @param b  
value 2</span>
+<span class="source-line-no">926</span><span id="line-926">     * @param c  
value 3</span>
+<span class="source-line-no">927</span><span id="line-927">     * @return  the 
largest of the values</span>
+<span class="source-line-no">928</span><span id="line-928">     * @see 
IEEE754rUtils#max(float, float, float) for a version of this method that 
handles NaN differently</span>
+<span class="source-line-no">929</span><span id="line-929">     */</span>
+<span class="source-line-no">930</span><span id="line-930">    public static 
float max(final float a, final float b, final float c) {</span>
+<span class="source-line-no">931</span><span id="line-931">        return 
Math.max(Math.max(a, b), c);</span>
+<span class="source-line-no">932</span><span id="line-932">    }</span>
+<span class="source-line-no">933</span><span id="line-933"></span>
+<span class="source-line-no">934</span><span id="line-934">    /**</span>
+<span class="source-line-no">935</span><span id="line-935">     * Returns the 
maximum value in an array.</span>
+<span class="source-line-no">936</span><span id="line-936">     *</span>
+<span class="source-line-no">937</span><span id="line-937">     * @param array 
 an array, must not be null or empty</span>
+<span class="source-line-no">938</span><span id="line-938">     * @return the 
maximum value in the array</span>
+<span class="source-line-no">939</span><span id="line-939">     * @throws 
NullPointerException if {@code array} is {@code null}</span>
+<span class="source-line-no">940</span><span id="line-940">     * @throws 
IllegalArgumentException if {@code array} is empty</span>
+<span class="source-line-no">941</span><span id="line-941">     * @since 3.4 
Changed signature from max(int[]) to max(int...)</span>
+<span class="source-line-no">942</span><span id="line-942">     */</span>
+<span class="source-line-no">943</span><span id="line-943">    public static 
int max(final int... array) {</span>
+<span class="source-line-no">944</span><span id="line-944">        // 
Validates input</span>
+<span class="source-line-no">945</span><span id="line-945">        
validateArray(array);</span>
+<span class="source-line-no">946</span><span id="line-946">        // Finds 
and returns max</span>
+<span class="source-line-no">947</span><span id="line-947">        int max = 
array[0];</span>
+<span class="source-line-no">948</span><span id="line-948">        for (int j 
= 1; j &lt; array.length; j++) {</span>
+<span class="source-line-no">949</span><span id="line-949">            if 
(array[j] &gt; max) {</span>
+<span class="source-line-no">950</span><span id="line-950">                max 
= array[j];</span>
+<span class="source-line-no">951</span><span id="line-951">            }</span>
+<span class="source-line-no">952</span><span id="line-952">        }</span>
+<span class="source-line-no">953</span><span id="line-953">        return 
max;</span>
+<span class="source-line-no">954</span><span id="line-954">    }</span>
+<span class="source-line-no">955</span><span id="line-955"></span>
+<span class="source-line-no">956</span><span id="line-956">    /**</span>
+<span class="source-line-no">957</span><span id="line-957">     * Gets the 
maximum of three {@code int} values.</span>
+<span class="source-line-no">958</span><span id="line-958">     *</span>
+<span class="source-line-no">959</span><span id="line-959">     * @param a  
value 1</span>
+<span class="source-line-no">960</span><span id="line-960">     * @param b  
value 2</span>
+<span class="source-line-no">961</span><span id="line-961">     * @param c  
value 3</span>
+<span class="source-line-no">962</span><span id="line-962">     * @return  the 
largest of the values</span>
+<span class="source-line-no">963</span><span id="line-963">     */</span>
+<span class="source-line-no">964</span><span id="line-964">    public static 
int max(int a, final int b, final int c) {</span>
+<span class="source-line-no">965</span><span id="line-965">        if (b &gt; 
a) {</span>
+<span class="source-line-no">966</span><span id="line-966">            a = 
b;</span>
+<span class="source-line-no">967</span><span id="line-967">        }</span>
+<span class="source-line-no">968</span><span id="line-968">        if (c &gt; 
a) {</span>
+<span class="source-line-no">969</span><span id="line-969">            a = 
c;</span>
+<span class="source-line-no">970</span><span id="line-970">        }</span>
+<span class="source-line-no">971</span><span id="line-971">        return 
a;</span>
+<span class="source-line-no">972</span><span id="line-972">    }</span>
+<span class="source-line-no">973</span><span id="line-973"></span>
+<span class="source-line-no">974</span><span id="line-974">    /**</span>
+<span class="source-line-no">975</span><span id="line-975">     * Returns the 
maximum value in an array.</span>
+<span class="source-line-no">976</span><span id="line-976">     *</span>
+<span class="source-line-no">977</span><span id="line-977">     * @param array 
 an array, must not be null or empty</span>
+<span class="source-line-no">978</span><span id="line-978">     * @return the 
maximum value in the array</span>
+<span class="source-line-no">979</span><span id="line-979">     * @throws 
NullPointerException if {@code array} is {@code null}</span>
+<span class="source-line-no">980</span><span id="line-980">     * @throws 
IllegalArgumentException if {@code array} is empty</span>
+<span class="source-line-no">981</span><span id="line-981">     * @since 3.4 
Changed signature from max(long[]) to max(long...)</span>
+<span class="source-line-no">982</span><span id="line-982">     */</span>
+<span class="source-line-no">983</span><span id="line-983">    public static 
long max(final long... array) {</span>
+<span class="source-line-no">984</span><span id="line-984">        // 
Validates input</span>
+<span class="source-line-no">985</span><span id="line-985">        
validateArray(array);</span>
+<span class="source-line-no">986</span><span id="line-986">        // Finds 
and returns max</span>
+<span class="source-line-no">987</span><span id="line-987">        long max = 
array[0];</span>
+<span class="source-line-no">988</span><span id="line-988">        for (int j 
= 1; j &lt; array.length; j++) {</span>
+<span class="source-line-no">989</span><span id="line-989">            if 
(array[j] &gt; max) {</span>
+<span class="source-line-no">990</span><span id="line-990">                max 
= array[j];</span>
+<span class="source-line-no">991</span><span id="line-991">            }</span>
+<span class="source-line-no">992</span><span id="line-992">        }</span>
+<span class="source-line-no">993</span><span id="line-993">        return 
max;</span>
+<span class="source-line-no">994</span><span id="line-994">    }</span>
+<span class="source-line-no">995</span><span id="line-995"></span>
+<span class="source-line-no">996</span><span id="line-996">    // 3 param 
max</span>
+<span class="source-line-no">997</span><span id="line-997">    /**</span>
+<span class="source-line-no">998</span><span id="line-998">     * Gets the 
maximum of three {@code long} values.</span>
+<span class="source-line-no">999</span><span id="line-999">     *</span>
+<span class="source-line-no">1000</span><span id="line-1000">     * @param a  
value 1</span>
+<span class="source-line-no">1001</span><span id="line-1001">     * @param b  
value 2</span>
+<span class="source-line-no">1002</span><span id="line-1002">     * @param c  
value 3</span>
+<span class="source-line-no">1003</span><span id="line-1003">     * @return  
the largest of the values</span>
+<span class="source-line-no">1004</span><span id="line-1004">     */</span>
+<span class="source-line-no">1005</span><span id="line-1005">    public static 
long max(long a, final long b, final long c) {</span>
+<span class="source-line-no">1006</span><span id="line-1006">        if (b 
&gt; a) {</span>
+<span class="source-line-no">1007</span><span id="line-1007">            a = 
b;</span>
+<span class="source-line-no">1008</span><span id="line-1008">        }</span>
+<span class="source-line-no">1009</span><span id="line-1009">        if (c 
&gt; a) {</span>
+<span class="source-line-no">1010</span><span id="line-1010">            a = 
c;</span>
+<span class="source-line-no">1011</span><span id="line-1011">        }</span>
+<span class="source-line-no">1012</span><span id="line-1012">        return 
a;</span>
+<span class="source-line-no">1013</span><span id="line-1013">    }</span>
+<span class="source-line-no">1014</span><span id="line-1014"></span>
+<span class="source-line-no">1015</span><span id="line-1015">    /**</span>
+<span class="source-line-no">1016</span><span id="line-1016">     * Returns 
the maximum value in an array.</span>
+<span class="source-line-no">1017</span><span id="line-1017">     *</span>
+<span class="source-line-no">1018</span><span id="line-1018">     * @param 
array  an array, must not be null or empty</span>
+<span class="source-line-no">1019</span><span id="line-1019">     * @return 
the maximum value in the array</span>
+<span class="source-line-no">1020</span><span id="line-1020">     * @throws 
NullPointerException if {@code array} is {@code null}</span>
+<span class="source-line-no">1021</span><span id="line-1021">     * @throws 
IllegalArgumentException if {@code array} is empty</span>
+<span class="source-line-no">1022</span><span id="line-1022">     * @since 3.4 
Changed signature from max(short[]) to max(short...)</span>
+<span class="source-line-no">1023</span><span id="line-1023">     */</span>
+<span class="source-line-no">1024</span><span id="line-1024">    public static 
short max(final short... array) {</span>
+<span class="source-line-no">1025</span><span id="line-1025">        // 
Validates input</span>
+<span class="source-line-no">1026</span><span id="line-1026">        
validateArray(array);</span>
+<span class="source-line-no">1027</span><span id="line-1027"></span>
+<span class="source-line-no">1028</span><span id="line-1028">        // Finds 
and returns max</span>
+<span class="source-line-no">1029</span><span id="line-1029">        short max 
= array[0];</span>
+<span class="source-line-no">1030</span><span id="line-1030">        for (int 
i = 1; i &lt; array.length; i++) {</span>
+<span class="source-line-no">1031</span><span id="line-1031">            if 
(array[i] &gt; max) {</span>
+<span class="source-line-no">1032</span><span id="line-1032">                
max = array[i];</span>
+<span class="source-line-no">1033</span><span id="line-1033">            
}</span>
+<span class="source-line-no">1034</span><span id="line-1034">        }</span>
+<span class="source-line-no">1035</span><span id="line-1035">        return 
max;</span>
+<span class="source-line-no">1036</span><span id="line-1036">    }</span>
 <span class="source-line-no">1037</span><span id="line-1037"></span>
-<span class="source-line-no">1038</span><span id="line-1038">        // Finds 
and returns max</span>
-<span class="source-line-no">1039</span><span id="line-1039">        short max 
= array[0];</span>
-<span class="source-line-no">1040</span><span id="line-1040">        for (int 
i = 1; i &lt; array.length; i++) {</span>
-<span class="source-line-no">1041</span><span id="line-1041">            if 
(array[i] &gt; max) {</span>
-<span class="source-line-no">1042</span><span id="line-1042">                
max = array[i];</span>
-<span class="source-line-no">1043</span><span id="line-1043">            
}</span>
-<span class="source-line-no">1044</span><span id="line-1044">        }</span>
-<span class="source-line-no">1045</span><span id="line-1045"></span>
-<span class="source-line-no">1046</span><span id="line-1046">        return 
max;</span>
-<span class="source-line-no">1047</span><span id="line-1047">    }</span>
-<span class="source-line-no">1048</span><span id="line-1048"></span>
-<span class="source-line-no">1049</span><span id="line-1049">    /**</span>
-<span class="source-line-no">1050</span><span id="line-1050">     * Gets the 
maximum of three {@code short} values.</span>
-<span class="source-line-no">1051</span><span id="line-1051">     *</span>
-<span class="source-line-no">1052</span><span id="line-1052">     * @param a  
value 1</span>
-<span class="source-line-no">1053</span><span id="line-1053">     * @param b  
value 2</span>
-<span class="source-line-no">1054</span><span id="line-1054">     * @param c  
value 3</span>
-<span class="source-line-no">1055</span><span id="line-1055">     * @return  
the largest of the values</span>
-<span class="source-line-no">1056</span><span id="line-1056">     */</span>
-<span class="source-line-no">1057</span><span id="line-1057">    public static 
short max(short a, final short b, final short c) {</span>
-<span class="source-line-no">1058</span><span id="line-1058">        if (b 
&gt; a) {</span>
-<span class="source-line-no">1059</span><span id="line-1059">            a = 
b;</span>
-<span class="source-line-no">1060</span><span id="line-1060">        }</span>
-<span class="source-line-no">1061</span><span id="line-1061">        if (c 
&gt; a) {</span>
-<span class="source-line-no">1062</span><span id="line-1062">            a = 
c;</span>
-<span class="source-line-no">1063</span><span id="line-1063">        }</span>
-<span class="source-line-no">1064</span><span id="line-1064">        return 
a;</span>
-<span class="source-line-no">1065</span><span id="line-1065">    }</span>
-<span class="source-line-no">1066</span><span id="line-1066"></span>
-<span class="source-line-no">1067</span><span id="line-1067">    /**</span>
-<span class="source-line-no">1068</span><span id="line-1068">     * Returns 
the minimum value in an array.</span>
-<span class="source-line-no">1069</span><span id="line-1069">     *</span>
-<span class="source-line-no">1070</span><span id="line-1070">     * @param 
array  an array, must not be null or empty</span>
-<span class="source-line-no">1071</span><span id="line-1071">     * @return 
the minimum value in the array</span>
-<span class="source-line-no">1072</span><span id="line-1072">     * @throws 
NullPointerException if {@code array} is {@code null}</span>
-<span class="source-line-no">1073</span><span id="line-1073">     * @throws 
IllegalArgumentException if {@code array} is empty</span>
-<span class="source-line-no">1074</span><span id="line-1074">     * @since 3.4 
Changed signature from min(byte[]) to min(byte...)</span>
-<span class="source-line-no">1075</span><span id="line-1075">     */</span>
-<span class="source-line-no">1076</span><span id="line-1076">    public static 
byte min(final byte... array) {</span>
-<span class="source-line-no">1077</span><span id="line-1077">        // 
Validates input</span>
-<span class="source-line-no">1078</span><span id="line-1078">        
validateArray(array);</span>
-<span class="source-line-no">1079</span><span id="line-1079"></span>
-<span class="source-line-no">1080</span><span id="line-1080">        // Finds 
and returns min</span>
-<span class="source-line-no">1081</span><span id="line-1081">        byte min 
= array[0];</span>
-<span class="source-line-no">1082</span><span id="line-1082">        for (int 
i = 1; i &lt; array.length; i++) {</span>
-<span class="source-line-no">1083</span><span id="line-1083">            if 
(array[i] &lt; min) {</span>
-<span class="source-line-no">1084</span><span id="line-1084">                
min = array[i];</span>
-<span class="source-line-no">1085</span><span id="line-1085">            
}</span>
-<span class="source-line-no">1086</span><span id="line-1086">        }</span>
-<span class="source-line-no">1087</span><span id="line-1087"></span>
-<span class="source-line-no">1088</span><span id="line-1088">        return 
min;</span>
-<span class="source-line-no">1089</span><span id="line-1089">    }</span>
-<span class="source-line-no">1090</span><span id="line-1090"></span>
-<span class="source-line-no">1091</span><span id="line-1091">    /**</span>
-<span class="source-line-no">1092</span><span id="line-1092">     * Gets the 
minimum of three {@code byte} values.</span>
-<span class="source-line-no">1093</span><span id="line-1093">     *</span>
-<span class="source-line-no">1094</span><span id="line-1094">     * @param a  
value 1</span>
-<span class="source-line-no">1095</span><span id="line-1095">     * @param b  
value 2</span>
-<span class="source-line-no">1096</span><span id="line-1096">     * @param c  
value 3</span>
-<span class="source-line-no">1097</span><span id="line-1097">     * @return  
the smallest of the values</span>
-<span class="source-line-no">1098</span><span id="line-1098">     */</span>
-<span class="source-line-no">1099</span><span id="line-1099">    public static 
byte min(byte a, final byte b, final byte c) {</span>
-<span class="source-line-no">1100</span><span id="line-1100">        if (b 
&lt; a) {</span>
-<span class="source-line-no">1101</span><span id="line-1101">            a = 
b;</span>
-<span class="source-line-no">1102</span><span id="line-1102">        }</span>
-<span class="source-line-no">1103</span><span id="line-1103">        if (c 
&lt; a) {</span>
-<span class="source-line-no">1104</span><span id="line-1104">            a = 
c;</span>
-<span class="source-line-no">1105</span><span id="line-1105">        }</span>
-<span class="source-line-no">1106</span><span id="line-1106">        return 
a;</span>
-<span class="source-line-no">1107</span><span id="line-1107">    }</span>
-<span class="source-line-no">1108</span><span id="line-1108"></span>
-<span class="source-line-no">1109</span><span id="line-1109">    /**</span>
-<span class="source-line-no">1110</span><span id="line-1110">     * Returns 
the minimum value in an array.</span>
-<span class="source-line-no">1111</span><span id="line-1111">     *</span>
-<span class="source-line-no">1112</span><span id="line-1112">     * @param 
array  an array, must not be null or empty</span>
-<span class="source-line-no">1113</span><span id="line-1113">     * @return 
the minimum value in the array</span>
-<span class="source-line-no">1114</span><span id="line-1114">     * @throws 
NullPointerException if {@code array} is {@code null}</span>
-<span class="source-line-no">1115</span><span id="line-1115">     * @throws 
IllegalArgumentException if {@code array} is empty</span>
-<span class="source-line-no">1116</span><span id="line-1116">     * @see 
IEEE754rUtils#min(double[]) IEEE754rUtils for a version of this method that 
handles NaN differently</span>
-<span class="source-line-no">1117</span><span id="line-1117">     * @since 3.4 
Changed signature from min(double[]) to min(double...)</span>
-<span class="source-line-no">1118</span><span id="line-1118">     */</span>
-<span class="source-line-no">1119</span><span id="line-1119">    public static 
double min(final double... array) {</span>
-<span class="source-line-no">1120</span><span id="line-1120">        // 
Validates input</span>
-<span class="source-line-no">1121</span><span id="line-1121">        
validateArray(array);</span>
+<span class="source-line-no">1038</span><span id="line-1038">    /**</span>
+<span class="source-line-no">1039</span><span id="line-1039">     * Gets the 
maximum of three {@code short} values.</span>
+<span class="source-line-no">1040</span><span id="line-1040">     *</span>
+<span class="source-line-no">1041</span><span id="line-1041">     * @param a  
value 1</span>
+<span class="source-line-no">1042</span><span id="line-1042">     * @param b  
value 2</span>
+<span class="source-line-no">1043</span><span id="line-1043">     * @param c  
value 3</span>
+<span class="source-line-no">1044</span><span id="line-1044">     * @return  
the largest of the values</span>
+<span class="source-line-no">1045</span><span id="line-1045">     */</span>
+<span class="source-line-no">1046</span><span id="line-1046">    public static 
short max(short a, final short b, final short c) {</span>
+<span class="source-line-no">1047</span><span id="line-1047">        if (b 
&gt; a) {</span>
+<span class="source-line-no">1048</span><span id="line-1048">            a = 
b;</span>
+<span class="source-line-no">1049</span><span id="line-1049">        }</span>
+<span class="source-line-no">1050</span><span id="line-1050">        if (c 
&gt; a) {</span>
+<span class="source-line-no">1051</span><span id="line-1051">            a = 
c;</span>
+<span class="source-line-no">1052</span><span id="line-1052">        }</span>
+<span class="source-line-no">1053</span><span id="line-1053">        return 
a;</span>
+<span class="source-line-no">1054</span><span id="line-1054">    }</span>
+<span class="source-line-no">1055</span><span id="line-1055"></span>
+<span class="source-line-no">1056</span><span id="line-1056">    /**</span>
+<span class="source-line-no">1057</span><span id="line-1057">     * Returns 
the minimum value in an array.</span>
+<span class="source-line-no">1058</span><span id="line-1058">     *</span>
+<span class="source-line-no">1059</span><span id="line-1059">     * @param 
array  an array, must not be null or empty</span>
+<span class="source-line-no">1060</span><span id="line-1060">     * @return 
the minimum value in the array</span>
+<span class="source-line-no">1061</span><span id="line-1061">     * @throws 
NullPointerException if {@code array} is {@code null}</span>
+<span class="source-line-no">1062</span><span id="line-1062">     * @throws 
IllegalArgumentException if {@code array} is empty</span>
+<span class="source-line-no">1063</span><span id="line-1063">     * @since 3.4 
Changed signature from min(byte[]) to min(byte...)</span>
+<span class="source-line-no">1064</span><span id="line-1064">     */</span>
+<span class="source-line-no">1065</span><span id="line-1065">    public static 
byte min(final byte... array) {</span>
+<span class="source-line-no">1066</span><span id="line-1066">        // 
Validates input</span>
+<span class="source-line-no">1067</span><span id="line-1067">        
validateArray(array);</span>
+<span class="source-line-no">1068</span><span id="line-1068">        // Finds 
and returns min</span>
+<span class="source-line-no">1069</span><span id="line-1069">        byte min 
= array[0];</span>
+<span class="source-line-no">1070</span><span id="line-1070">        for (int 
i = 1; i &lt; array.length; i++) {</span>
+<span class="source-line-no">1071</span><span id="line-1071">            if 
(array[i] &lt; min) {</span>
+<span class="source-line-no">1072</span><span id="line-1072">                
min = array[i];</span>
+<span class="source-line-no">1073</span><span id="line-1073">            
}</span>
+<span class="source-line-no">1074</span><span id="line-1074">        }</span>
+<span class="source-line-no">1075</span><span id="line-1075">        return 
min;</span>
+<span class="source-line-no">1076</span><span id="line-1076">    }</span>
+<span class="source-line-no">1077</span><span id="line-1077"></span>
+<span class="source-line-no">1078</span><span id="line-1078">    /**</span>
+<span class="source-line-no">1079</span><span id="line-1079">     * Gets the 
minimum of three {@code byte} values.</span>
+<span class="source-line-no">1080</span><span id="line-1080">     *</span>
+<span class="source-line-no">1081</span><span id="line-1081">     * @param a  
value 1</span>
+<span class="source-line-no">1082</span><span id="line-1082">     * @param b  
value 2</span>
+<span class="source-line-no">1083</span><span id="line-1083">     * @param c  
value 3</span>
+<span class="source-line-no">1084</span><span id="line-1084">     * @return  
the smallest of the values</span>
+<span class="source-line-no">1085</span><span id="line-1085">     */</span>
+<span class="source-line-no">1086</span><span id="line-1086">    public static 
byte min(byte a, final byte b, final byte c) {</span>
+<span class="source-line-no">1087</span><span id="line-1087">        if (b 
&lt; a) {</span>
+<span class="source-line-no">1088</span><span id="line-1088">            a = 
b;</span>
+<span class="source-line-no">1089</span><span id="line-1089">        }</span>
+<span class="source-line-no">1090</span><span id="line-1090">        if (c 
&lt; a) {</span>
+<span class="source-line-no">1091</span><span id="line-1091">            a = 
c;</span>
+<span class="source-line-no">1092</span><span id="line-1092">        }</span>
+<span class="source-line-no">1093</span><span id="line-1093">        return 
a;</span>
+<span class="source-line-no">1094</span><span id="line-1094">    }</span>
+<span class="source-line-no">1095</span><span id="line-1095"></span>
+<span class="source-line-no">1096</span><span id="line-1096">    /**</span>
+<span class="source-line-no">1097</span><span id="line-1097">     * Returns 
the minimum value in an array.</span>
+<span class="source-line-no">1098</span><span id="line-1098">     *</span>
+<span class="source-line-no">1099</span><span id="line-1099">     * @param 
array  an array, must not be null or empty</span>
+<span class="source-line-no">1100</span><span id="line-1100">     * @return 
the minimum value in the array</span>
+<span class="source-line-no">1101</span><span id="line-1101">     * @throws 
NullPointerException if {@code array} is {@code null}</span>
+<span class="source-line-no">1102</span><span id="line-1102">     * @throws 
IllegalArgumentException if {@code array} is empty</span>
+<span class="source-line-no">1103</span><span id="line-1103">     * @see 
IEEE754rUtils#min(double[]) IEEE754rUtils for a version of this method that 
handles NaN differently</span>
+<span class="source-line-no">1104</span><span id="line-1104">     * @since 3.4 
Changed signature from min(double[]) to min(double...)</span>
+<span class="source-line-no">1105</span><span id="line-1105">     */</span>
+<span class="source-line-no">1106</span><span id="line-1106">    public static 
double min(final double... array) {</span>
+<span class="source-line-no">1107</span><span id="line-1107">        // 
Validates input</span>
+<span class="source-line-no">1108</span><span id="line-1108">        
validateArray(array);</span>
+<span class="source-line-no">1109</span><span id="line-1109"></span>
+<span class="source-line-no">1110</span><span id="line-1110">        // Finds 
and returns min</span>
+<span class="source-line-no">1111</span><span id="line-1111">        double 
min = array[0];</span>
+<span class="source-line-no">1112</span><span id="line-1112">        for (int 
i = 1; i &lt; array.length; i++) {</span>
+<span class="source-line-no">1113</span><span id="line-1113">            if 
(Double.isNaN(array[i])) {</span>
+<span class="source-line-no">1114</span><span id="line-1114">                
return Double.NaN;</span>
+<span class="source-line-no">1115</span><span id="line-1115">            
}</span>
+<span class="source-line-no">1116</span><span id="line-1116">            if 
(array[i] &lt; min) {</span>
+<span class="source-line-no">1117</span><span id="line-1117">                
min = array[i];</span>
+<span class="source-line-no">1118</span><span id="line-1118">            
}</span>
+<span class="source-line-no">1119</span><span id="line-1119">        }</span>
+<span class="source-line-no">1120</span><span id="line-1120">        return 
min;</span>
+<span class="source-line-no">1121</span><span id="line-1121">    }</span>
 <span class="source-line-no">1122</span><span id="line-1122"></span>
-<span class="source-line-no">1123</span><span id="line-1123">        // Finds 
and returns min</span>
-<span class="source-line-no">1124</span><span id="line-1124">        double 
min = array[0];</span>
-<span class="source-line-no">1125</span><span id="line-1125">        for (int 
i = 1; i &lt; array.length; i++) {</span>
-<span class="source-line-no">1126</span><span id="line-1126">            if 
(Double.isNaN(array[i])) {</span>
-<span class="source-line-no">1127</span><span id="line-1127">                
return Double.NaN;</span>
-<span class="source-line-no">1128</span><span id="line-1128">            
}</span>
-<span class="source-line-no">1129</span><span id="line-1129">            if 
(array[i] &lt; min) {</span>
-<span class="source-line-no">1130</span><span id="line-1130">                
min = array[i];</span>
-<span class="source-line-no">1131</span><span id="line-1131">            
}</span>
-<span class="source-line-no">1132</span><span id="line-1132">        }</span>
-<span class="source-line-no">1133</span><span id="line-1133"></span>
-<span class="source-line-no">1134</span><span id="line-1134">        return 
min;</span>
-<span class="source-line-no">1135</span><span id="line-1135">    }</span>
-<span class="source-line-no">1136</span><span id="line-1136"></span>
-<span class="source-line-no">1137</span><span id="line-1137">    /**</span>
-<span class="source-line-no">1138</span><span id="line-1138">     * Gets the 
minimum of three {@code double} values.</span>
-<span class="source-line-no">1139</span><span id="line-1139">     *</span>
-<span class="source-line-no">1140</span><span id="line-1140">     * 
&lt;p&gt;If any value is {@code NaN}, {@code NaN} is</span>
-<span class="source-line-no">1141</span><span id="line-1141">     * returned. 
Infinity is handled.&lt;/p&gt;</span>
-<span class="source-line-no">1142</span><span id="line-1142">     *</span>
-<span class="source-line-no">1143</span><span id="line-1143">     * @param a  
value 1</span>
-<span class="source-line-no">1144</span><span id="line-1144">     * @param b  
value 2</span>
-<span class="source-line-no">1145</span><span id="line-1145">     * @param c  
value 3</span>
-<span class="source-line-no">1146</span><span id="line-1146">     * @return  
the smallest of the values</span>
-<span class="source-line-no">1147</span><span id="line-1147">     * @see 
IEEE754rUtils#min(double, double, double) for a version of this method that 
handles NaN differently</span>
+<span class="source-line-no">1123</span><span id="line-1123">    /**</span>
+<span class="source-line-no">1124</span><span id="line-1124">     * Gets the 
minimum of three {@code double} values.</span>
+<span class="source-line-no">1125</span><span id="line-1125">     *</span>
+<span class="source-line-no">1126</span><span id="line-1126">     * 
&lt;p&gt;If any value is {@code NaN}, {@code NaN} is</span>
+<span class="source-line-no">1127</span><span id="line-1127">     * returned. 
Infinity is handled.&lt;/p&gt;</span>
+<span class="source-line-no">1128</span><span id="line-1128">     *</span>
+<span class="source-line-no">1129</span><span id="line-1129">     * @param a  
value 1</span>
+<span class="source-line-no">1130</span><span id="line-1130">     * @param b  
value 2</span>
+<span class="source-line-no">1131</span><span id="line-1131">     * @param c  
value 3</span>
+<span class="source-line-no">1132</span><span id="line-1132">     * @return  
the smallest of the values</span>
+<span class="source-line-no">1133</span><span id="line-1133">     * @see 
IEEE754rUtils#min(double, double, double) for a version of this method that 
handles NaN differently</span>
+<span class="source-line-no">1134</span><span id="line-1134">     */</span>
+<span class="source-line-no">1135</span><span id="line-1135">    public static 
double min(final double a, final double b, final double c) {</span>
+<span class="source-line-no">1136</span><span id="line-1136">        return 
Math.min(Math.min(a, b), c);</span>
+<span class="source-line-no">1137</span><span id="line-1137">    }</span>
+<span class="source-line-no">1138</span><span id="line-1138"></span>
+<span class="source-line-no">1139</span><span id="line-1139">    /**</span>
+<span class="source-line-no">1140</span><span id="line-1140">     * Returns 
the minimum value in an array.</span>
+<span class="source-line-no">1141</span><span id="line-1141">     *</span>
+<span class="source-line-no">1142</span><span id="line-1142">     * @param 
array  an array, must not be null or empty</span>
+<span class="source-line-no">1143</span><span id="line-1143">     * @return 
the minimum value in the array</span>
+<span class="source-line-no">1144</span><span id="line-1144">     * @throws 
NullPointerException if {@code array} is {@code null}</span>
+<span class="source-line-no">1145</span><span id="line-1145">     * @throws 
IllegalArgumentException if {@code array} is empty</span>
+<span class="source-line-no">1146</span><span id="line-1146">     * @see 
IEEE754rUtils#min(float[]) IEEE754rUtils for a version of this method that 
handles NaN differently</span>
+<span class="source-line-no">1147</span><span id="line-1147">     * @since 3.4 
Changed signature from min(float[]) to min(float...)</span>
 <span class="source-line-no">1148</span><span id="line-1148">     */</span>
-<span class="source-line-no">1149</span><span id="line-1149">    public static 
double min(final double a, final double b, final double c) {</span>
-<span class="source-line-no">1150</span><span id="line-1150">        return 
Math.min(Math.min(a, b), c);</span>
-<span class="source-line-no">1151</span><span id="line-1151">    }</span>
+<span class="source-line-no">1149</span><span id="line-1149">    public static 
float min(final float... array) {</span>
+<span class="source-line-no">1150</span><span id="line-1150">        // 
Validates input</span>
+<span class="source-line-no">1151</span><span id="line-1151">        
validateArray(array);</span>
 <span class="source-line-no">1152</span><span id="line-1152"></span>
-<span class="source-line-no">1153</span><span id="line-1153">    /**</span>
-<span class="source-line-no">1154</span><span id="line-1154">     * Returns 
the minimum value in an array.</span>
-<span class="source-line-no">1155</span><span id="line-1155">     *</span>
-<span class="source-line-no">1156</span><span id="line-1156">     * @param 
array  an array, must not be null or empty</span>
-<span class="source-line-no">1157</span><span id="line-1157">     * @return 
the minimum value in the array</span>
-<span class="source-line-no">1158</span><span id="line-1158">     * @throws 
NullPointerException if {@code array} is {@code null}</span>
-<span class="source-line-no">1159</span><span id="line-1159">     * @throws 
IllegalArgumentException if {@code array} is empty</span>
-<span class="source-line-no">1160</span><span id="line-1160">     * @see 
IEEE754rUtils#min(float[]) IEEE754rUtils for a version of this method that 
handles NaN differently</span>
-<span class="source-line-no">1161</span><span id="line-1161">     * @since 3.4 
Changed signature from min(float[]) to min(float...)</span>
-<span class="source-line-no">1162</span><span id="line-1162">     */</span>
-<span class="source-line-no">1163</span><span id="line-1163">    public static 
float min(final float... array) {</span>
-<span class="source-line-no">1164</span><span id="line-1164">        // 
Validates input</span>
-<span class="source-line-no">1165</span><span id="line-1165">        
validateArray(array);</span>
-<span class="source-line-no">1166</span><span id="line-1166"></span>
-<span class="source-line-no">1167</span><span id="line-1167">        // Finds 
and returns min</span>
-<span class="source-line-no">1168</span><span id="line-1168">        float min 
= array[0];</span>
-<span class="source-line-no">1169</span><span id="line-1169">        for (int 
i = 1; i &lt; array.length; i++) {</span>
-<span class="source-line-no">1170</span><span id="line-1170">            if 
(Float.isNaN(array[i])) {</span>
-<span class="source-line-no">1171</span><span id="line-1171">                
return Float.NaN;</span>
-<span class="source-line-no">1172</span><span id="line-1172">            
}</span>
-<span class="source-line-no">1173</span><span id="line-1173">            if 
(array[i] &lt; min) {</span>
-<span class="source-line-no">1174</span><span id="line-1174">                
min = array[i];</span>
-<span class="source-line-no">1175</span><span id="line-1175">            
}</span>
-<span class="source-line-no">1176</span><span id="line-1176">        }</span>
-<span class="source-line-no">1177</span><span id="line-1177"></span>
-<span class="source-line-no">1178</span><span id="line-1178">        return 
min;</span>
-<span class="source-line-no">1179</span><span id="line-1179">    }</span>
-<span class="source-line-no">1180</span><span id="line-1180"></span>
-<span class="source-line-no">1181</span><span id="line-1181">    /**</span>
-<span class="source-line-no">1182</span><span id="line-1182">     * Gets the 
minimum of three {@code float} values.</span>
-<span class="source-line-no">1183</span><span id="line-1183">     *</span>
-<span class="source-line-no">1184</span><span id="line-1184">     * 
&lt;p&gt;If any value is {@code NaN}, {@code NaN} is</span>
-<span class="source-line-no">1185</span><span id="line-1185">     * returned. 
Infinity is handled.&lt;/p&gt;</span>
-<span class="source-line-no">1186</span><span id="line-1186">     *</span>
-<span class="source-line-no">1187</span><span id="line-1187">     * @param a  
value 1</span>
-<span class="source-line-no">1188</span><span id="line-1188">     * @param b  
value 2</span>
-<span class="source-line-no">1189</span><span id="line-1189">     * @param c  
value 3</span>
-<span class="source-line-no">1190</span><span id="line-1190">     * @return  
the smallest of the values</span>
-<span class="source-line-no">1191</span><span id="line-1191">     * @see 
IEEE754rUtils#min(float, float, float) for a version of this method that 
handles NaN differently</span>
-<span class="source-line-no">1192</span><span id="line-1192">     */</span>
-<span class="source-line-no">1193</span><span id="line-1193">    public static 
float min(final float a, final float b, final float c) {</span>
-<span class="source-line-no">1194</span><span id="line-1194">        return 
Math.min(Math.min(a, b), c);</span>
-<span class="source-line-no">1195</span><span id="line-1195">    }</span>
-<span class="source-line-no">1196</span><span id="line-1196"></span>
-<span class="source-line-no">1197</span><span id="line-1197">    /**</span>
-<span class="source-line-no">1198</span><span id="line-1198">     * Returns 
the minimum value in an array.</span>
-<span class="source-line-no">1199</span><span id="line-1199">     *</span>
-<span class="source-line-no">1200</span><span id="line-1200">     * @param 
array  an array, must not be null or empty</span>
-<span class="source-line-no">1201</span><span id="line-1201">     * @return 
the minimum value in the array</span>
-<span class="source-line-no">1202</span><span id="line-1202">     * @throws 
NullPointerException if {@code array} is {@code null}</span>
-<span class="source-line-no">1203</span><span id="line-1203">     * @throws 
IllegalArgumentException if {@code array} is empty</span>
-<span class="source-line-no">1204</span><span id="line-1204">     * @since 3.4 
Changed signature from min(int[]) to min(int...)</span>
-<span class="source-line-no">1205</span><span id="line-1205">     */</span>
-<span class="source-line-no">1206</span><span id="line-1206">    public static 
int min(final int... array) {</span>
-<span class="source-line-no">1207</span><span id="line-1207">        // 
Validates input</span>
-<span class="source-line-no">1208</span><span id="line-1208">        
validateArray(array);</span>
-<span class="source-line-no">1209</span><span id="line-1209"></span>
-<span class="source-line-no">1210</span><span id="line-1210">        // Finds 
and returns min</span>
-<span class="source-line-no">1211</span><span id="line-1211">        int min = 
array[0];</span>
-<span class="source-line-no">1212</span><span id="line-1212">        for (int 
j = 1; j &lt; array.length; j++) {</span>
-<span class="source-line-no">1213</span><span id="line-1213">            if 
(array[j] &lt; min) {</span>
-<span class="source-line-no">1214</span><span id="line-1214">                
min = array[j];</span>
-<span class="source-line-no">1215</span><span id="line-1215">            
}</span>
-<span class="source-line-no">1216</span><span id="line-1216">        }</span>
-<span class="source-line-no">1217</span><span id="line-1217"></span>
-<span class="source-line-no">1218</span><span id="line-1218">        return 
min;</span>
-<span class="source-line-no">1219</span><span id="line-1219">    }</span>
-<span class="source-line-no">1220</span><span id="line-1220"></span>
-<span class="source-line-no">1221</span><span id="line-1221">     /**</span>
-<span class="source-line-no">1222</span><span id="line-1222">     * Gets the 
minimum of three {@code int} values.</span>
-<span class="source-line-no">1223</span><span id="line-1223">     *</span>
-<span class="source-line-no">1224</span><span id="line-1224">     * @param a  
value 1</span>
-<span class="source-line-no">1225</span><span id="line-1225">     * @param b  
value 2</span>
-<span class="source-line-no">1226</span><span id="line-1226">     * @param c  
value 3</span>
-<span class="source-line-no">1227</span><span id="line-1227">     * @return  
the smallest of the values</span>
-<span class="source-line-no">1228</span><span id="line-1228">     */</span>
-<span class="source-line-no">1229</span><span id="line-1229">    public static 
int min(int a, final int b, final int c) {</span>
-<span class="source-line-no">1230</span><span id="line-1230">        if (b 
&lt; a) {</span>
-<span class="source-line-no">1231</span><span id="line-1231">            a = 
b;</span>
-<span class="source-line-no">1232</span><span id="line-1232">        }</span>
-<span class="source-line-no">1233</span><span id="line-1233">        if (c 
&lt; a) {</span>
-<span class="source-line-no">1234</span><span id="line-1234">            a = 
c;</span>
-<span class="source-line-no">1235</span><span id="line-1235">        }</span>
-<span class="source-line-no">1236</span><span id="line-1236">        return 
a;</span>
-<span class="source-line-no">1237</span><span id="line-1237">    }</span>
-<span class="source-line-no">1238</span><span id="line-1238"></span>
-<span class="source-line-no">1239</span><span id="line-1239">    /**</span>
-<span class="source-line-no">1240</span><span id="line-1240">     * Returns 
the minimum value in an array.</span>
-<span class="source-line-no">1241</span><span id="line-1241">     *</span>
-<span class="source-line-no">1242</span><span id="line-1242">     * @param 
array  an array, must not be null or empty</span>
-<span class="source-line-no">1243</span><span id="line-1243">     * @return 
the minimum value in the array</span>
-<span class="source-line-no">1244</span><span id="line-1244">     * @throws 
NullPointerException if {@code array} is {@code null}</span>
-<span class="source-line-no">1245</span><span id="line-1245">     * @throws 
IllegalArgumentException if {@code array} is empty</span>
-<span class="source-line-no">1246</span><span id="line-1246">     * @since 3.4 
Changed signature from min(long[]) to min(long...)</span>
-<span class="source-line-no">1247</span><span id="line-1247">     */</span>
-<span class="source-line-no">1248</span><span id="line-1248">    public static 
long min(final long... array) {</span>
-<span class="source-line-no">1249</span><span id="line-1249">        // 
Validates input</span>
-<span class="source-line-no">1250</span><span id="line-1250">        
validateArray(array);</span>
-<span class="source-line-no">1251</span><span id="line-1251"></span>
-<span class="source-line-no">1252</span><span id="line-1252">        // Finds 
and returns min</span>
-<span class="source-line-no">1253</span><span id="line-1253">        long min 
= array[0];</span>
-<span class="source-line-no">1254</span><span id="line-1254">        for (int 
i = 1; i &lt; array.length; i++) {</span>
-<span class="source-line-no">1255</span><span id="line-1255">            if 
(array[i] &lt; min) {</span>
-<span class="source-line-no">1256</span><span id="line-1256">                
min = array[i];</span>
-<span class="source-line-no">1257</span><span id="line-1257">            
}</span>
-<span class="source-line-no">1258</span><span id="line-1258">        }</span>
-<span class="source-line-no">1259</span><span id="line-1259"></span>
-<span class="source-line-no">1260</span><span id="line-1260">        return 
min;</span>
+<span class="source-line-no">1153</span><span id="line-1153">        // Finds 
and returns min</span>
+<span class="source-line-no">1154</span><span id="line-1154">        float min 
= array[0];</span>
+<span class="source-line-no">1155</span><span id="line-1155">        for (int 
i = 1; i &lt; array.length; i++) {</span>
+<span class="source-line-no">1156</span><span id="line-1156">            if 
(Float.isNaN(array[i])) {</span>
+<span class="source-line-no">1157</span><span id="line-1157">                
return Float.NaN;</span>
+<span class="source-line-no">1158</span><span id="line-1158">            
}</span>
+<span class="source-line-no">1159</span><span id="line-1159">            if 
(array[i] &lt; min) {</span>
+<span class="source-line-no">1160</span><span id="line-1160">                
min = array[i];</span>
+<span class="source-line-no">1161</span><span id="line-1161">            
}</span>
+<span class="source-line-no">1162</span><span id="line-1162">        }</span>
+<span class="source-line-no">1163</span><span id="line-1163">        return 
min;</span>
+<span class="source-line-no">1164</span><span id="line-1164">    }</span>
+<span class="source-line-no">1165</span><span id="line-1165"></span>
+<span class="source-line-no">1166</span><span id="line-1166">    /**</span>
+<span class="source-line-no">1167</span><span id="line-1167">     * Gets the 
minimum of three {@code float} values.</span>
+<span class="source-line-no">1168</span><span id="line-1168">     *</span>
+<span class="source-line-no">1169</span><span id="line-1169">     * 
&lt;p&gt;If any value is {@code NaN}, {@code NaN} is</span>
+<span class="source-line-no">1170</span><span id="line-1170">     * returned. 
Infinity is handled.&lt;/p&gt;</span>
+<span class="source-line-no">1171</span><span id="line-1171">     *</span>
+<span class="source-line-no">1172</span><span id="line-1172">     * @param a  
value 1</span>
+<span class="source-line-no">1173</span><span id="line-1173">     * @param b  
value 2</span>
+<span class="source-line-no">1174</span><span id="line-1174">     * @param c  
value 3</span>
+<span class="source-line-no">1175</span><span id="line-1175">     * @return  
the smallest of the values</span>
+<span class="source-line-no">1176</span><span id="line-1176">     * @see 
IEEE754rUtils#min(float, float, float) for a version of this method that 
handles NaN differently</span>
+<span class="source-line-no">1177</span><span id="line-1177">     */</span>
+<span class="source-line-no">1178</span><span id="line-1178">    public static 
float min(final float a, final float b, final float c) {</span>
+<span class="source-line-no">1179</span><span id="line-1179">        return 
Math.min(Math.min(a, b), c);</span>
+<span class="source-line-no">1180</span><span id="line-1180">    }</span>
+<span class="source-line-no">1181</span><span id="line-1181"></span>
+<span class="source-line-no">1182</span><span id="line-1182">    /**</span>
+<span class="source-line-no">1183</span><span id="line-1183">     * Returns 
the minimum value in an array.</span>
+<span class="source-line-no">1184</span><span id="line-1184">     *</span>
+<span class="source-line-no">1185</span><span id="line-1185">     * @param 
array  an array, must not be null or empty</span>
+<span class="source-line-no">1186</span><span id="line-1186">     * @return 
the minimum value in the array</span>
+<span class="source-line-no">1187</span><span id="line-1187">     * @throws 
NullPointerException if {@code array} is {@code null}</span>
+<span class="source-line-no">1188</span><span id="line-1188">     * @throws 
IllegalArgumentException if {@code array} is empty</span>
+<span class="source-line-no">1189</span><span id="line-1189">     * @since 3.4 
Changed signature from min(int[]) to min(int...)</span>
+<span class="source-line-no">1190</span><span id="line-1190">     */</span>
+<span class="source-line-no">1191</span><span id="line-1191">    public static 
int min(final int... array) {</span>
+<span class="source-line-no">1192</span><span id="line-1192">        // 
Validates input</span>
+<span class="source-line-no">1193</span><span id="line-1193">        
validateArray(array);</span>
+<span class="source-line-no">1194</span><span id="line-1194">        // Finds 
and returns min</span>
+<span class="source-line-no">1195</span><span id="line-1195">        int min = 
array[0];</span>
+<span class="source-line-no">1196</span><span id="line-1196">        for (int 
j = 1; j &lt; array.length; j++) {</span>
+<span class="source-line-no">1197</span><span id="line-1197">            if 
(array[j] &lt; min) {</span>
+<span class="source-line-no">1198</span><span id="line-1198">                
min = array[j];</span>
+<span class="source-line-no">1199</span><span id="line-1199">            
}</span>
+<span class="source-line-no">1200</span><span id="line-1200">        }</span>
+<span class="source-line-no">1201</span><span id="line-1201">        return 
min;</span>
+<span class="source-line-no">1202</span><span id="line-1202">    }</span>
+<span class="source-line-no">1203</span><span id="line-1203"></span>
+<span class="source-line-no">1204</span><span id="line-1204">     /**</span>
+<span class="source-line-no">1205</span><span id="line-1205">     * Gets the 
minimum of three {@code int} values.</span>
+<span class="source-line-no">1206</span><span id="line-1206">     *</span>
+<span class="source-line-no">1207</span><span id="line-1207">     * @param a  
value 1</span>
+<span class="source-line-no">1208</span><span id="line-1208">     * @param b  
value 2</span>
+<span class="source-line-no">1209</span><span id="line-1209">     * @param c  
value 3</span>
+<span class="source-line-no">1210</span><span id="line-1210">     * @return  
the smallest of the values</span>
+<span class="source-line-no">1211</span><span id="line-1211">     */</span>
+<span class="source-line-no">1212</span><span id="line-1212">    public static 
int min(int a, final int b, final int c) {</span>
+<span class="source-line-no">1213</span><span id="line-1213">        if (b 
&lt; a) {</span>
+<span class="source-line-no">1214</span><span id="line-1214">            a = 
b;</span>
+<span class="source-line-no">1215</span><span id="line-1215">        }</span>
+<span class="source-line-no">1216</span><span id="line-1216">        if (c 
&lt; a) {</span>
+<span class="source-line-no">1217</span><span id="line-1217">            a = 
c;</span>
+<span class="source-line-no">1218</span><span id="line-1218">        }</span>
+<span class="source-line-no">1219</span><span id="line-1219">        return 
a;</span>
+<span class="source-line-no">1220</span><span id="line-1220">    }</span>
+<span class="source-line-no">1221</span><span id="line-1221"></span>
+<span class="source-line-no">1222</span><span id="line-1222">    /**</span>
+<span class="source-line-no">1223</span><span id="line-1223">     * Returns 
the minimum value in an array.</span>
+<span class="source-line-no">1224</span><span id="line-1224">     *</span>
+<span class="source-line-no">1225</span><span id="line-1225">     * @param 
array  an array, must not be null or empty</span>

[... 1191 lines stripped ...]

Reply via email to