@Test public void testNextGamma() { double[] quartiles; long[] counts; // Tests shape > 1, one case in the rejection sampling quartiles = TestUtils.getDistributionQuartiles(new GammaDistribution(4, 2)); counts = new long[4]; randomData.reSeed(1000); for (int i = 0; i < 1000; i++) { double value = randomData.nextGamma(4, 2); TestUtils.updateCounts(value, counts, quartiles); } TestUtils.assertChiSquareAccept(expected, counts, 0.001); // Tests shape <= 1, another case in the rejection sampling quartiles = TestUtils.getDistributionQuartiles(new GammaDistribution(0.3, 3)); counts = new long[4]; randomData.reSeed(1000); for (int i = 0; i < 1000; i++) { double value = randomData.nextGamma(0.3, 3); TestUtils.updateCounts(value, counts, quartiles); } TestUtils.assertChiSquareAccept(expected, counts, 0.001); }
@Test public void testNextZipf() { ZipfDistributionTest testInstance = new ZipfDistributionTest(); int[] densityPoints = testInstance.makeDensityTestPoints(); double[] densityValues = testInstance.makeDensityTestValues(); int sampleSize = 1000; int length = TestUtils.eliminateZeroMassPoints(densityPoints, densityValues); ZipfDistribution distribution = (ZipfDistribution) testInstance.makeDistribution(); double[] expectedCounts = new double[length]; long[] observedCounts = new long[length]; for (int i = 0; i < length; i++) { expectedCounts[i] = sampleSize * densityValues[i]; } randomData.reSeed(1000); for (int i = 0; i < sampleSize; i++) { int value = randomData.nextZipf(distribution.getNumberOfElements(), distribution.getExponent()); for (int j = 0; j < length; j++) { if (value == densityPoints[j]) { observedCounts[j]++; } } } TestUtils.assertChiSquareAccept(densityPoints, expectedCounts, observedCounts, .001); }
@Test public void testNextUniformIAE() { try { randomData.nextUniform(4, 3); Assert.fail("MathIllegalArgumentException expected"); } catch (MathIllegalArgumentException ex) { // ignored } try { randomData.nextUniform(0, Double.POSITIVE_INFINITY); Assert.fail("MathIllegalArgumentException expected"); } catch (MathIllegalArgumentException ex) { // ignored } try { randomData.nextUniform(Double.NEGATIVE_INFINITY, 0); Assert.fail("MathIllegalArgumentException expected"); } catch (MathIllegalArgumentException ex) { // ignored } try { randomData.nextUniform(0, Double.NaN); Assert.fail("MathIllegalArgumentException expected"); } catch (MathIllegalArgumentException ex) { // ignored } try { randomData.nextUniform(Double.NaN, 0); Assert.fail("MathIllegalArgumentException expected"); } catch (MathIllegalArgumentException ex) { // ignored } }
@Test public void testNextWeibull() { double[] quartiles = TestUtils.getDistributionQuartiles(new WeibullDistribution(1.2, 2.1)); long[] counts = new long[4]; randomData.reSeed(1000); for (int i = 0; i < 1000; i++) { double value = randomData.nextWeibull(1.2, 2.1); TestUtils.updateCounts(value, counts, quartiles); } TestUtils.assertChiSquareAccept(expected, counts, 0.001); }
@Setup public void generateData() { src = new double[arraySize]; final RandomDataGenerator gen = new RandomDataGenerator(); for (int i = 0; i < src.length; i++) { if (i < src.length / 3) { src[i] = gen.nextUniform(0, 1); } else { src[i] = gen.nextGamma(42., 42.); } } }
private void checkNextUniformUniform(double min, double max) { // Set up bin bounds - min, binBound[0], ..., binBound[binCount-2], max final int binCount = 5; final double binSize = max / binCount - min / binCount; // Prevent overflow in extreme value case final double[] binBounds = new double[binCount - 1]; binBounds[0] = min + binSize; for (int i = 1; i < binCount - 1; i++) { binBounds[i] = binBounds[i - 1] + binSize; // + instead of * to avoid overflow in extreme case } final Frequency freq = new Frequency(); for (int i = 0; i < smallSampleSize; i++) { final double value = randomData.nextUniform(min, max); Assert.assertTrue("nextUniform range", (value > min) && (value < max)); // Find bin int j = 0; while (j < binCount - 1 && value > binBounds[j]) { j++; } freq.addValue(j); } final long[] observed = new long[binCount]; for (int i = 0; i < binCount; i++) { observed[i] = freq.getCount(i); } final double[] expected = new double[binCount]; for (int i = 0; i < binCount; i++) { expected[i] = 1d / binCount; } TestUtils.assertChiSquareAccept(expected, observed, 0.01); }
@Test public void testNextPoissonConsistency() { // Small integral means for (int i = 1; i < 100; i++) { checkNextPoissonConsistency(i); } // non-integer means for (int i = 1; i < 10; i++) { checkNextPoissonConsistency(randomData.nextUniform(1, 1000)); } // large means for (int i = 1; i < 10; i++) { checkNextPoissonConsistency(randomData.nextUniform(1000, 10000)); } }
/** test exclusive endpoints of nextUniform * */ @Test public void testNextUniformExclusiveEndpoints() { for (int i = 0; i < 1000; i++) { double u = randomData.nextUniform(0.99, 1); Assert.assertTrue(u > 0.99 && u < 1); } }
/** test failure modes and distribution of nextGaussian() */ @Test public void testNextGaussian() { try { randomData.nextGaussian(0, 0); Assert.fail("zero sigma -- MathIllegalArgumentException expected"); } catch (MathIllegalArgumentException ex) { // ignored } double[] quartiles = TestUtils.getDistributionQuartiles(new NormalDistribution(0, 1)); long[] counts = new long[4]; randomData.reSeed(1000); for (int i = 0; i < 1000; i++) { double value = randomData.nextGaussian(0, 1); TestUtils.updateCounts(value, counts, quartiles); } TestUtils.assertChiSquareAccept(expected, counts, 0.001); }
/** tests for nextPermutation */ @Test public void testNextPermutation() { int[][] p = {{0, 1, 2}, {0, 2, 1}, {1, 0, 2}, {1, 2, 0}, {2, 0, 1}, {2, 1, 0}}; long[] observed = {0, 0, 0, 0, 0, 0}; double[] expected = {100, 100, 100, 100, 100, 100}; for (int i = 0; i < 600; i++) { int[] perm = randomData.nextPermutation(3, 3); observed[findPerm(p, perm)]++; } String[] labels = { "{0, 1, 2}", "{ 0, 2, 1 }", "{ 1, 0, 2 }", "{ 1, 2, 0 }", "{ 2, 0, 1 }", "{ 2, 1, 0 }" }; TestUtils.assertChiSquareAccept(labels, expected, observed, 0.001); // Check size = 1 boundary case int[] perm = randomData.nextPermutation(1, 1); if ((perm.length != 1) || (perm[0] != 0)) { Assert.fail("bad permutation for n = 1, sample k = 1"); // Make sure we fail for k size > n try { perm = randomData.nextPermutation(2, 3); Assert.fail("permutation k > n, expecting MathIllegalArgumentException"); } catch (MathIllegalArgumentException ex) { // ignored } // Make sure we fail for n = 0 try { perm = randomData.nextPermutation(0, 0); Assert.fail("permutation k = n = 0, expecting MathIllegalArgumentException"); } catch (MathIllegalArgumentException ex) { // ignored } // Make sure we fail for k < n < 0 try { perm = randomData.nextPermutation(-1, -3); Assert.fail("permutation k < n < 0, expecting MathIllegalArgumentException"); } catch (MathIllegalArgumentException ex) { // ignored } } }
@Test public void testNextIntIAE() { try { randomData.nextInt(4, 3); Assert.fail("MathIllegalArgumentException expected"); } catch (MathIllegalArgumentException ex) { // ignored } }
@Test public void testNextUniformExtremeValues() { double x = randomData.nextUniform(-Double.MAX_VALUE, Double.MAX_VALUE); double y = randomData.nextUniform(-Double.MAX_VALUE, Double.MAX_VALUE); Assert.assertFalse(x == y); Assert.assertFalse(Double.isNaN(x)); Assert.assertFalse(Double.isNaN(y)); Assert.assertFalse(Double.isInfinite(x)); Assert.assertFalse(Double.isInfinite(y)); }
/** * Make sure that empirical distribution of random Poisson(4)'s has P(X <= 5) close to actual * cumulative Poisson probability and that nextPoisson fails when mean is non-positive. */ @Test public void testNextPoisson() { try { randomData.nextPoisson(0); Assert.fail("zero mean -- expecting MathIllegalArgumentException"); } catch (MathIllegalArgumentException ex) { // ignored } try { randomData.nextPoisson(-1); Assert.fail("negative mean supplied -- MathIllegalArgumentException expected"); } catch (MathIllegalArgumentException ex) { // ignored } try { randomData.nextPoisson(0); Assert.fail("0 mean supplied -- MathIllegalArgumentException expected"); } catch (MathIllegalArgumentException ex) { // ignored } final double mean = 4.0d; final int len = 5; PoissonDistribution poissonDistribution = new PoissonDistribution(mean); Frequency f = new Frequency(); randomData.reSeed(1000); for (int i = 0; i < largeSampleSize; i++) { f.addValue(randomData.nextPoisson(mean)); } final long[] observed = new long[len]; for (int i = 0; i < len; i++) { observed[i] = f.getCount(i + 1); } final double[] expected = new double[len]; for (int i = 0; i < len; i++) { expected[i] = poissonDistribution.probability(i + 1) * largeSampleSize; } TestUtils.assertChiSquareAccept(expected, observed, 0.0001); }
@Test public void testNextInversionDeviate() { // Set the seed for the default random generator RandomGenerator rg = new Well19937c(100); RandomDataGenerator rdg = new RandomDataGenerator(rg); double[] quantiles = new double[10]; for (int i = 0; i < 10; i++) { quantiles[i] = rdg.nextUniform(0, 1); } // Reseed again so the inversion generator gets the same sequence rg.setSeed(100); BetaDistribution betaDistribution = new BetaDistribution(rg, 2, 4, BetaDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY); /* * Generate a sequence of deviates using inversion - the distribution function * evaluated at the random value from the distribution should match the uniform * random value used to generate it, which is stored in the quantiles[] array. */ for (int i = 0; i < 10; i++) { double value = betaDistribution.sample(); Assert.assertEquals(betaDistribution.cumulativeProbability(value), quantiles[i], 10E-9); } }
@Test public void testNextIntWideRange() { int lower = -0x6543210F; int upper = 0x456789AB; int max = Integer.MIN_VALUE; int min = Integer.MAX_VALUE; for (int i = 0; i < 1000000; ++i) { int r = randomData.nextInt(lower, upper); max = FastMath.max(max, r); min = FastMath.min(min, r); Assert.assertTrue(r >= lower); Assert.assertTrue(r <= upper); } double ratio = (((double) max) - ((double) min)) / (((double) upper) - ((double) lower)); Assert.assertTrue(ratio > 0.99999); }
@Test public void testNextLongWideRange() { long lower = -0x6543210FEDCBA987L; long upper = 0x456789ABCDEF0123L; long max = Long.MIN_VALUE; long min = Long.MAX_VALUE; for (int i = 0; i < 10000000; ++i) { long r = randomData.nextLong(lower, upper); max = FastMath.max(max, r); min = FastMath.min(min, r); Assert.assertTrue(r >= lower); Assert.assertTrue(r <= upper); } double ratio = (((double) max) - ((double) min)) / (((double) upper) - ((double) lower)); Assert.assertTrue(ratio > 0.99999); }
public long generateTime() { TimeUnit tu = SimulationUtils.getTimeUnit(data); long mean = (long) SimulationUtils.asDouble(data.get(SimulationConstants.MEAN)); mean = timeUnit.convert(mean, tu); long sdv = (long) SimulationUtils.asDouble(data.get(SimulationConstants.STANDARD_DEVIATION)); sdv = timeUnit.convert(sdv, tu); if (sdv > 0) { long value = (long) generator.nextGaussian(mean, sdv); if (value <= 0) { value = mean; } return value; } else { return 0; } }
private void checkNextSecureIntUniform(int min, int max) { final Frequency freq = new Frequency(); for (int i = 0; i < smallSampleSize; i++) { final int value = randomData.nextSecureInt(min, max); Assert.assertTrue("nextInt range", (value >= min) && (value <= max)); freq.addValue(value); } final int len = max - min + 1; final long[] observed = new long[len]; for (int i = 0; i < len; i++) { observed[i] = freq.getCount(min + i); } final double[] expected = new double[len]; for (int i = 0; i < len; i++) { expected[i] = 1d / len; } TestUtils.assertChiSquareAccept(expected, observed, 0.0001); }
private void checkNextLongUniform(long min, long max) { final Frequency freq = new Frequency(); for (int i = 0; i < smallSampleSize; i++) { final long value = randomData.nextLong(min, max); Assert.assertTrue( "nextLong range: " + value + " " + min + " " + max, (value >= min) && (value <= max)); freq.addValue(value); } final int len = ((int) (max - min)) + 1; final long[] observed = new long[len]; for (int i = 0; i < len; i++) { observed[i] = freq.getCount(min + i); } final double[] expected = new double[len]; for (int i = 0; i < len; i++) { expected[i] = 1d / len; } TestUtils.assertChiSquareAccept(expected, observed, 0.01); }
/** test dispersion and failure modes for nextHex() */ @Test @Retry(3) public void testNextSecureHex() { try { randomData.nextSecureHexString(-1); Assert.fail("negative length -- MathIllegalArgumentException expected"); } catch (MathIllegalArgumentException ex) { // ignored } try { randomData.nextSecureHexString(0); Assert.fail("zero length -- MathIllegalArgumentException expected"); } catch (MathIllegalArgumentException ex) { // ignored } String hexString = randomData.nextSecureHexString(3); if (hexString.length() != 3) { Assert.fail("incorrect length for generated string"); } hexString = randomData.nextSecureHexString(1); if (hexString.length() != 1) { Assert.fail("incorrect length for generated string"); } try { hexString = randomData.nextSecureHexString(0); Assert.fail("zero length requested -- expecting MathIllegalArgumentException"); } catch (MathIllegalArgumentException ex) { // ignored } Frequency f = new Frequency(); for (int i = 0; i < smallSampleSize; i++) { hexString = randomData.nextSecureHexString(100); if (hexString.length() != 100) { Assert.fail("incorrect length for generated string"); } for (int j = 0; j < hexString.length(); j++) { f.addValue(hexString.substring(j, j + 1)); } } double[] expected = new double[16]; long[] observed = new long[16]; for (int i = 0; i < 16; i++) { expected[i] = (double) smallSampleSize * 100 / 16; observed[i] = f.getCount(hex[i]); } TestUtils.assertChiSquareAccept(expected, observed, 0.001); }
public static void main(String[] args) { // int d_total = 10000; int p_numbers = 3; // Partition Numbers int p_size = 5; int z_exponent = 1; int d = 0; int d_start = 0; int d_end = p_size; double mu = 0.0; double sigma = 1.0; double z, c, c_rand, n; ZipfDistribution zipf; // Parameters = Number of Elements, Exponent RandomDataGenerator randData = new RandomDataGenerator(); RandomDataGenerator rand = new RandomDataGenerator(); rand.reSeed(0); for (int p = 0; p < p_numbers; p++) { zipf = new ZipfDistribution(p_size, z_exponent); zipf.reseedRandomGenerator(p); randData.reSeed(p); for (d = d_start; d < d_end; d++) { z = randData.nextZipf(p_size, z_exponent); z += d_start; if (z > d_end) z -= 1; c = zipf.cumulativeProbability((d - d_start)); c_rand = zipf.cumulativeProbability(((int) z - d_start)); // n = rand.nextGaussian(mu, sigma); n = rand.nextUniform(0.0, 1.0); System.out.println(p + " " + d + " " + c + " " + (int) z + " " + c_rand + " " + n); } d_start = d_end; d_end = (d + p_size); } }
/** test failure modes and distribution of nextExponential() */ @Test public void testNextExponential() { try { randomData.nextExponential(-1); Assert.fail("negative mean -- expecting MathIllegalArgumentException"); } catch (MathIllegalArgumentException ex) { // ignored } try { randomData.nextExponential(0); Assert.fail("zero mean -- expecting MathIllegalArgumentException"); } catch (MathIllegalArgumentException ex) { // ignored } double[] quartiles; long[] counts; // Mean 1 quartiles = TestUtils.getDistributionQuartiles(new ExponentialDistribution(1)); counts = new long[4]; randomData.reSeed(1000); for (int i = 0; i < 1000; i++) { double value = randomData.nextExponential(1); TestUtils.updateCounts(value, counts, quartiles); } TestUtils.assertChiSquareAccept(expected, counts, 0.001); // Mean 5 quartiles = TestUtils.getDistributionQuartiles(new ExponentialDistribution(5)); counts = new long[4]; randomData.reSeed(1000); for (int i = 0; i < 1000; i++) { double value = randomData.nextExponential(5); TestUtils.updateCounts(value, counts, quartiles); } TestUtils.assertChiSquareAccept(expected, counts, 0.001); }
@Override public CADensity createRandomIndividual(RandomDataGenerator random) { double density = random.nextUniform(lower, upper); return new CADensity(density, testLength); }
/** tests for nextSample() sampling from Collection */ @Test public void testNextSample() { Object[][] c = { {"0", "1"}, {"0", "2"}, {"0", "3"}, {"0", "4"}, {"1", "2"}, {"1", "3"}, {"1", "4"}, {"2", "3"}, {"2", "4"}, {"3", "4"} }; long[] observed = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; double[] expected = {100, 100, 100, 100, 100, 100, 100, 100, 100, 100}; HashSet<Object> cPop = new HashSet<Object>(); // {0,1,2,3,4} for (int i = 0; i < 5; i++) { cPop.add(Integer.toString(i)); } Object[] sets = new Object[10]; // 2-sets from 5 for (int i = 0; i < 10; i++) { HashSet<Object> hs = new HashSet<Object>(); hs.add(c[i][0]); hs.add(c[i][1]); sets[i] = hs; } for (int i = 0; i < 1000; i++) { Object[] cSamp = randomData.nextSample(cPop, 2); observed[findSample(sets, cSamp)]++; } /* * Use ChiSquare dist with df = 10-1 = 9, alpha = .001 Change to 21.67 * for alpha = .01 */ Assert.assertTrue( "chi-square test -- will fail about 1 in 1000 times", testStatistic.chiSquare(expected, observed) < 27.88); // Make sure sample of size = size of collection returns same collection HashSet<Object> hs = new HashSet<Object>(); hs.add("one"); Object[] one = randomData.nextSample(hs, 1); String oneString = (String) one[0]; if ((one.length != 1) || !oneString.equals("one")) { Assert.fail("bad sample for set size = 1, sample size = 1"); } // Make sure we fail for sample size > collection size try { one = randomData.nextSample(hs, 2); Assert.fail("sample size > set size, expecting MathIllegalArgumentException"); } catch (MathIllegalArgumentException ex) { // ignored } // Make sure we fail for empty collection try { hs = new HashSet<Object>(); one = randomData.nextSample(hs, 0); Assert.fail("n = k = 0, expecting MathIllegalArgumentException"); } catch (MathIllegalArgumentException ex) { // ignored } }
/** test reseeding, algorithm/provider games */ @Test public void testConfig() { randomData.reSeed(1000); double v = randomData.nextUniform(0, 1); randomData.reSeed(); Assert.assertTrue("different seeds", Math.abs(v - randomData.nextUniform(0, 1)) > 10E-12); randomData.reSeed(1000); Assert.assertEquals("same seeds", v, randomData.nextUniform(0, 1), 10E-12); randomData.reSeedSecure(1000); String hex = randomData.nextSecureHexString(40); randomData.reSeedSecure(); Assert.assertTrue("different seeds", !hex.equals(randomData.nextSecureHexString(40))); randomData.reSeedSecure(1000); Assert.assertTrue("same seeds", !hex.equals(randomData.nextSecureHexString(40))); /* * remove this test back soon, since it takes about 4 seconds * * try { randomData.setSecureAlgorithm("SHA1PRNG","SUN"); } catch * (NoSuchProviderException ex) { ; } Assert.assertTrue("different seeds", * !hex.equals(randomData.nextSecureHexString(40))); try { * randomData.setSecureAlgorithm("NOSUCHTHING","SUN"); * Assert.fail("expecting NoSuchAlgorithmException"); } catch * (NoSuchProviderException ex) { ; } catch (NoSuchAlgorithmException * ex) { ; } * * try { randomData.setSecureAlgorithm("SHA1PRNG","NOSUCHPROVIDER"); * Assert.fail("expecting NoSuchProviderException"); } catch * (NoSuchProviderException ex) { ; } */ // test reseeding without first using the generators RandomDataGenerator rd = new RandomDataGenerator(); rd.reSeed(100); rd.nextLong(1, 2); RandomDataGenerator rd2 = new RandomDataGenerator(); rd2.reSeedSecure(2000); rd2.nextSecureLong(1, 2); rd = new RandomDataGenerator(); rd.reSeed(); rd.nextLong(1, 2); rd2 = new RandomDataGenerator(); rd2.reSeedSecure(); rd2.nextSecureLong(1, 2); }
@Test public void testNextLongExtremeValues() { long x = randomData.nextLong(Long.MIN_VALUE, Long.MAX_VALUE); long y = randomData.nextLong(Long.MIN_VALUE, Long.MAX_VALUE); Assert.assertFalse(x == y); }
/** * Verifies that nextPoisson(mean) generates an empirical distribution of values consistent with * PoissonDistributionImpl by generating 1000 values, computing a grouped frequency distribution * of the observed values and comparing this distribution to the corresponding expected * distribution computed using PoissonDistributionImpl. Uses ChiSquare test of goodness of fit to * evaluate the null hypothesis that the distributions are the same. If the null hypothesis can be * rejected with confidence 1 - alpha, the check fails. */ public void checkNextPoissonConsistency(double mean) { // Generate sample values final int sampleSize = 1000; // Number of deviates to generate final int minExpectedCount = 7; // Minimum size of expected bin count long maxObservedValue = 0; final double alpha = 0.001; // Probability of false failure Frequency frequency = new Frequency(); for (int i = 0; i < sampleSize; i++) { long value = randomData.nextPoisson(mean); if (value > maxObservedValue) { maxObservedValue = value; } frequency.addValue(value); } /* * Set up bins for chi-square test. * Ensure expected counts are all at least minExpectedCount. * Start with upper and lower tail bins. * Lower bin = [0, lower); Upper bin = [upper, +inf). */ PoissonDistribution poissonDistribution = new PoissonDistribution(mean); int lower = 1; while (poissonDistribution.cumulativeProbability(lower - 1) * sampleSize < minExpectedCount) { lower++; } int upper = (int) (5 * mean); // Even for mean = 1, not much mass beyond 5 while ((1 - poissonDistribution.cumulativeProbability(upper - 1)) * sampleSize < minExpectedCount) { upper--; } // Set bin width for interior bins. For poisson, only need to look at end bins. int binWidth = 0; boolean widthSufficient = false; double lowerBinMass = 0; double upperBinMass = 0; while (!widthSufficient) { binWidth++; lowerBinMass = poissonDistribution.cumulativeProbability(lower - 1, lower + binWidth - 1); upperBinMass = poissonDistribution.cumulativeProbability(upper - binWidth - 1, upper - 1); widthSufficient = FastMath.min(lowerBinMass, upperBinMass) * sampleSize >= minExpectedCount; } /* * Determine interior bin bounds. Bins are * [1, lower = binBounds[0]), [lower, binBounds[1]), [binBounds[1], binBounds[2]), ... , * [binBounds[binCount - 2], upper = binBounds[binCount - 1]), [upper, +inf) * */ List<Integer> binBounds = new ArrayList<Integer>(); binBounds.add(lower); int bound = lower + binWidth; while (bound < upper - binWidth) { binBounds.add(bound); bound += binWidth; } binBounds.add( upper); // The size of bin [binBounds[binCount - 2], upper) satisfies binWidth <= size < // 2*binWidth. // Compute observed and expected bin counts final int binCount = binBounds.size() + 1; long[] observed = new long[binCount]; double[] expected = new double[binCount]; // Bottom bin observed[0] = 0; for (int i = 0; i < lower; i++) { observed[0] += frequency.getCount(i); } expected[0] = poissonDistribution.cumulativeProbability(lower - 1) * sampleSize; // Top bin observed[binCount - 1] = 0; for (int i = upper; i <= maxObservedValue; i++) { observed[binCount - 1] += frequency.getCount(i); } expected[binCount - 1] = (1 - poissonDistribution.cumulativeProbability(upper - 1)) * sampleSize; // Interior bins for (int i = 1; i < binCount - 1; i++) { observed[i] = 0; for (int j = binBounds.get(i - 1); j < binBounds.get(i); j++) { observed[i] += frequency.getCount(j); } // Expected count is (mass in [binBounds[i-1], binBounds[i])) * sampleSize expected[i] = (poissonDistribution.cumulativeProbability(binBounds.get(i) - 1) - poissonDistribution.cumulativeProbability(binBounds.get(i - 1) - 1)) * sampleSize; } // Use chisquare test to verify that generated values are poisson(mean)-distributed ChiSquareTest chiSquareTest = new ChiSquareTest(); // Fail if we can reject null hypothesis that distributions are the same if (chiSquareTest.chiSquareTest(expected, observed, alpha)) { StringBuilder msgBuffer = new StringBuilder(); DecimalFormat df = new DecimalFormat("#.##"); msgBuffer.append("Chisquare test failed for mean = "); msgBuffer.append(mean); msgBuffer.append(" p-value = "); msgBuffer.append(chiSquareTest.chiSquareTest(expected, observed)); msgBuffer.append(" chisquare statistic = "); msgBuffer.append(chiSquareTest.chiSquare(expected, observed)); msgBuffer.append(". \n"); msgBuffer.append("bin\t\texpected\tobserved\n"); for (int i = 0; i < expected.length; i++) { msgBuffer.append("["); msgBuffer.append(i == 0 ? 1 : binBounds.get(i - 1)); msgBuffer.append(","); msgBuffer.append(i == binBounds.size() ? "inf" : binBounds.get(i)); msgBuffer.append(")"); msgBuffer.append("\t\t"); msgBuffer.append(df.format(expected[i])); msgBuffer.append("\t\t"); msgBuffer.append(observed[i]); msgBuffer.append("\n"); } msgBuffer.append("This test can fail randomly due to sampling error with probability "); msgBuffer.append(alpha); msgBuffer.append("."); Assert.fail(msgBuffer.toString()); } }
@Test public void testNextIntExtremeValues() { int x = randomData.nextInt(Integer.MIN_VALUE, Integer.MAX_VALUE); int y = randomData.nextInt(Integer.MIN_VALUE, Integer.MAX_VALUE); Assert.assertFalse(x == y); }
public void testClustering() { final int numberOfTimeSeriesPerClass = 100; final int timeSeriesLength = 1500; final int sample_size = (9 * numberOfTimeSeriesPerClass) / 2; final int numberOfResamples = 100; final int maxIterations = 1000; final int numberOfInitializations = 100; // ------------------------------------ // compute DRQA measures // ------------------------------------ TimeSeriesGenerator timeSeriesGenerator = new TimeSeriesGenerator(numberOfTimeSeriesPerClass, timeSeriesLength, null); ArrayList<DoublePoint> rqa_measures = new ArrayList<DoublePoint>(9 * numberOfTimeSeriesPerClass); System.out.println("Computing DRQA measures"); double[][][][] trajectories = timeSeriesGenerator.getAllTrajectories(); for (int system_idx = 0; system_idx < trajectories.length; system_idx++) { System.out.println(String.format("System: %s", TimeSeriesGenerator.system_names[system_idx])); double[][][] trajectory1 = trajectories[system_idx]; for (double[][] trajectory : trajectory1) { DRQA drqa = new DRQA(trajectory, trajectory, 0.05); drqa.computeRQA(2, 2, 2); // rqa_measures[system_idx * numberOfTimeSeriesPerClass + i] = new // DoublePoint(drqa.allRQAMeasures(DRQA.HistogramStatistic.values())); rqa_measures.add(new DoublePoint(drqa.standardRQAMeasures())); } } System.out.println( String.format( "Standard RQA of first point:\n%s", Arrays.toString(rqa_measures.get(0).getPoint()))); // ------------------------------------ // Cluster // ------------------------------------ long before = System.currentTimeMillis(); RandomDataGenerator randomDataGenerator = new RandomDataGenerator(); final EuclideanDistance euclideanDistance = new EuclideanDistance(); ClusterEvaluator<DoublePoint> evaluator = new SumOfClusterVariances<DoublePoint>(euclideanDistance); ArrayList<DoublePoint> sample = new ArrayList<DoublePoint>(sample_size); System.out.println(String.format("sample_size: %s", sample_size)); // generate random subsamples of the data set for (int resample_idx = 0; resample_idx < numberOfResamples; resample_idx++) { System.out.println(String.format("Resample: %s", resample_idx + 1)); // generate random sample of half size Object[] randomSample = randomDataGenerator.nextSample(rqa_measures, sample_size); sample.clear(); for (Object point : randomSample) sample.add((DoublePoint) point); int bestK = 0; double bestScore = Double.POSITIVE_INFINITY; // cluster using different numbers of clusters for (int k = 2; k < 17; k++) { // seed the algorithm several times to have a better chance to escape local maxima // this can also be done using // org.apache.commons.math3.ml.clustering.MultiKMeansPlusPlusClusterer, // but it doesn't return the actual scores, which is important in determining the number of // clusters. double bestInitScore = Double.POSITIVE_INFINITY; for (int init_num = 0; init_num < numberOfInitializations; init_num++) { KMeansPlusPlusClusterer<DoublePoint> clusterer = new KMeansPlusPlusClusterer<DoublePoint>( k, maxIterations, euclideanDistance, new ISAACRandom(init_num)); List<CentroidCluster<DoublePoint>> result = clusterer.cluster(sample); final double score = evaluator.score(result); bestInitScore = Math.min(bestInitScore, score); } // for initializations if (bestInitScore < bestScore) { bestScore = bestInitScore; bestK = k; } // for(CentroidCluster<DoublePoint> cc : result) // System.out.println(Arrays.toString(cc.getCenter().getPoint())); } // for number of clusters System.out.println(String.format("Best k=%s, score=%s", bestK, bestScore)); } // for resampling System.out.println( String.format("Time for clustering: %s", System.currentTimeMillis() - before)); }