Coverage Report - net.admin4j.util.NumberUtils
 
Classes in this File Line Coverage Branch Coverage Complexity
NumberUtils
87%
47/54
77%
28/36
3.2
 
 1   
 /*
 2   
  * This software is licensed under the Apache License, Version 2.0
 3   
  * (the "License") agreement; you may not use this file except in compliance with
 4   
  * the License.  You may obtain a copy of the License at
 5   
  *
 6   
  *      http://www.apache.org/licenses/LICENSE-2.0
 7   
  *
 8   
  * Unless required by applicable law or agreed to in writing, software
 9   
  * distributed under the License is distributed on an "AS IS" BASIS,
 10   
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 11   
  * See the License for the specific language governing permissions and
 12   
  * limitations under the License.
 13   
  */
 14   
 package net.admin4j.util;
 15   
 
 16   
 import java.math.BigDecimal;
 17   
 import java.math.BigInteger;
 18   
 import java.util.List;
 19   
 
 20   
 /**
 21   
  * Generic numeric utilities not provided by jdk or Commons Lang.
 22   
  * @author D. Ashmore
 23   
  * @since 1.0
 24   
  */
 25  0 
 public class NumberUtils {
 26   
 
 27  15 
     private static final BigDecimal DOUBLE_MAX_VALUE = new BigDecimal(Double.MAX_VALUE);
 28  15 
     private static final BigInteger INTEGER_MAX_VALUE = BigInteger.valueOf(Long.MAX_VALUE);
 29   
 
 30   
     public static Number min(List<Number> numberList) {
 31  21 
         Number answer = null;
 32  21 
         double answerValue = Double.MAX_VALUE;
 33   
 
 34  21 
         for (Number number: numberList) {
 35  42 
             if (number.doubleValue() < answerValue) {
 36  22 
                 answerValue = number.doubleValue();
 37  22 
                 answer = number;
 38   
             }
 39   
         }
 40   
 
 41  21 
         return answer;
 42   
     }
 43   
 
 44   
     public static Number max(List<Number> numberList) {
 45  21 
         Number answer = null;
 46  21 
         double answerValue = Double.MIN_VALUE;
 47   
 
 48  21 
         for (Number number: numberList) {
 49  42 
             if (number.doubleValue() > answerValue) {
 50  30 
                 answerValue = number.doubleValue();
 51  30 
                 answer = number;
 52   
             }
 53   
         }
 54   
 
 55  21 
         return answer;
 56   
     }
 57   
 
 58   
     public static Number sum(List<Number> numberList) {
 59  99 
         if (hasFractions(numberList)) {
 60  33 
             return sumDecimals(numberList);
 61   
         }
 62  66 
         else return sumIntegers(numberList);
 63   
     }
 64   
 
 65   
     public static Number average(List<Number> numberList) {
 66  78 
         return sum(numberList).doubleValue() / (double)numberList.size();
 67   
     }
 68   
 
 69   
     public static Number standardDeviation(List<Number> numberList) {
 70  21 
         return Math.sqrt(variance(numberList).doubleValue());
 71   
     }
 72   
 
 73   
     public static Number variance(List<Number> numberList) {
 74  39 
         double firstPart = (sumSquares(numberList).doubleValue() / (double)(numberList.size()));
 75  39 
         double secondPart = Math.pow(average(numberList).doubleValue(), 2);
 76  39 
         return firstPart
 77   
             - secondPart;
 78   
     }
 79   
 
 80   
     private static Number sumIntegers(List<Number> numberList) {
 81  66 
         BigInteger total = BigInteger.ZERO;
 82  66 
         for (Number number: numberList) {
 83  93 
             if (number instanceof BigInteger) {
 84  0 
                 total = total.add((BigInteger)number);
 85   
             }
 86   
             else {
 87  93 
                 total = total.add(BigInteger.valueOf(number.longValue()));
 88   
             }
 89   
         }
 90   
 
 91  66 
         if (total.compareTo(INTEGER_MAX_VALUE) < 0) {
 92  66 
             return total.longValue();
 93   
         }
 94   
 
 95  0 
         return total;
 96   
     }
 97   
 
 98   
     private static Number sumDecimals(List<Number> numberList) {
 99  33 
         BigDecimal total = new BigDecimal(0);
 100  33 
         for (Number number: numberList) {
 101  228 
             if (number instanceof BigDecimal) {
 102  0 
                 total = total.add((BigDecimal)number);
 103   
             }
 104   
             else {
 105  228 
                 total = total.add(new BigDecimal( number.doubleValue()));
 106   
             }
 107   
         }
 108   
 
 109  33 
         if (total.compareTo(DOUBLE_MAX_VALUE) < 0) {
 110  33 
             return total.doubleValue();
 111   
         }
 112   
 
 113  0 
         return total;
 114   
     }
 115   
 
 116   
     private static Number sumSquares(List<Number> numberList) {
 117  39 
         BigDecimal total = new BigDecimal(0);
 118  39 
         for (Number number: numberList) {
 119  84 
             if (number instanceof BigDecimal) {
 120  0 
                 total = total.add( ((BigDecimal)number).pow(2));
 121   
             }
 122   
             else {
 123  84 
                 total = total.add(new BigDecimal( number.doubleValue()).pow(2));
 124   
             }
 125   
         }
 126   
 
 127  39 
         if (total.compareTo(DOUBLE_MAX_VALUE) < 0) {
 128  39 
             return total.doubleValue();
 129   
         }
 130   
 
 131  0 
         return total;
 132   
     }
 133   
 
 134   
     private static boolean hasFractions(List<Number> numberList) {
 135  99 
         boolean answer = false;
 136  99 
         for (Number number: numberList) {
 137  321 
             if (number instanceof Float || number instanceof Double || number instanceof BigDecimal) {
 138  228 
                 answer = true;
 139   
             }
 140   
         }
 141   
 
 142  99 
         return answer;
 143   
     }
 144   
 
 145   
 }
Report generated by Cobertura 2.0.3 on 11/22/15 10:14 AM.