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 }