    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.lang.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     * @author Apache Software Foundation
    026     * @version $Id: IEEE754rUtils.java 905636 2010-02-02 14:03:32Z niallp $
    027     */
    028    public class IEEE754rUtils {
    029
    030         /**
    031         * <p>Returns the minimum value in an array.</p>
    032         *
    033         * @param array  an array, must not be null or empty
    034         * @return the minimum value in the array
    035         * @throws IllegalArgumentException if <code>array</code> is <code>null</code>
    036         * @throws IllegalArgumentException if <code>array</code> is empty
    037         */
    038        public static double min(double[] array) {
    039            // Validates input
    040            if (array == null) {
    041                throw new IllegalArgumentException("The Array must not be null");
    042            } else if (array.length == 0) {
    043                throw new IllegalArgumentException("Array cannot be empty.");
    044            }
    045
    046            // Finds and returns min
    047            double min = array[0];
    048            for (int i = 1; i < array.length; i++) {
    049                min = min(array[i], min);
    050            }
    051
    052            return min;
    053        }
    054
    055        /**
    056         * <p>Returns the minimum value in an array.</p>
    057         *
    058         * @param array  an array, must not be null or empty
    059         * @return the minimum value in the array
    060         * @throws IllegalArgumentException if <code>array</code> is <code>null</code>
    061         * @throws IllegalArgumentException if <code>array</code> is empty
    062         */
    063        public static float min(float[] array) {
    064            // Validates input
    065            if (array == null) {
    066                throw new IllegalArgumentException("The Array must not be null");
    067            } else if (array.length == 0) {
    068                throw new IllegalArgumentException("Array cannot be empty.");
    069            }
    070
    071            // Finds and returns min
    072            float min = array[0];
    073            for (int i = 1; i < array.length; i++) {
    074                min = min(array[i], min);
    075            }
    076
    077            return min;
    078        }
    079
    080        /**
    081         * <p>Gets the minimum of three <code>double</code> values.</p>
    082         *
    083         * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
    084         *
    085         * @param a  value 1
    086         * @param b  value 2
    087         * @param c  value 3
    088         * @return  the smallest of the values
    089         */
    090        public static double min(double a, double b, double c) {
    091            return min(min(a, b), c);
    092        }
    093
    094        /**
    095         * <p>Gets the minimum of two <code>double</code> values.</p>
    096         *
    097         * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
    098         *
    099         * @param a  value 1
    100         * @param b  value 2
    101         * @return  the smallest of the values
    102         */
    103        public static double min(double a, double b) {
    104            if(Double.isNaN(a)) {
    105                return b;
    106            } else
    107            if(Double.isNaN(b)) {
    108                return a;
    109            } else {
    110                return Math.min(a, b);
    111            }
    112        }
    113
    114        /**
    115         * <p>Gets the minimum of three <code>float</code> values.</p>
    116         *
    117         * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
    118         *
    119         * @param a  value 1
    120         * @param b  value 2
    121         * @param c  value 3
    122         * @return  the smallest of the values
    123         */
    124        public static float min(float a, float b, float c) {
    125            return min(min(a, b), c);
    126        }
    127
    128        /**
    129         * <p>Gets the minimum of two <code>float</code> values.</p>
    130         *
    131         * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
    132         *
    133         * @param a  value 1
    134         * @param b  value 2
    135         * @return  the smallest of the values
    136         */
    137        public static float min(float a, float b) {
    138            if(Float.isNaN(a)) {
    139                return b;
    140            } else
    141            if(Float.isNaN(b)) {
    142                return a;
    143            } else {
    144                return Math.min(a, b);
    145            }
    146        }
    147
    148        /**
    149         * <p>Returns the maximum value in an array.</p>
    150         *
    151         * @param array  an array, must not be null or empty
    152         * @return the minimum value in the array
    153         * @throws IllegalArgumentException if <code>array</code> is <code>null</code>
    154         * @throws IllegalArgumentException if <code>array</code> is empty
    155         */
    156        public static double max(double[] array) {
    157            // Validates input
    158            if (array== null) {
    159                throw new IllegalArgumentException("The Array must not be null");
    160            } else if (array.length == 0) {
    161                throw new IllegalArgumentException("Array cannot be empty.");
    162            }
    163
    164            // Finds and returns max
    165            double max = array[0];
    166            for (int j = 1; j < array.length; j++) {
    167                max = max(array[j], max);
    168            }
    169
    170            return max;
    171        }
    172
    173        /**
    174         * <p>Returns the maximum value in an array.</p>
    175         *
    176         * @param array  an array, must not be null or empty
    177         * @return the minimum value in the array
    178         * @throws IllegalArgumentException if <code>array</code> is <code>null</code>
    179         * @throws IllegalArgumentException if <code>array</code> is empty
    180         */
    181        public static float max(float[] array) {
    182            // Validates input
    183            if (array == null) {
    184                throw new IllegalArgumentException("The Array must not be null");
    185            } else if (array.length == 0) {
    186                throw new IllegalArgumentException("Array cannot be empty.");
    187            }
    188
    189            // Finds and returns max
    190            float max = array[0];
    191            for (int j = 1; j < array.length; j++) {
    192                max = max(array[j], max);
    193            }
    194
    195            return max;
    196        }
    197
    198        /**
    199         * <p>Gets the maximum of three <code>double</code> values.</p>
    200         *
    201         * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
    202         *
    203         * @param a  value 1
    204         * @param b  value 2
    205         * @param c  value 3
    206         * @return  the largest of the values
    207         */
    208        public static double max(double a, double b, double c) {
    209            return max(max(a, b), c);
    210        }
    211
    212        /**
    213         * <p>Gets the maximum of two <code>double</code> values.</p>
    214         *
    215         * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
    216         *
    217         * @param a  value 1
    218         * @param b  value 2
    219         * @return  the largest of the values
    220         */
    221        public static double max(double a, double b) {
    222            if(Double.isNaN(a)) {
    223                return b;
    224            } else
    225            if(Double.isNaN(b)) {
    226                return a;
    227            } else {
    228                return Math.max(a, b);
    229            }
    230        }
    231
    232        /**
    233         * <p>Gets the maximum of three <code>float</code> values.</p>
    234         *
    235         * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
    236         *
    237         * @param a  value 1
    238         * @param b  value 2
    239         * @param c  value 3
    240         * @return  the largest of the values
    241         */
    242        public static float max(float a, float b, float c) {
    243            return max(max(a, b), c);
    244        }
    245
    246        /**
    247         * <p>Gets the maximum of two <code>float</code> values.</p>
    248         *
    249         * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
    250         *
    251         * @param a  value 1
    252         * @param b  value 2
    253         * @return  the largest of the values
    254         */
    255        public static float max(float a, float b) {
    256            if(Float.isNaN(a)) {
    257                return b;
    258            } else
    259            if(Float.isNaN(b)) {
    260                return a;
    261            } else {
    262                return Math.max(a, b);
    263            }
    264        }
    265
    266    }