You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@commons.apache.org by gg...@apache.org on 2024/08/29 19:59:25 UTC
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...
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 < array.length; i++) {</span>
-<span class="source-line-no">791</span><span id="line-791"> if (array[i] > 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 > 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 > 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 < 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 < array.length; i++) {</span>
+<span class="source-line-no">790</span><span id="line-790"> if (array[i] > 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 > 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 > 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 < 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] > 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] > 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"> * <p>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.</p></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 < 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] > 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"> * <p>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.</p></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 < array.length; j++) {</span>
-<span class="source-line-no">956</span><span id="line-956"> if (array[j] > 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 > 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 > 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 < array.length; j++) {</span>
-<span class="source-line-no">998</span><span id="line-998"> if (array[j] > 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 > 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 > 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"> * <p>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.</p></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 < 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] > 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"> * <p>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.</p></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 < array.length; j++) {</span>
+<span class="source-line-no">949</span><span id="line-949"> if (array[j] > 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 > 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 > 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 < array.length; j++) {</span>
+<span class="source-line-no">989</span><span id="line-989"> if (array[j] > 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 > 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 > 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 < array.length; i++) {</span>
+<span class="source-line-no">1031</span><span id="line-1031"> if (array[i] > 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 < array.length; i++) {</span>
-<span class="source-line-no">1041</span><span id="line-1041"> if (array[i] > 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 > 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 > 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 < array.length; i++) {</span>
-<span class="source-line-no">1083</span><span id="line-1083"> if (array[i] < 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 < 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 < 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 > 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 > 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 < array.length; i++) {</span>
+<span class="source-line-no">1071</span><span id="line-1071"> if (array[i] < 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 < 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 < 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 < 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] < 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 < 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] < 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"> * <p>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.</p></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"> * <p>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.</p></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 < 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] < 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"> * <p>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.</p></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 < array.length; j++) {</span>
-<span class="source-line-no">1213</span><span id="line-1213"> if (array[j] < 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 < 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 < 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 < array.length; i++) {</span>
-<span class="source-line-no">1255</span><span id="line-1255"> if (array[i] < 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 < 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] < 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"> * <p>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.</p></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 < array.length; j++) {</span>
+<span class="source-line-no">1197</span><span id="line-1197"> if (array[j] < 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 < 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 < 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 ...]