| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You 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.math4.legacy.stat.inference; |
| |
| import org.apache.commons.math4.legacy.exception.DimensionMismatchException; |
| import org.apache.commons.math4.legacy.exception.NotPositiveException; |
| import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException; |
| import org.apache.commons.math4.legacy.exception.OutOfRangeException; |
| import org.apache.commons.math4.legacy.exception.ZeroException; |
| import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath; |
| import org.junit.Assert; |
| import org.junit.Test; |
| |
| /** |
| * Test cases for the GTest class. |
| * |
| * Data for the tests are from p64-69 in: McDonald, J.H. 2009. Handbook of |
| * Biological Statistics (2nd ed.). Sparky House Publishing, Baltimore, |
| * Maryland. |
| * |
| */ |
| public class GTestTest { |
| |
| protected GTest testStatistic = new GTest(); |
| |
| @Test |
| public void testGTestGoodnesOfFit1() throws Exception { |
| final double[] exp = new double[]{ |
| 3d, 1d |
| }; |
| |
| final long[] obs = new long[]{ |
| 423, 133 |
| }; |
| |
| Assert.assertEquals("G test statistic", |
| 0.348721, testStatistic.g(exp, obs), 1E-6); |
| final double p_gtgf = testStatistic.gTest(exp, obs); |
| Assert.assertEquals("g-Test p-value", 0.55483, p_gtgf, 1E-5); |
| |
| Assert.assertFalse(testStatistic.gTest(exp, obs, 0.05)); |
| } |
| |
| @Test |
| public void testGTestGoodnesOfFit2() throws Exception { |
| final double[] exp = new double[]{ |
| 0.54d, 0.40d, 0.05d, 0.01d |
| }; |
| |
| final long[] obs = new long[]{ |
| 70, 79, 3, 4 |
| }; |
| Assert.assertEquals("G test statistic", |
| 13.144799, testStatistic.g(exp, obs), 1E-6); |
| final double p_gtgf = testStatistic.gTest(exp, obs); |
| Assert.assertEquals("g-Test p-value", 0.004333, p_gtgf, 1E-5); |
| |
| Assert.assertTrue(testStatistic.gTest(exp, obs, 0.05)); |
| } |
| |
| @Test |
| public void testGTestGoodnesOfFit3() throws Exception { |
| final double[] exp = new double[]{ |
| 0.167d, 0.483d, 0.350d |
| }; |
| |
| final long[] obs = new long[]{ |
| 14, 21, 25 |
| }; |
| |
| Assert.assertEquals("G test statistic", |
| 4.5554, testStatistic.g(exp, obs), 1E-4); |
| // Intrinisic (Hardy-Weinberg proportions) P-Value should be 0.033 |
| final double p_gtgf = testStatistic.gTestIntrinsic(exp, obs); |
| Assert.assertEquals("g-Test p-value", 0.0328, p_gtgf, 1E-4); |
| |
| Assert.assertFalse(testStatistic.gTest(exp, obs, 0.05)); |
| } |
| |
| @Test |
| public void testGTestIndependence1() throws Exception { |
| final long[] obs1 = new long[]{ |
| 268, 199, 42 |
| }; |
| |
| final long[] obs2 = new long[]{ |
| 807, 759, 184 |
| }; |
| |
| final double g = testStatistic.gDataSetsComparison(obs1, obs2); |
| |
| Assert.assertEquals("G test statistic", |
| 7.3008170, g, 1E-6); |
| final double p_gti = testStatistic.gTestDataSetsComparison(obs1, obs2); |
| |
| Assert.assertEquals("g-Test p-value", 0.0259805, p_gti, 1E-6); |
| Assert.assertTrue(testStatistic.gTestDataSetsComparison(obs1, obs2, 0.05)); |
| } |
| |
| @Test |
| public void testGTestIndependence2() throws Exception { |
| final long[] obs1 = new long[]{ |
| 127, 99, 264 |
| }; |
| |
| final long[] obs2 = new long[]{ |
| 116, 67, 161 |
| }; |
| |
| final double g = testStatistic.gDataSetsComparison(obs1, obs2); |
| |
| Assert.assertEquals("G test statistic", |
| 6.227288, g, 1E-6); |
| final double p_gti = testStatistic.gTestDataSetsComparison(obs1, obs2); |
| |
| Assert.assertEquals("g-Test p-value", 0.04443, p_gti, 1E-5); |
| Assert.assertTrue(testStatistic.gTestDataSetsComparison(obs1, obs2, 0.05)); |
| } |
| |
| @Test |
| public void testGTestIndependence3() throws Exception { |
| final long[] obs1 = new long[]{ |
| 190, 149 |
| }; |
| |
| final long[] obs2 = new long[]{ |
| 42, 49 |
| }; |
| |
| final double g = testStatistic.gDataSetsComparison(obs1, obs2); |
| Assert.assertEquals("G test statistic", |
| 2.8187, g, 1E-4); |
| final double p_gti = testStatistic.gTestDataSetsComparison(obs1, obs2); |
| Assert.assertEquals("g-Test p-value", 0.09317325, p_gti, 1E-6); |
| |
| Assert.assertFalse(testStatistic.gTestDataSetsComparison(obs1, obs2, 0.05)); |
| } |
| |
| @Test |
| public void testGTestSetsComparisonBadCounts() { |
| long[] observed1 = {10, -1, 12, 10, 15}; |
| long[] observed2 = {15, 10, 10, 15, 5}; |
| try { |
| testStatistic.gTestDataSetsComparison( |
| observed1, observed2); |
| Assert.fail("Expecting NotPositiveException - negative count"); |
| } catch (NotPositiveException ex) { |
| // expected |
| } |
| long[] observed3 = {10, 0, 12, 10, 15}; |
| long[] observed4 = {15, 0, 10, 15, 5}; |
| try { |
| testStatistic.gTestDataSetsComparison( |
| observed3, observed4); |
| Assert.fail("Expecting ZeroException - double 0's"); |
| } catch (ZeroException ex) { |
| // expected |
| } |
| long[] observed5 = {10, 10, 12, 10, 15}; |
| long[] observed6 = {0, 0, 0, 0, 0}; |
| try { |
| testStatistic.gTestDataSetsComparison( |
| observed5, observed6); |
| Assert.fail("Expecting ZeroException - vanishing counts"); |
| } catch (ZeroException ex) { |
| // expected |
| } |
| } |
| |
| @Test |
| public void testUnmatchedArrays() { |
| final long[] observed = { 0, 1, 2, 3 }; |
| final double[] expected = { 1, 1, 2 }; |
| final long[] observed2 = {3, 4}; |
| try { |
| testStatistic.gTest(expected, observed); |
| Assert.fail("arrays have different lengths, DimensionMismatchException expected"); |
| } catch (DimensionMismatchException ex) { |
| // expected |
| } |
| try { |
| testStatistic.gTestDataSetsComparison(observed, observed2); |
| Assert.fail("arrays have different lengths, DimensionMismatchException expected"); |
| } catch (DimensionMismatchException ex) { |
| // expected |
| } |
| } |
| |
| @Test |
| public void testNegativeObservedCounts() { |
| final long[] observed = { 0, 1, 2, -3 }; |
| final double[] expected = { 1, 1, 2, 3}; |
| final long[] observed2 = {3, 4, 5, 0}; |
| try { |
| testStatistic.gTest(expected, observed); |
| Assert.fail("negative observed count, NotPositiveException expected"); |
| } catch (NotPositiveException ex) { |
| // expected |
| } |
| try { |
| testStatistic.gTestDataSetsComparison(observed, observed2); |
| Assert.fail("negative observed count, NotPositiveException expected"); |
| } catch (NotPositiveException ex) { |
| // expected |
| } |
| } |
| |
| @Test |
| public void testZeroExpectedCounts() { |
| final long[] observed = { 0, 1, 2, -3 }; |
| final double[] expected = { 1, 0, 2, 3}; |
| try { |
| testStatistic.gTest(expected, observed); |
| Assert.fail("zero expected count, NotStrictlyPositiveException expected"); |
| } catch (NotStrictlyPositiveException ex) { |
| // expected |
| } |
| } |
| |
| @Test |
| public void testBadAlpha() { |
| final long[] observed = { 0, 1, 2, 3 }; |
| final double[] expected = { 1, 2, 2, 3}; |
| final long[] observed2 = { 0, 2, 2, 3 }; |
| try { |
| testStatistic.gTest(expected, observed, 0.8); |
| Assert.fail("zero expected count, NotStrictlyPositiveException expected"); |
| } catch (OutOfRangeException ex) { |
| // expected |
| } |
| try { |
| testStatistic.gTestDataSetsComparison(observed, observed2, -0.5); |
| Assert.fail("zero expected count, NotStrictlyPositiveException expected"); |
| } catch (OutOfRangeException ex) { |
| // expected |
| } |
| } |
| |
| @Test |
| public void testScaling() { |
| final long[] observed = {9, 11, 10, 8, 12}; |
| final double[] expected1 = {10, 10, 10, 10, 10}; |
| final double[] expected2 = {1000, 1000, 1000, 1000, 1000}; |
| final double[] expected3 = {1, 1, 1, 1, 1}; |
| final double tol = 1E-15; |
| Assert.assertEquals( |
| testStatistic.gTest(expected1, observed), |
| testStatistic.gTest(expected2, observed), |
| tol); |
| Assert.assertEquals( |
| testStatistic.gTest(expected1, observed), |
| testStatistic.gTest(expected3, observed), |
| tol); |
| } |
| |
| @Test |
| public void testRootLogLikelihood() { |
| // positive where k11 is bigger than expected. |
| Assert.assertTrue(testStatistic.rootLogLikelihoodRatio(904, 21060, 1144, 283012) > 0.0); |
| |
| // negative because k11 is lower than expected |
| Assert.assertTrue(testStatistic.rootLogLikelihoodRatio(36, 21928, 60280, 623876) < 0.0); |
| |
| Assert.assertEquals(AccurateMath.sqrt(2.772589), testStatistic.rootLogLikelihoodRatio(1, 0, 0, 1), 0.000001); |
| Assert.assertEquals(-AccurateMath.sqrt(2.772589), testStatistic.rootLogLikelihoodRatio(0, 1, 1, 0), 0.000001); |
| Assert.assertEquals(AccurateMath.sqrt(27.72589), testStatistic.rootLogLikelihoodRatio(10, 0, 0, 10), 0.00001); |
| |
| Assert.assertEquals(AccurateMath.sqrt(39.33052), testStatistic.rootLogLikelihoodRatio(5, 1995, 0, 100000), 0.00001); |
| Assert.assertEquals(-AccurateMath.sqrt(39.33052), testStatistic.rootLogLikelihoodRatio(0, 100000, 5, 1995), 0.00001); |
| |
| Assert.assertEquals(AccurateMath.sqrt(4730.737), testStatistic.rootLogLikelihoodRatio(1000, 1995, 1000, 100000), 0.001); |
| Assert.assertEquals(-AccurateMath.sqrt(4730.737), testStatistic.rootLogLikelihoodRatio(1000, 100000, 1000, 1995), 0.001); |
| |
| Assert.assertEquals(AccurateMath.sqrt(5734.343), testStatistic.rootLogLikelihoodRatio(1000, 1000, 1000, 100000), 0.001); |
| Assert.assertEquals(AccurateMath.sqrt(5714.932), testStatistic.rootLogLikelihoodRatio(1000, 1000, 1000, 99000), 0.001); |
| } |
| } |