Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2009-2012 Alexander Kerner. All rights reserved. Licensed 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 net.sf.kerner.utils.math;
 
 
Provides static helper methods.

Author(s):
Alexander Kerner
Version:
2012-03-06
 
 public class UtilMath {
 
     private UtilMath() {
     }

    
Round a floating point number (double) with an accuracy up to given decimal place.

Parameters:
number double that is rounded to given decimal place
decimalPlace decimal place to which given double is rounded
Returns:
rounded double
 
     public static double round(double numberint decimalPlace) {
         int n = decimalPlace;
         int c = 0;
         while (n > 10) {
             n = n / 10;
             c++;
         }
         decimalPlace = decimalPlace + c;
         final double factor = Math.pow(10, decimalPlace);
         final double result = Math.round(number * factor) / factor;
         return result;
     }
 
     public static boolean equals(double d1double d2int decimalPlace) {
         double d11 = round(d1decimalPlace);
         double d22 = round(d2decimalPlace);
         return Double.valueOf(d11).equals(Double.valueOf(d22));
     }

    
Get maximum of given values.

Parameters:
values values to get maximum from
Returns:
maximum value
Throws:
java.lang.IllegalArgumentException if values.length < 1 or values == null
 
     public static double max(double... values) {
         if (values == null || values.length < 1)
             throw new IllegalArgumentException();
         double result = values[0];
         for (double i : values) {
             if (i > result) {
                 result = i;
             }
         }
         return result;
     }
 
     public static double max(Collection<? extends Numbervalues) {
         return max(UtilArray.toPrimitive(values.toArray(new Number[values.size()])));
     }

    
Get minimum of given values.

Parameters:
values values to get minimum from
Returns:
minimum value
Throws:
java.lang.IllegalArgumentException if values.length < 1 or values == null
 
     public static double min(double... values) {
         if (values == null || values.length < 1)
             throw new IllegalArgumentException();
         double result = values[0];
        for (double i : values) {
            if (i < result)
                result = i;
        }
        return result;
    }
    public static double min(Collection<? extends Numbervalues) {
        return min(UtilArray.toPrimitive(values.toArray(new Number[values.size()])));
    }

    
Calculate the mean of given values.

Parameters:
values values to calculate the mean
Returns:
mean of values
Throws:
java.lang.IllegalArgumentException if values.length < 1 or values == null
    public static double mean(double... values) {
        if (values == null || values.length < 1)
            throw new IllegalArgumentException();
        return sum(values) / values.length;
    }
    public static double mean(Collection<? extends Numbervalues) {
        return mean(UtilArray.toPrimitive(values.toArray(new Number[values.size()])));
    }

    
Calculates the median of a collection of numbers.

Parameters:
values numbers to calculate median from
Returns:
median for given numbers
    public static double median(double... values) {
        if (values == null || values.length < 1)
            throw new IllegalArgumentException();
        // TODO necessary?
        double[] b = new double[values.length];
        System.arraycopy(values, 0, b, 0, b.length);
        Arrays.sort(b);
        if (values.length % 2 == 0) {
            return (b[(b.length / 2) - 1] + b[b.length / 2]) / 2;
        } else {
            return b[b.length / 2];
        }
    }

    
Calculates the median of a collection of numbers.

Parameters:
values numbers to calculate median from
Returns:
median for given numbers
    public static double median(Collection<? extends Numbervalues) {
        return median(UtilArray.toPrimitive(values.toArray(new Number[values.size()])));
    }

    
Calculate the sum of given values.

Parameters:
values values to calculate the sum
Returns:
sum of values * @throws IllegalArgumentException if values.length < 1 or values == null
    public static double sum(double... values) {
        if (values == null || values.length < 1)
            throw new IllegalArgumentException();
        double result = 0;
        for (double d : values) {
            result += d;
        }
        return result;
    }
    public static double sum(Collection<Doublevalues) {
        return sum(UtilArray.toPrimitive(values.toArray(new Double[values.size()])));
    }

    
Calculate the standard deviation of given values.

Parameters:
values values to calculate the standard deviation
Returns:
sum of values
Throws:
java.lang.IllegalArgumentException if values.length < 1 or values == null
    public static double stdDev(double... values) {
        if (values == null || values.length < 1) {
            throw new IllegalArgumentException();
        }
        if (values.length == 1) {
            return 0;
        }
        double sumOfSquares = 0;
        final double mean = mean(values);
        for (double d : values) {
            final double dd = d - mean;
            sumOfSquares += (dd) * (dd);
        }
        return Math.sqrt(sumOfSquares / (values.length - 1));
    }
    public static double stdDev(Collection<? extends Numbervalues) {
        return stdDev(UtilArray.toPrimitive(values.toArray(new Number[values.size()])));
    }
    public static double getClosest(double numberdouble... values) {
        if (values == null || values.length < 1)
            throw new IllegalArgumentException();
        if (values.length == 1) {
            return values[0];
        }
        final double[] arr = UtilArray.copy(values);
        Arrays.sort(arr);
        double result = arr[0];
        double diff = Math.abs(arr[0] - number);
        for (int i = 1; i < arr.lengthi++) {
            double diff2 = Math.abs(arr[i] - number);
            if (diff2 < diff) {
                diff = diff2;
                result = arr[i];
            }
        }
        return result;
    }
    public static double getClosest(double numberCollection<? extends Numbervalues) {
        return getClosest(number, UtilArray.toPrimitive(values.toArray(new Number[values.size()])));
    }

    
Increment given java.lang.Integer by 1.

Parameters:
integer java.lang.Integer to increment
Returns:
incremented java.lang.Integer
    public static Integer increment(Integer integer) {
        return increment(integer, 1);
    }

    
Increment given java.lang.Integer by {i}.

Parameters:
integer java.lang.Integer to increment
Returns:
incremented java.lang.Integer
    public static Integer increment(Integer integerint i) {
        return Integer.valueOf(integer.intValue() + i);
    }

    
Add one java.lang.Integer to another.

Parameters:
integer1 first java.lang.Integer
integer2 second java.lang.Integer
Returns:
sum of integer1 and integer2
    public static Integer add(Integer integer1Integer integer2) {
        return Integer.valueOf(integer1.intValue() + integer2.intValue());
    }
    public static double log2(double number) {
        return Math.log(number) / Math.log(2);
    }
    public static double lower(double d1double d2) {
        if (d1 < d2)
            return d1;
        else
            return d2;
    }
    public static double higher(double d1double d2) {
        if (d1 > d2)
            return d1;
        else
            return d2;
    }
    public static double assertAboveEqual(double numberdouble value) {
        if (number < value) {
            return value;
        }
        return number;
    }
    public static double assertBelowEqual(double numberdouble value) {
        if (number > value) {
            return value;
        }
        return number;
    }
New to GrepCode? Check out our FAQ X