Computes the (linear) correlation between two arrays. - Java Collection Framework

Java examples for Collection Framework:Array Algorithm

  1. HOME
  2. Java
  3. Collection Framework
  4. Array Algorithm

Description

Computes the (linear) correlation between two arrays.

Demo Code


//package com.java2s;

public class Main {
    public static void main(String[] argv) throws Exception {
        double[] v1 = new double[] { 34.45, 35.45, 36.67, 37.78, 37.0000,
                37.1234, 67.2344, 68.34534, 69.87700 };
        double[] v2 = new double[] { 34.45, 35.45, 36.67, 37.78, 37.0000,
                37.1234, 67.2344, 68.34534, 69.87700 };
        System.out.println(correlation(v1, v2));
    }//from w ww. j av  a  2s.c  o  m

    /**
     * Computes the (linear) correlation between two arrays.
     * Squaring this result and multiply by 100 gives you
     * the percentage of correlation.
     */
    public static double correlation(double[] v1, double[] v2) {
        double denom = Math.sqrt(variance(v1) * variance(v2));
        if (denom != 0)
            return (covariance(v1, v2) / denom);
        else {
            if ((variance(v1) == 0) && (variance(v2) == 0))
                return (1.0);
            else
                return (0.0); // impossible to correlate a null signal with another
        }
    }

    /**
     * Computes the (linear) correlation between two arrays.
     * Squaring this result and multiply by 100 gives you
     * the percentage of correlation.
     */
    public static double correlation(int[] v1, int[] v2) {
        double denom = Math.sqrt(variance(v1) * variance(v2));
        if (denom != 0)
            return (covariance(v1, v2) / denom);
        else {
            if ((variance(v1) == 0) && (variance(v2) == 0))
                return (1.0);
            else
                return (0.0); // impossible to correlate a null signal with another
        }
    }

    /**
     * Computes the (bias-corrected sample) variance.
     */
    public static double variance(double[] v) {
        if (v.length > 1) {
            final double m = mean(v);
            double ans = 0.0;
            for (int i = 0; i < v.length; i++)
                ans += (v[i] - m) * (v[i] - m);
            return ans / (v.length - 1);
        } else
            throw new IllegalArgumentException(
                    "Array length must be of 2 or greater.");
    }

    /**
     * Computes the (bias-corrected sample) variance.
     */
    public static double variance(int[] v) {
        if (v.length > 1) {
            final double m = mean(v);
            double ans = 0.0;
            for (int i = 0; i < v.length; i++)
                ans += (v[i] - m) * (v[i] - m);
            return ans / (v.length - 1);
        } else
            throw new IllegalArgumentException(
                    "Array length must be of 2 or greater.");
    }

    /**
     * Computes the covariance.
     */
    public static double covariance(double[] v1, double[] v2) {
        if (v1.length != v2.length)
            throw new IllegalArgumentException(
                    "Arrays must have the same length : " + v1.length
                            + ", " + v2.length);
        final double m1 = mean(v1);
        final double m2 = mean(v2);
        double ans = 0.0;
        for (int i = 0; i < v1.length; i++)
            ans += (v1[i] - m1) * (v2[i] - m2);
        return ans / (v1.length - 1);
    }

    /**
     * Computes the covariance.
     */
    public static double covariance(int[] v1, int[] v2) {
        if (v1.length != v2.length)
            throw new IllegalArgumentException(
                    "Arrays must have the same length : " + v1.length
                            + ", " + v2.length);
        final double m1 = mean(v1);
        final double m2 = mean(v2);
        double ans = 0.0;
        for (int i = 0; i < v1.length; i++)
            ans += (v1[i] - m1) * (v2[i] - m2);
        return ans / (v1.length - 1);
    }

    /**
     * Computes the mean.
     */
    public static double mean(double[] v) {
        if (v.length == 0)
            throw new IllegalArgumentException(
                    "Nothing to compute! The array must have at least one element.");
        return (mass(v) / (double) v.length);
    }

    /**
     * Computes the mean.
     */
    public static double mean(int[] v) {
        if (v.length == 0)
            throw new IllegalArgumentException(
                    "Nothing to compute! The array must have at least one element.");
        return (mass(v) / (double) v.length);
    }

    /**
     * Returns the sum of the elements of the array.
     */
    public static double mass(double[] v) {
        double somme = 0.0;
        for (int k = 0; k < v.length; k++) {
            somme += v[k];
        }
        return (somme);
    }

    /**
     * Returns the sum of the elements of the array.
     */
    public static int mass(int[] v) {
        int somme = 0;
        for (int k = 0; k < v.length; k++) {
            somme += v[k];
        }
        return (somme);
    }
}

Related Tutorials