// Catalano Statistics Library
// The Catalano Framework
//
// Copyright © Diego Catalano, 2012-2016
// diego.catalano at live.com
//
//    This library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    This library 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
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with this library; if not, write to the Free Software
//    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

package Catalano.Statistics;

import Catalano.Math.Matrix;
import java.util.Arrays;

/**
 * Common tools used in statistics.
 * @author Diego Catalano
 */
public class Tools {

    private Tools() {}
    
    /**
     * Alpha Trimmed Mean
     * @param values Values.
     * @param alpha Percentage [0..1]
     * @return Alpha trimmed mean.
     */
    public static double AlphaTrimmedMean(double[] values, float alpha){
        
        int lower = (int)(values.length * alpha);
        int upper = values.length - lower;
        
        double sum = 0;
        for (int i = lower; i < upper; i++)
            sum += values[i];
        
        
        return sum / (upper - lower);
        
    }
    
    /**
     * Alpha Trimmed Mean
     * @param values Values.
     * @param n Number of elements.
     * @return Alpha trimmed mean.
     */
    public static double AlphaTrimmedMean(double[] values, int n){
        
        int upper = values.length - n;
        
        double sum = 0;
        for (int i = n; i < upper; i++)
            sum += values[i];
        
        return sum / (upper - n);
        
    }
    
    /**
     * Alpha Trimmed Mean
     * @param values Values.
     * @param alpha Percentage [0..1]
     * @return Alpha trimmed mean.
     */
    public static double AlphaTrimmedMean(int[] values, float alpha){
        
        int lower = (int)(values.length * alpha);
        int upper = values.length - lower;
        
        double sum = 0;
        for (int i = lower; i < upper; i++) {
            sum += values[i];
        }
        
        return sum / (upper - lower);
        
    }
    
    /**
     * Alpha Trimmed Mean
     * @param values Values.
     * @param n Number of elements.
     * @return Alpha trimmed mean.
     */
    public static double AlphaTrimmedMean(int[] values, int n){
        
        int upper = values.length - n;
        
        double sum = 0;
        for (int i = n; i < upper; i++)
            sum += values[i];
        
        return sum / (upper - n);
        
    }
    
    /**
     * Coefficient of variation.
     * @param x Vector.
     * @return Coefficient of variation.
     */
    public static double CoefficientOfVariation(double[] x){
        double mean = Mean(x);
        double std = Math.sqrt(Variance(x, mean));
        return std / mean;
    }
    
    /**
     * Create a pearson correlation matrix.
     * @param data Data.
     * @return Correlation matrix.
     */
    public static double[][] Correlation(double[][] data){
        double[][] co = new double[data[0].length][data[0].length];
        for (int i = 0; i < co.length; i++) {
            for (int j = 0; j < co[0].length; j++) {
                if(i == j){
                    co[i][j] = 1;
                }
                else{
                    double[] colX = Matrix.getColumn(data, i);
                    double[] colY = Matrix.getColumn(data, j);
                    co[i][j] = Correlations.PearsonCorrelation(colX, colY);
                }
            }
        }
        return co;
    }
    
    /**
     * Covariance between vector x and y.
     * @param x Vector.
     * @param y Vector.
     * @return Covariance between x and y.
     */
    public static double Covariance(double[] x, double[] y){
        if (x.length != y.length)
            throw new IllegalArgumentException("The size of both matrix needs be equal");
        
        double meanX = 0, meanY = 0;
        for (int i = 0; i < x.length; i++) {
            meanX += x[i];
            meanY += y[i];
        }
        meanX /= x.length;
        meanY /= y.length;
        
        return Covariance(x,y,meanX,meanY);
    }
    
    /**
     * Covariance between vector x and y.
     * @param x Vector.
     * @param y Vector.
     * @param meanX X mean.
     * @param meanY Y mean.
     * @return Covariance between x and y.
     */
    public static double Covariance(double[] x, double[] y, double meanX, double meanY){
        double result = 0;
        for (int i = 0; i < x.length; i++) {
            result += (x[i] - meanX) * (y[i] - meanY);
        }
        
        return result / (double)(x.length - 1);
    }
    
    /**
     * Matrix of covariance.
     * @param matrix Matrix.
     * @return Matrix of covariance.
     */
    public static double[][] Covariance(double[][] matrix){
        double[] means = new double[matrix[0].length];
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                means[j] += matrix[i][j];
            }
        }
        
        for (int i = 0; i < means.length; i++) {
            means[i] /= means.length;
        }
        
        return Covariance(matrix, means);
    }
    
    /**
     * Matrix of covariance.
     * @param matrix Matrix.
     * @param means Means.
     * @return Matrix of covariance.
     */
    public static double[][] Covariance(double[][] matrix, double[] means){
        double[][] cov = new double[means.length][means.length];
        
        for (int i = 0; i < cov.length; i++) {
            for (int j = 0; j < cov[0].length; j++) {
                cov[i][j] = Covariance(Matrix.getColumn(matrix, i), Matrix.getColumn(matrix, j), means[i], means[j]);
            }
        }
        
        return cov;
        
    }
    
    /**
     * Fisher.
     * @param n Number.
     * @return Fisher number.
     */
    public static double Fisher(double n){
        
        if ((n <= -1) || (n >= 1))
            throw new IllegalArgumentException("Fisher works with number between -1 < x < 1");
        
        double r = (1 + n) / (1 - n);
        return 0.5 * Math.log(r);
    }
    
    /**
     * Inclination.
     * @param x Vector.
     * @param y Vector.
     * @return Inclination between the vector x and y.
     */
    public static double Inclination(double[] x, double[] y){
        if (x.length != y.length)
            throw new IllegalArgumentException("The size of both matrix needs be equal");
        
        double meanX = 0; double meanY = 0;
        for (int i = 0; i < x.length; i++) {
            meanX += x[i];
            meanY += y[i];
        }
        
        meanX /= x.length;
        meanY /= y.length;
        
        double num = 0, den = 0;
        for (int i = 0; i < x.length; i++) {
            num += (x[i] - meanX) * (y[i] - meanY);
            den += Math.pow((x[i] - meanX),2);
        }
        
        return num/den;
    }
    
    /**
     * Inverse fisher.
     * @param n Number.
     * @return Inverse fisher of the number.
     */
    public static double InverseFisher(double n){
        if ((n <= -1) || (n >= 1))
            throw new IllegalArgumentException("Fisher works with number between -1 < x < 1");
        
        double r = (Math.pow(Math.E,2 * n) - 1) / (Math.pow(Math.E,2 * n) + 1);
        return r;
    }
    
    /**
     * Interception.
     * @param x Vector.
     * @param y Vector.
     * @return Interception between the vector x and y.
     */
    public static double Interception(double[] x, double[] y){
        if (x.length != y.length)
            throw new IllegalArgumentException("The size of both matrix needs be equal");
        
        double meanX = 0; double meanY = 0;
        for (int i = 0; i < x.length; i++) {
            meanX += x[i];
            meanY += y[i];
        }
        
        meanX /= x.length;
        meanY /= y.length;
        
        double b = Inclination(x, y);
        double a = meanY - (b * meanX);
        return a;
    }
    
    /**
     * Maximum element.
     * @param x Vector.
     * @return Maximum element of the vector,
     */
    public static double Max(double[] x){
        double m = x[0];
        for (int i = 1; i < x.length; i++)
            if(x[i] > m) m = x[i];
        
        return m;
    }
    
    /**
     * Mean.
     * @param x Vector.
     * @return Mean of the vector.
     */
    public static double Mean(double[] x){
        double r = 0;
        for (int i = 0; i < x.length; i++) {
            r += x[i];
        }
        
        return r / (double)x.length;
    }
    
    /**
     * Mean of the matrix for each column.
     * @param data Data.
     * @return Mean of the each column.
     */
    public static double[] Mean(double[][] data){
        
        double[] means = new double[data[0].length];
        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data[0].length; j++) {
                means[j] += data[i][j];
            }
        }

        for (int i = 0; i < means.length; i++) {
            means[i] /= (double)data.length;
        }
        return means;
        
    }
    
    /**
     * Minimum element.
     * @param x Vector.
     * @return Minimum element of the vector.
     */
    public static double Min(double[] x){
        double m = x[0];
        for (int i = 1; i < x.length; i++)
            if(x[i] < m) m = x[i];
        
        return m;
    }
    
    /**
     * Mode of the vector.
     * @param values Values.
     * @return Mode.
     */
    public static double Mode(double[] values){
        Arrays.sort(values);
        double v = values[0];
        int index = 0, x = 0, rep = 0;
        for (int i = 1; i < values.length; i++) {
            if (values[i] == v) {
                x++;
                if (x > rep) {
                    rep = x;
                    index = i;
                }
                v = values[i];
                x = 0;
            }
            else{
                if (x > rep) {
                    rep = x;
                    index = i;
                }
                v = values[i];
                x = 0;
            }
        }
        return values[index];
    }
    
    /**
     * Mode of the vector.
     * @param values Values.
     * @return Mode.
     */
    public static int Mode(int[] values){
        Arrays.sort(values);
        int v = values[0];
        int index = 0, x = 0, rep = 0;
        for (int i = 1; i < values.length; i++) {
            if (values[i] == v) {
                x++;
                if (x > rep) {
                    rep = x;
                    index = i;
                }
                v = values[i];
                x = 0;
            }
            else{
                if (x > rep) {
                    rep = x;
                    index = i;
                }
                v = values[i];
                x = 0;
            }
        }
        return values[index];
    }
    
    /**
     * Geometric mean.
     * @param x Vector.
     * @return Geometric mean.
     */
    public static double GeometricMean(double[] x){
        
        double r = 1;
        for (int i = 0; i < x.length; i++) {
            r *= x[i];
        }
        
        return Math.pow(r,(double)1/x.length);
    }
    
    /**
     * Harmonic mean.
     * @param x Vector.
     * @return Harmonic mean.
     */
    public static double HarmonicMean(double[] x){
        
        double r = 0;
        for (int i = 0; i < x.length; i++) {
            r += 1 / x[i];
        }
        
        return x.length / r;
    }
    
    /**
     * Contra Harmonic mean.
     * @param x Vector.
     * @param order Order.
     * @return Contra Harmonic mean.
     */
    public static double ContraHarmonicMean(double[] x, int order){
        
        double r1 = 0, r2 = 0;
        for (int i = 0; i < x.length; i++) {
            r1 += Math.pow(x[i], order + 1);
            r2 += Math.pow(x[i], order);
        }
        
        return r1 / r2;
    }
    
    /**
     * Sum.
     * @param x Vector.
     * @return Sum of the all elements.
     */
    public static double Sum(double[] x){
        double sum = 0;
        for (int i = 0; i < x.length; i++) {
            sum += x[i];
        }
        return sum;
    }
    
    /**
     * Variance
     * @param x Vector.
     * @return Variance of the vector.
     */
    public static double Variance(double[] x){
        return Variance(x, Mean(x));
    }
    
    /**
     * Variance.
     * @param x Vector.
     * @param mean Mean.
     * @return Variance of the vector.
     */
    public static double Variance(double[] x, double mean){
        double sum = 0;
        for (int i = 0; i < x.length; i++) {
            sum += Math.pow((x[i] - mean), 2);
        }
        double var = sum / ((double)x.length - 1);
        return var;
    }
    
    /**
     * Standart deviation.
     * @param x Vector.
     * @return Standart deviation of the vector.
     */
    public static double StandartDeviation(double[] x){
        return Math.sqrt(Variance(x));
    }
    
    /**
     * Standart deviation.
     * @param x Vector.
     * @param mean Mean.
     * @return Standart deviation of the vector.
     */
    public static double StandartDeviation(double[] x, double mean){
        return Math.sqrt(Variance(x, mean));
    }
    
    /**
     * Standart deviation for each column.
     * @param data Data.
     * @return Standart deviation of the data.
     */
    public static double[] StandartDeviation(double[][] data){
        double[] means = Mean(data);
        return StandartDeviation(data, means);
    }
    
    /**
     * Standart deviation for each column.
     * @param data Data.
     * @param means Means of the columns.
     * @return Standart deviation of the data.
     */
    public static double[] StandartDeviation(double[][] data, double[] means){
        
        double[] std = new double[means.length];
        
        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data[0].length; j++) {
                std[j] += Math.pow(data[i][j] - means[j], 2);
            }
        }

        for (int i = 0; i < std.length; i++) {
            std[i] = Math.sqrt(std[i] / ((double)data.length - 1D));
        }
        
        return std;
    }
}
 

Ads help maintain this website.