Coverage Report

Coverage Report - org.apache.commons.lang3.math.IEEE754rUtils

Classes in this File

Line Coverage

Branch Coverage

Complexity

IEEE754rUtils

100%

57/57

100%

40/40

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  * 
  *      http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.apache.commons.lang3.math;
 
 /**
  * <p>Provides IEEE-754r variants of NumberUtils methods. </p>
  *
  * <p>See: <a href="http://en.wikipedia.org/wiki/IEEE_754r">http://en.wikipedia.org/wiki/IEEE_754r</a></p>
  *
  * @since 2.4
  * @version $Id: IEEE754rUtils.java 1436768 2013-01-22 07:07:42Z ggregory $
  */
 public class IEEE754rUtils {
     
      /**
      * <p>Returns the minimum value in an array.</p>
      * 
      * @param array  an array, must not be null or empty
      * @return the minimum value in the array
      * @throws IllegalArgumentException if <code>array</code> is <code>null</code>
      * @throws IllegalArgumentException if <code>array</code> is empty
      */
     public static double min(final double[] array) {
         // Validates input
         if (array == null) {
             throw new IllegalArgumentException("The Array must not be null");
         } else if (array.length == 0) {
             throw new IllegalArgumentException("Array cannot be empty.");
         }
     
         // Finds and returns min
         double min = array[0];
         for (int i = 1; i < array.length; i++) {
             min = min(array[i], min);
         }
     
         return min;
     }
 
     /**
      * <p>Returns the minimum value in an array.</p>
      * 
      * @param array  an array, must not be null or empty
      * @return the minimum value in the array
      * @throws IllegalArgumentException if <code>array</code> is <code>null</code>
      * @throws IllegalArgumentException if <code>array</code> is empty
      */
     public static float min(final float[] array) {
         // Validates input
         if (array == null) {
             throw new IllegalArgumentException("The Array must not be null");
         } else if (array.length == 0) {
             throw new IllegalArgumentException("Array cannot be empty.");
         }
     
         // Finds and returns min
         float min = array[0];
         for (int i = 1; i < array.length; i++) {
             min = min(array[i], min);
         }
     
         return min;
     }
 
     /**
      * <p>Gets the minimum of three <code>double</code> values.</p>
      * 
      * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
      * 
      * @param a  value 1
      * @param b  value 2
      * @param c  value 3
      * @return  the smallest of the values
      */
     public static double min(final double a, final double b, final double c) {
         return min(min(a, b), c);
     }
 
     /**
      * <p>Gets the minimum of two <code>double</code> values.</p>
      * 
      * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
      * 
      * @param a  value 1
      * @param b  value 2
      * @return  the smallest of the values
      */
     public static double min(final double a, final double b) {
         if(Double.isNaN(a)) {
             return b;
         } else
         if(Double.isNaN(b)) {
             return a;
         } else {
             return Math.min(a, b);
         }
     }
 
     /**
      * <p>Gets the minimum of three <code>float</code> values.</p>
      * 
      * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
      *
      * @param a  value 1
      * @param b  value 2
      * @param c  value 3
      * @return  the smallest of the values
      */
     public static float min(final float a, final float b, final float c) {
         return min(min(a, b), c);
     }
 
     /**
      * <p>Gets the minimum of two <code>float</code> values.</p>
      * 
      * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
      *
      * @param a  value 1
      * @param b  value 2
      * @return  the smallest of the values
      */
     public static float min(final float a, final float b) {
         if(Float.isNaN(a)) {
             return b;
         } else
         if(Float.isNaN(b)) {
             return a;
         } else {
             return Math.min(a, b);
         }
     }
 
     /**
      * <p>Returns the maximum value in an array.</p>
      * 
      * @param array  an array, must not be null or empty
      * @return the minimum value in the array
      * @throws IllegalArgumentException if <code>array</code> is <code>null</code>
      * @throws IllegalArgumentException if <code>array</code> is empty
      */
     public static double max(final double[] array) {
         // Validates input
         if (array== null) {
             throw new IllegalArgumentException("The Array must not be null");
         } else if (array.length == 0) {
             throw new IllegalArgumentException("Array cannot be empty.");
         }
     
         // Finds and returns max
         double max = array[0];
         for (int j = 1; j < array.length; j++) {
             max = max(array[j], max);
         }
     
         return max;
     }
 
     /**
      * <p>Returns the maximum value in an array.</p>
      * 
      * @param array  an array, must not be null or empty
      * @return the minimum value in the array
      * @throws IllegalArgumentException if <code>array</code> is <code>null</code>
      * @throws IllegalArgumentException if <code>array</code> is empty
      */
     public static float max(final float[] array) {
         // Validates input
         if (array == null) {
             throw new IllegalArgumentException("The Array must not be null");
         } else if (array.length == 0) {
             throw new IllegalArgumentException("Array cannot be empty.");
         }
 
         // Finds and returns max
         float max = array[0];
         for (int j = 1; j < array.length; j++) {
             max = max(array[j], max);
         }
 
         return max;
     }
      
     /**
      * <p>Gets the maximum of three <code>double</code> values.</p>
      * 
      * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
      *
      * @param a  value 1
      * @param b  value 2
      * @param c  value 3
      * @return  the largest of the values
      */
     public static double max(final double a, final double b, final double c) {
         return max(max(a, b), c);
     }
 
     /**
      * <p>Gets the maximum of two <code>double</code> values.</p>
      * 
      * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
      *
      * @param a  value 1
      * @param b  value 2
      * @return  the largest of the values
      */
     public static double max(final double a, final double b) {
         if(Double.isNaN(a)) {
             return b;
         } else
         if(Double.isNaN(b)) {
             return a;
         } else {
             return Math.max(a, b);
         }
     }
 
     /**
      * <p>Gets the maximum of three <code>float</code> values.</p>
      * 
      * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
      *
      * @param a  value 1
      * @param b  value 2
      * @param c  value 3
      * @return  the largest of the values
      */
     public static float max(final float a, final float b, final float c) {
         return max(max(a, b), c);
     }
 
     /**
      * <p>Gets the maximum of two <code>float</code> values.</p>
      * 
      * <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
      *
      * @param a  value 1
      * @param b  value 2
      * @return  the largest of the values
      */
     public static float max(final float a, final float b) {
         if(Float.isNaN(a)) {
             return b;
         } else
         if(Float.isNaN(b)) {
             return a;
         } else {
             return Math.max(a, b);
         }
     }
 
 }

1		/*
2		* Licensed to the Apache Software Foundation (ASF) under one or more
3		* contributor license agreements. See the NOTICE file distributed with
4		* this work for additional information regarding copyright ownership.
5		* The ASF licenses this file to You under the Apache License, Version 2.0
6		* (the "License"); you may not use this file except in compliance with
7		* the License. You may obtain a copy of the License at
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*/
17		package org.apache.commons.lang3.math;
18
19		/**
20		* <p>Provides IEEE-754r variants of NumberUtils methods. </p>
21		*
22		* <p>See: <a href="http://en.wikipedia.org/wiki/IEEE_754r">http://en.wikipedia.org/wiki/IEEE_754r</a></p>
23		*
24		* @since 2.4
25		* @version $Id: IEEE754rUtils.java 1436768 2013-01-22 07:07:42Z ggregory $
26		*/
27	1	public class IEEE754rUtils {
28
29		/**
30		* <p>Returns the minimum value in an array.</p>
31		*
32		* @param array an array, must not be null or empty
33		* @return the minimum value in the array
34		* @throws IllegalArgumentException if <code>array</code> is <code>null</code>
35		* @throws IllegalArgumentException if <code>array</code> is empty
36		*/
37		public static double min(final double[] array) {
38		// Validates input
39	4	if (array == null) {
40	1	throw new IllegalArgumentException("The Array must not be null");
41	3	} else if (array.length == 0) {
42	1	throw new IllegalArgumentException("Array cannot be empty.");
43		}
44
45		// Finds and returns min
46	2	double min = array[0];
47	13	for (int i = 1; i < array.length; i++) {
48	11	min = min(array[i], min);
49		}
50
51	2	return min;
52		}
53
54		/**
55		* <p>Returns the minimum value in an array.</p>
56		*
57		* @param array an array, must not be null or empty
58		* @return the minimum value in the array
59		* @throws IllegalArgumentException if <code>array</code> is <code>null</code>
60		* @throws IllegalArgumentException if <code>array</code> is empty
61		*/
62		public static float min(final float[] array) {
63		// Validates input
64	4	if (array == null) {
65	1	throw new IllegalArgumentException("The Array must not be null");
66	3	} else if (array.length == 0) {
67	1	throw new IllegalArgumentException("Array cannot be empty.");
68		}
69
70		// Finds and returns min
71	2	float min = array[0];
72	13	for (int i = 1; i < array.length; i++) {
73	11	min = min(array[i], min);
74		}
75
76	2	return min;
77		}
78
79		/**
80		* <p>Gets the minimum of three <code>double</code> values.</p>
81		*
82		* <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
83		*
84		* @param a value 1
85		* @param b value 2
86		* @param c value 3
87		* @return the smallest of the values
88		*/
89		public static double min(final double a, final double b, final double c) {
90	1	return min(min(a, b), c);
91		}
92
93		/**
94		* <p>Gets the minimum of two <code>double</code> values.</p>
95		*
96		* <p>NaN is only returned if all numbers are NaN as per IEEE-754r. </p>
97		*
98		* @param a value 1
99		* @param b value 2
100		* @return the smallest of the values
101		*/
102		public static double min(final double a, final double b) {
103	13	if(Double.isNaN(a)) {
104	4	return b;
105		} else
106	9	if(Double.isNaN(b)) {
107	2	return a;
108		} else {
109	7	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(final float a, final float b, final float c) {
124	1	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(final float a, final float b) {
137	13	if(Float.isNaN(a)) {
138	4	return b;
139		} else
140	9	if(Float.isNaN(b)) {
141	2	return a;
142		} else {
143	7	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(final double[] array) {
156		// Validates input
157	4	if (array== null) {
158	1	throw new IllegalArgumentException("The Array must not be null");
159	3	} else if (array.length == 0) {
160	1	throw new IllegalArgumentException("Array cannot be empty.");
161		}
162
163		// Finds and returns max
164	2	double max = array[0];
165	13	for (int j = 1; j < array.length; j++) {
166	11	max = max(array[j], max);
167		}
168
169	2	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(final float[] array) {
181		// Validates input
182	4	if (array == null) {
183	1	throw new IllegalArgumentException("The Array must not be null");
184	3	} else if (array.length == 0) {
185	1	throw new IllegalArgumentException("Array cannot be empty.");
186		}
187
188		// Finds and returns max
189	2	float max = array[0];
190	13	for (int j = 1; j < array.length; j++) {
191	11	max = max(array[j], max);
192		}
193
194	2	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(final double a, final double b, final double c) {
208	2	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(final double a, final double b) {
221	15	if(Double.isNaN(a)) {
222	6	return b;
223		} else
224	9	if(Double.isNaN(b)) {
225	2	return a;
226		} else {
227	7	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(final float a, final float b, final float c) {
242	2	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(final float a, final float b) {
255	15	if(Float.isNaN(a)) {
256	6	return b;
257		} else
258	9	if(Float.isNaN(b)) {
259	2	return a;
260		} else {
261	7	return Math.max(a, b);
262		}
263		}
264
265		}