StatUtils.java

Go to the documentation of this file.

/*
 *   DENOPTIM
 *   Copyright (C) 2019 Vishwesh Venkatraman <vishwesh.venkatraman@ntnu.no>
 * 
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published
 *   by the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
package denoptim.utils;
 
public final class StatUtils
{
 
//------------------------------------------------------------------------------
 
    public static double sum(double[] numbers)
    {
        double sum = 0;
        for (double number : numbers) {
            sum += number;
        }
        return sum;
    }
 
//------------------------------------------------------------------------------
 
    public static double mean(double[] numbers)
    {
        double sum = sum(numbers);
        return sum / numbers.length;
    }
 
//------------------------------------------------------------------------------
 
    public static double min(double[] numbers)
    {
        double min = Integer.MAX_VALUE;
        for (double number : numbers) {
            if (number < min)
                min = number;
        }
        return min;
    }
 
//------------------------------------------------------------------------------
 
    public static double max(double[] numbers)
    {
        double max = Integer.MIN_VALUE;
        for (double number : numbers) {
            if (number > max)
                max = number;
        }
        return max;
    }
 
  //------------------------------------------------------------------------------
 
    public static double stddev(double[] numbers, boolean biasCorrected)
    {
        double stddev = Double.NaN;
        int n = numbers.length;
        if (n > 0)
        {
            if (n > 1)
            {
                stddev = Math.sqrt(var(numbers, biasCorrected));
            }
            else
            {
                stddev = 0.0;
            }
        }
        return stddev;
    }
    
//------------------------------------------------------------------------------
 
    public static double var(double[] numbers, boolean biasCorrected)
    {
        int n = numbers.length;
        if (n == 0)
            return Double.NaN;
        else if (n == 1)
            return 0d;
 
        double mean = mean(numbers);
        double[] squares = new double[numbers.length];
        for (int i=0; i<numbers.length; i++)
        {
            double XminMean = numbers[i] - mean;
            squares[i] = Math.pow(XminMean, 2);
        }
        double sum = sum(squares);
        return sum / (biasCorrected ? (n - 1) : n);
    }
 
//------------------------------------------------------------------------------
 
    public static double median(double[] m)
    {
        int middle = m.length / 2;  // subscript of middle element
        if (m.length % 2 == 1)
        {
            // Odd number of elements -- return the middle one.
            return m[middle];
        }
        else
        {
            // Even number -- return average of middle two
            // Must cast the numbers to double before dividing.
            return (m[middle-1] + m[middle]) / 2.0;
        }
    }
 
  //------------------------------------------------------------------------------
 
    public static double kurtosis(double[] m, boolean biasCorrected)
    {
        double value = Double.NaN;
        int N = m.length;
        if (N > 3)
        {
            double variance = var(m, biasCorrected);
            if (N <= 3 || variance < 10E-20)
            {
                value = 0.0;
            }
            else
            {
                double n = N;
                double f1 = (n*(n+1)) /((n -1) * (n - 2) * (n - 3));
                double avg = mean(m);
                double f2 = 0, f3 = 0;
                for (int i=0; i<N; i++)
                {
                    f2 += Math.pow((m[i] - avg), 4);
                    f3 += Math.pow((m[i] - avg), 2);
                }
 
                double f4 = (3 * (n-1) * (n -1)) / ((n-2)*(n-3));
 
                value = (f1 * (Math.pow(f2, 4)/Math.pow(f3, 2))) - f4;
            }
        }
        return value;
    }
    
//------------------------------------------------------------------------------
    
    public static double skewness(double[] m, boolean biasCorrected)
    {
        double n = m.length;
        if (n <= 3) {
            return Double.NaN;
        }
        double sampleSizeCorrectionTerm = Math.sqrt(n * (n - 1)) / (n - 2);
        double biasedStandardDeviation = Math.sqrt(n / (n - 1)) 
                * stddev(m, biasCorrected);
        double accDeviationFromMean = 0.0;
        double mean = mean(m);
        for (double v : m) {
            accDeviationFromMean += v - mean;
        }
        return sampleSizeCorrectionTerm
                * (accDeviationFromMean / (n * biasedStandardDeviation));
    }
 
//------------------------------------------------------------------------------
 
}