How to calculate mean, median, mode and range from a set of numbers How to calculate mean, median, mode and range from a set of numbers java java

How to calculate mean, median, mode and range from a set of numbers


Yes, there does seem to be 3rd libraries (none in Java Math). Two that have come up are:

http://opsresearch.com/app/

http://www.iro.umontreal.ca/~simardr/ssj/indexe.html

but, it is actually not that difficult to write your own methods to calculate mean, median, mode and range.

MEAN

public static double mean(double[] m) {    double sum = 0;    for (int i = 0; i < m.length; i++) {        sum += m[i];    }    return sum / m.length;}

MEDIAN

// the array double[] m MUST BE SORTEDpublic static double median(double[] m) {    int middle = m.length/2;    if (m.length%2 == 1) {        return m[middle];    } else {        return (m[middle-1] + m[middle]) / 2.0;    }}

MODE

public static int mode(int a[]) {    int maxValue, maxCount;    for (int i = 0; i < a.length; ++i) {        int count = 0;        for (int j = 0; j < a.length; ++j) {            if (a[j] == a[i]) ++count;        }        if (count > maxCount) {            maxCount = count;            maxValue = a[i];        }    }    return maxValue;}

UPDATE

As has been pointed out by Neelesh Salpe, the above does not cater for multi-modal collections. We can fix this quite easily:

public static List<Integer> mode(final int[] numbers) {    final List<Integer> modes = new ArrayList<Integer>();    final Map<Integer, Integer> countMap = new HashMap<Integer, Integer>();    int max = -1;    for (final int n : numbers) {        int count = 0;        if (countMap.containsKey(n)) {            count = countMap.get(n) + 1;        } else {            count = 1;        }        countMap.put(n, count);        if (count > max) {            max = count;        }    }    for (final Map.Entry<Integer, Integer> tuple : countMap.entrySet()) {        if (tuple.getValue() == max) {            modes.add(tuple.getKey());        }    }    return modes;}

ADDITION

If you are using Java 8 or higher, you can also determine the modes like this:

public static List<Integer> getModes(final List<Integer> numbers) {    final Map<Integer, Long> countFrequencies = numbers.stream()            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));    final long maxFrequency = countFrequencies.values().stream()            .mapToLong(count -> count)            .max().orElse(-1);    return countFrequencies.entrySet().stream()            .filter(tuple -> tuple.getValue() == maxFrequency)            .map(Map.Entry::getKey)            .collect(Collectors.toList());}


    public static Set<Double> getMode(double[] data) {            if (data.length == 0) {                return new TreeSet<>();            }            TreeMap<Double, Integer> map = new TreeMap<>(); //Map Keys are array values and Map Values are how many times each key appears in the array            for (int index = 0; index != data.length; ++index) {                double value = data[index];                if (!map.containsKey(value)) {                    map.put(value, 1); //first time, put one                }                else {                    map.put(value, map.get(value) + 1); //seen it again increment count                }            }            Set<Double> modes = new TreeSet<>(); //result set of modes, min to max sorted            int maxCount = 1;            Iterator<Integer> modeApperance = map.values().iterator();            while (modeApperance.hasNext()) {                maxCount = Math.max(maxCount, modeApperance.next()); //go through all the value counts            }            for (double key : map.keySet()) {                if (map.get(key) == maxCount) { //if this key's value is max                    modes.add(key); //get it                }            }            return modes;        }        //std dev function for good measure        public static double getStandardDeviation(double[] data) {            final double mean = getMean(data);            double sum = 0;            for (int index = 0; index != data.length; ++index) {                sum += Math.pow(Math.abs(mean - data[index]), 2);            }            return Math.sqrt(sum / data.length);        }        public static double getMean(double[] data) {        if (data.length == 0) {            return 0;        }        double sum = 0.0;        for (int index = 0; index != data.length; ++index) {            sum += data[index];        }        return sum / data.length;    }//by creating a copy array and sorting it, this function can take any data.    public static double getMedian(double[] data) {        double[] copy = Arrays.copyOf(data, data.length);        Arrays.sort(copy);        return (copy.length % 2 != 0) ? copy[copy.length / 2] : (copy[copy.length / 2] + copy[(copy.length / 2) - 1]) / 2;    }