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 }