src/test/org/apache/commons/math/stat/StatUtilsTest.java

/*
 * Copyright 2003-2004 The Apache Software Foundation.
 * 
 * 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 org.apache.commons.math.stat;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

import org.apache.commons.math.TestUtils;

/**
 * Test cases for the {@link StatUtils} class.
 * @version $Revision$ $Date$
 */

public final class StatUtilsTest extends TestCase {

    private double one = 1;
    private float two = 2;
    private int three = 3;
    private double mean = 2;
    private double sumSq = 18;
    private double sum = 8;
    private double var = 0.666666666666666666667;
    private double std = Math.sqrt(var);
    private double n = 4;
    private double min = 1;
    private double max = 3;
    private double skewness = 0;
    private double kurtosis = 0.5;
    private double tolerance = 10E-15;

    public StatUtilsTest(String name) {
        super(name);
    }

    public void setUp() {
    }

    public static Test suite() {
        TestSuite suite = new TestSuite(StatUtilsTest.class);
        suite.setName("StatUtil Tests");
        return suite;
    }

    /** test stats */
    public void testStats() {
        double[] values = new double[] { one, two, two, three };
        assertEquals("sum", sum, StatUtils.sum(values), tolerance);
        assertEquals("sumsq", sumSq, StatUtils.sumSq(values), tolerance);
        assertEquals("var", var, StatUtils.variance(values), tolerance);
        assertEquals("var with mean", var, StatUtils.variance(values, mean), tolerance);
        assertEquals("mean", mean, StatUtils.mean(values), tolerance);
        assertEquals("min", min, StatUtils.min(values), tolerance);
        assertEquals("max", max, StatUtils.max(values), tolerance);
    }

    public void testN0andN1Conditions() throws Exception {
        double[] values = new double[0];

        assertTrue(
            "Mean of n = 0 set should be NaN",
            Double.isNaN(StatUtils.mean(values)));
        assertTrue(
            "Variance of n = 0 set should be NaN",
            Double.isNaN(StatUtils.variance(values)));

        values = new double[] { one };

        assertTrue(
            "Mean of n = 1 set should be value of single item n1",
            StatUtils.mean(values) == one);
        assertTrue(
            "Variance of n = 1 set should be zero",
            StatUtils.variance(values) == 0);
    }

    public void testArrayIndexConditions() throws Exception {
        double[] values = { 1.0, 2.0, 3.0, 4.0 };

        assertEquals(
            "Sum not expected",
            5.0,
            StatUtils.sum(values, 1, 2),
            Double.MIN_VALUE);
        assertEquals(
            "Sum not expected",
            3.0,
            StatUtils.sum(values, 0, 2),
            Double.MIN_VALUE);
        assertEquals(
            "Sum not expected",
            7.0,
            StatUtils.sum(values, 2, 2),
            Double.MIN_VALUE);

        try {
            StatUtils.sum(values, 2, 3);
            assertTrue("Didn't throw exception", false);
        } catch (Exception e) {
            assertTrue(true);
        }

        try {
            StatUtils.sum(values, -1, 2);
            assertTrue("Didn't throw exception", false);
        } catch (Exception e) {
            assertTrue(true);
        }

    }
    
    public void testSumSq() {
        double[] x = null;
        
        // test null
        try {
            StatUtils.sumSq(x);
            fail("null is not a valid data array.");
        } catch (IllegalArgumentException ex) {
            // success
        }
        
        try {
            StatUtils.sumSq(x, 0, 4);
            fail("null is not a valid data array.");
        } catch (IllegalArgumentException ex) {
            // success
        }
        
        // test empty
        x = new double[] {};
        TestUtils.assertEquals(Double.NaN, StatUtils.sumSq(x), tolerance);
        TestUtils.assertEquals(Double.NaN, StatUtils.sumSq(x, 0, 0), tolerance);
        
        // test one
        x = new double[] {two};
        TestUtils.assertEquals(4, StatUtils.sumSq(x), tolerance);
        TestUtils.assertEquals(4, StatUtils.sumSq(x, 0, 1), tolerance);
        
        // test many
        x = new double[] {one, two, two, three};
        TestUtils.assertEquals(18, StatUtils.sumSq(x), tolerance);
        TestUtils.assertEquals(8, StatUtils.sumSq(x, 1, 2), tolerance);
    }
    
    public void testProduct() {
        double[] x = null;
        
        // test null
        try {
            StatUtils.product(x);
            fail("null is not a valid data array.");
        } catch (IllegalArgumentException ex) {
            // success
        }
        
        try {
            StatUtils.product(x, 0, 4);
            fail("null is not a valid data array.");
        } catch (IllegalArgumentException ex) {
            // success
        }
        
        // test empty
        x = new double[] {};
        TestUtils.assertEquals(Double.NaN, StatUtils.product(x), tolerance);
        TestUtils.assertEquals(Double.NaN, StatUtils.product(x, 0, 0), tolerance);
        
        // test one
        x = new double[] {two};
        TestUtils.assertEquals(two, StatUtils.product(x), tolerance);
        TestUtils.assertEquals(two, StatUtils.product(x, 0, 1), tolerance);
        
        // test many
        x = new double[] {one, two, two, three};
        TestUtils.assertEquals(12, StatUtils.product(x), tolerance);
        TestUtils.assertEquals(4, StatUtils.product(x, 1, 2), tolerance);
    }
    
    public void testSumLog() {
        double[] x = null;
        
        // test null
        try {
            StatUtils.sumLog(x);
            fail("null is not a valid data array.");
        } catch (IllegalArgumentException ex) {
            // success
        }
        
        try {
            StatUtils.sumLog(x, 0, 4);
            fail("null is not a valid data array.");
        } catch (IllegalArgumentException ex) {
            // success
        }
        
        // test empty
        x = new double[] {};
        TestUtils.assertEquals(Double.NaN, StatUtils.sumLog(x), tolerance);
        TestUtils.assertEquals(Double.NaN, StatUtils.sumLog(x, 0, 0), tolerance);
        
        // test one
        x = new double[] {two};
        TestUtils.assertEquals(Math.log(two), StatUtils.sumLog(x), tolerance);
        TestUtils.assertEquals(Math.log(two), StatUtils.sumLog(x, 0, 1), tolerance);
        
        // test many
        x = new double[] {one, two, two, three};
        TestUtils.assertEquals(Math.log(one) + 2.0 * Math.log(two) + Math.log(three), StatUtils.sumLog(x), tolerance);
        TestUtils.assertEquals(2.0 * Math.log(two), StatUtils.sumLog(x, 1, 2), tolerance);
    }
    
    public void testMean() {
        double[] x = null;
        
        try {
            StatUtils.mean(x, 0, 4);
            fail("null is not a valid data array.");
        } catch (IllegalArgumentException ex) {
            // success
        }
        
        // test empty
        x = new double[] {};
        TestUtils.assertEquals(Double.NaN, StatUtils.mean(x, 0, 0), tolerance);
        
        // test one
        x = new double[] {two};
        TestUtils.assertEquals(two, StatUtils.mean(x, 0, 1), tolerance);
        
        // test many
        x = new double[] {one, two, two, three};
        TestUtils.assertEquals(2.5, StatUtils.mean(x, 2, 2), tolerance);
    }
    
    public void testVariance() {
        double[] x = null;
        
        try {
            StatUtils.variance(x, 0, 4);
            fail("null is not a valid data array.");
        } catch (IllegalArgumentException ex) {
            // success
        }
        
        // test empty
        x = new double[] {};
        TestUtils.assertEquals(Double.NaN, StatUtils.variance(x, 0, 0), tolerance);
        
        // test one
        x = new double[] {two};
        TestUtils.assertEquals(0.0, StatUtils.variance(x, 0, 1), tolerance);
        
        // test many
        x = new double[] {one, two, two, three};
        TestUtils.assertEquals(0.5, StatUtils.variance(x, 2, 2), tolerance);
        
        // test precomputed mean
        x = new double[] {one, two, two, three};
        TestUtils.assertEquals(0.5, StatUtils.variance(x,2.5, 2, 2), tolerance);
    }
    
    public void testMax() {
        double[] x = null;
        
        try {
            StatUtils.max(x, 0, 4);
            fail("null is not a valid data array.");
        } catch (IllegalArgumentException ex) {
            // success
        }
        
        // test empty
        x = new double[] {};
        TestUtils.assertEquals(Double.NaN, StatUtils.max(x, 0, 0), tolerance);
        
        // test one
        x = new double[] {two};
        TestUtils.assertEquals(two, StatUtils.max(x, 0, 1), tolerance);
        
        // test many
        x = new double[] {one, two, two, three};
        TestUtils.assertEquals(three, StatUtils.max(x, 1, 3), tolerance);
    }
    
    public void testMin() {
        double[] x = null;
        
        try {
            StatUtils.min(x, 0, 4);
            fail("null is not a valid data array.");
        } catch (IllegalArgumentException ex) {
            // success
        }
        
        // test empty
        x = new double[] {};
        TestUtils.assertEquals(Double.NaN, StatUtils.min(x, 0, 0), tolerance);
        
        // test one
        x = new double[] {two};
        TestUtils.assertEquals(two, StatUtils.min(x, 0, 1), tolerance);
        
        // test many
        x = new double[] {one, two, two, three};
        TestUtils.assertEquals(two, StatUtils.min(x, 1, 3), tolerance);
    }
    
    public void testPercentile() {
        double[] x = null;
        
        // test null
        try {
            StatUtils.percentile(x, .25);
            fail("null is not a valid data array.");
        } catch (IllegalArgumentException ex) {
            // success
        }
        
        try {
            StatUtils.percentile(x, 0, 4, 0.25);
            fail("null is not a valid data array.");
        } catch (IllegalArgumentException ex) {
            // success
        }
        
        // test empty
        x = new double[] {};
        TestUtils.assertEquals(Double.NaN, StatUtils.percentile(x, 25), tolerance);
        TestUtils.assertEquals(Double.NaN, StatUtils.percentile(x, 0, 0, 25), tolerance);
        
        // test one
        x = new double[] {two};
        TestUtils.assertEquals(two, StatUtils.percentile(x, 25), tolerance);
        TestUtils.assertEquals(two, StatUtils.percentile(x, 0, 1, 25), tolerance);
        
        // test many
        x = new double[] {one, two, two, three};
        TestUtils.assertEquals(2.5, StatUtils.percentile(x, 70), tolerance);
        TestUtils.assertEquals(2.5, StatUtils.percentile(x, 1, 3, 62.5), tolerance);
    }
    
    public void testDifferenceStats() throws Exception {
        double sample1[] = {1d, 2d, 3d, 4d};
        double sample2[] = {1d, 3d, 4d, 2d};
        double diff[] = {0d, -1d, -1d, 2d};
        double small[] = {1d, 4d};
        double meanDifference = StatUtils.meanDifference(sample1, sample2);
        assertEquals(StatUtils.sumDifference(sample1, sample2), StatUtils.sum(diff), tolerance);
        assertEquals(meanDifference, StatUtils.mean(diff), tolerance);
        assertEquals(StatUtils.varianceDifference(sample1, sample2, meanDifference), 
                StatUtils.variance(diff), tolerance);
        try {
            StatUtils.meanDifference(sample1, small);
            fail("Expecting IllegalArgumentException");
        } catch (IllegalArgumentException ex) {
            // expected
        }
    }
    
    public void testGeometricMean() throws Exception {
        double[] test = null;
        try {
            double x = StatUtils.geometricMean(test);
            fail("Expecting IllegalArgumentException");
        } catch (IllegalArgumentException ex) {
            // expected
        }
        test = new double[] {2, 4, 6, 8};
        assertEquals(Math.exp(0.25d * StatUtils.sumLog(test)), 
                StatUtils.geometricMean(test), Double.MIN_VALUE);
    }
}