    001    /*
    002     * Licensed to the Apache Software Foundation (ASF) under one or more
    003     * contributor license agreements.  See the NOTICE file distributed with
    004     * this work for additional information regarding copyright ownership.
    005     * The ASF licenses this file to You under the Apache License, Version 2.0
    006     * (the "License"); you may not use this file except in compliance with
    007     * the License.  You may obtain a copy of the License at
    008     *
    009     *      http://www.apache.org/licenses/LICENSE-2.0
    010     *
    011     * Unless required by applicable law or agreed to in writing, software
    012     * distributed under the License is distributed on an "AS IS" BASIS,
    013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014     * See the License for the specific language governing permissions and
    015     * limitations under the License.
    016     */
    017    package org.apache.commons.lang3.math;
    018
    019    /**
    020     * <p>Provides IEEE-754r variants of NumberUtils methods. </p>
    021     *
    022     * <p>See: <a href="http://en.wikipedia.org/wiki/IEEE_754r">http://en.wikipedia.org/wiki/IEEE_754r</a></p>
    023     *
    024     * @since 2.4
    025     * @version $Id: IEEE754rUtils.java 1088899 2011-04-05 05:31:27Z bayard $
    026     */
    027    public class IEEE754rUtils {
    028
    029         /**
    030         * <p>Returns the minimum value in an array.</p>
    031         *
    032         * @param array  an array, must not be null or empty
    033         * @return the minimum value in the array
    034         * @throws IllegalArgumentException if <code>array</code> is <code>null</code>
    035         * @throws IllegalArgumentException if <code>array</code> is empty
    036         */
    037        public static double min(double[] array) {
    038            // Validates input
    039            if (array == null) {
    040                throw new IllegalArgumentException("The Array must not be null");
    041            } else if (array.length == 0) {
    042                throw new IllegalArgumentException("Array cannot be empty.");
    043            }
    044
    045            // Finds and returns min
    046            double min = array[0];
    047            for (int i = 1; i < array.length; i++) {
    048                min = min(array[i], min);
    049            }
    050
    051            return min;
    052        }
    053
    054        /**
    055         * <p>Returns the minimum value in an array.</p>
    056         *
    057         * @param array  an array, must not be null or empty
    058         * @return the minimum value in the array
    059         * @throws IllegalArgumentException if <code>array</code> is <code>null</code>
    060         * @throws IllegalArgumentException if <code>array</code> is empty
    061         */
    062        public static float min(float[] array) {
    063            // Validates input
    064            if (array == null) {
    065                throw new IllegalArgumentException("The Array must not be null");
    066            } else if (array.length == 0) {
    067                throw new IllegalArgumentException("Array cannot be empty.");
    068            }
    069
    070            // Finds and returns min
    071            float min = array[0];
    072            for (int i = 1; i < array.length; i++) {
    073                min = min(array[i], min);
    074            }
    075
    076            return min;
    077        }
    078
    079        /**
    080         * <p>Gets the minimum of three <code>double</code> values.</p>
    081         *
    082         * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
    083         *
    084         * @param a  value 1
    085         * @param b  value 2
    086         * @param c  value 3
    087         * @return  the smallest of the values
    088         */
    089        public static double min(double a, double b, double c) {
    090            return min(min(a, b), c);
    091        }
    092
    093        /**
    094         * <p>Gets the minimum of two <code>double</code> values.</p>
    095         *
    096         * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
    097         *
    098         * @param a  value 1
    099         * @param b  value 2
    100         * @return  the smallest of the values
    101         */
    102        public static double min(double a, double b) {
    103            if(Double.isNaN(a)) {
    104                return b;
    105            } else
    106            if(Double.isNaN(b)) {
    107                return a;
    108            } else {
    109                return Math.min(a, b);
    110            }
    111        }
    112
    113        /**
    114         * <p>Gets the minimum of three <code>float</code> values.</p>
    115         *
    116         * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
    117         *
    118         * @param a  value 1
    119         * @param b  value 2
    120         * @param c  value 3
    121         * @return  the smallest of the values
    122         */
    123        public static float min(float a, float b, float c) {
    124            return min(min(a, b), c);
    125        }
    126
    127        /**
    128         * <p>Gets the minimum of two <code>float</code> values.</p>
    129         *
    130         * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
    131         *
    132         * @param a  value 1
    133         * @param b  value 2
    134         * @return  the smallest of the values
    135         */
    136        public static float min(float a, float b) {
    137            if(Float.isNaN(a)) {
    138                return b;
    139            } else
    140            if(Float.isNaN(b)) {
    141                return a;
    142            } else {
    143                return Math.min(a, b);
    144            }
    145        }
    146
    147        /**
    148         * <p>Returns the maximum value in an array.</p>
    149         *
    150         * @param array  an array, must not be null or empty
    151         * @return the minimum value in the array
    152         * @throws IllegalArgumentException if <code>array</code> is <code>null</code>
    153         * @throws IllegalArgumentException if <code>array</code> is empty
    154         */
    155        public static double max(double[] array) {
    156            // Validates input
    157            if (array== null) {
    158                throw new IllegalArgumentException("The Array must not be null");
    159            } else if (array.length == 0) {
    160                throw new IllegalArgumentException("Array cannot be empty.");
    161            }
    162
    163            // Finds and returns max
    164            double max = array[0];
    165            for (int j = 1; j < array.length; j++) {
    166                max = max(array[j], max);
    167            }
    168
    169            return max;
    170        }
    171
    172        /**
    173         * <p>Returns the maximum value in an array.</p>
    174         *
    175         * @param array  an array, must not be null or empty
    176         * @return the minimum value in the array
    177         * @throws IllegalArgumentException if <code>array</code> is <code>null</code>
    178         * @throws IllegalArgumentException if <code>array</code> is empty
    179         */
    180        public static float max(float[] array) {
    181            // Validates input
    182            if (array == null) {
    183                throw new IllegalArgumentException("The Array must not be null");
    184            } else if (array.length == 0) {
    185                throw new IllegalArgumentException("Array cannot be empty.");
    186            }
    187
    188            // Finds and returns max
    189            float max = array[0];
    190            for (int j = 1; j < array.length; j++) {
    191                max = max(array[j], max);
    192            }
    193
    194            return max;
    195        }
    196
    197        /**
    198         * <p>Gets the maximum of three <code>double</code> values.</p>
    199         *
    200         * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
    201         *
    202         * @param a  value 1
    203         * @param b  value 2
    204         * @param c  value 3
    205         * @return  the largest of the values
    206         */
    207        public static double max(double a, double b, double c) {
    208            return max(max(a, b), c);
    209        }
    210
    211        /**
    212         * <p>Gets the maximum of two <code>double</code> values.</p>
    213         *
    214         * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
    215         *
    216         * @param a  value 1
    217         * @param b  value 2
    218         * @return  the largest of the values
    219         */
    220        public static double max(double a, double b) {
    221            if(Double.isNaN(a)) {
    222                return b;
    223            } else
    224            if(Double.isNaN(b)) {
    225                return a;
    226            } else {
    227                return Math.max(a, b);
    228            }
    229        }
    230
    231        /**
    232         * <p>Gets the maximum of three <code>float</code> values.</p>
    233         *
    234         * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
    235         *
    236         * @param a  value 1
    237         * @param b  value 2
    238         * @param c  value 3
    239         * @return  the largest of the values
    240         */
    241        public static float max(float a, float b, float c) {
    242            return max(max(a, b), c);
    243        }
    244
    245        /**
    246         * <p>Gets the maximum of two <code>float</code> values.</p>
    247         *
    248         * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
    249         *
    250         * @param a  value 1
    251         * @param b  value 2
    252         * @return  the largest of the values
    253         */
    254        public static float max(float a, float b) {
    255            if(Float.isNaN(a)) {
    256                return b;
    257            } else
    258            if(Float.isNaN(b)) {
    259                return a;
    260            } else {
    261                return Math.max(a, b);
    262            }
    263        }
    264
    265    }