final TimeSeriesGenerator generator = TimeSeries.nonHomogenousPoisson( lengthOfScenario, intensity);
/** * Test whether the number of events filter works. */ @Test public void testFilter() { final TimeSeriesGenerator original = homogenousPoisson(500, 20); final TimeSeriesGenerator filtered = filter(original, numEventsPredicate(20)); final RandomGenerator rng = new MersenneTwister(123L); for (int i = 0; i < 10; i++) { assertEquals(20, filtered.generate(rng.nextLong()).size()); } } }
/** * Creates a {@link TimeSeriesGenerator} that uses a truncated normal * distribution for the inter arrival times of events. The normal distribution * is truncated at a lower bound of <code>0</code> since it is not allowed (it * makes no sense) to have negative inter arrival times. For more information * about the normal distribution see {@link StochasticSuppliers#normal()}. * @param length The length of the time series, all generated times will be in * the interval [0,length). * @param numEvents The total number of events in the time series (on * average). * @param sd The standard deviation of the normal distribution. * @return A {@link TimeSeriesGenerator} based on a normal distribution. */ public static TimeSeriesGenerator normal(double length, int numEvents, double sd) { checkArgument(length > 0d); checkArgument(numEvents > 0); final double average = length / numEvents; return toTimeSeries(length, StochasticSuppliers.normal() .mean(average) .std(sd) .lowerBound(0d) .redrawWhenOutOfBounds() .scaleMean() .buildDouble()); }
/** * @return Test configs */ @Parameters public static Collection<Object[]> data() { return Arrays.asList(new Object[][] { {TimeSeries.homogenousPoisson(60d, 10)}, {TimeSeries.homogenousPoisson(60d, 100)}, {TimeSeries.homogenousPoisson(180d, 10)}, {TimeSeries.homogenousPoisson(180d, 100)}, {TimeSeries.nonHomogenousPoisson(60d, IntensityFunctions .sineIntensity() .period(60).area(10).build())}, {TimeSeries.nonHomogenousPoisson(60d, IntensityFunctions .sineIntensity() .period(60).area(10).phaseShift(2).build())}, {TimeSeries.nonHomogenousPoisson(60d, IntensityFunctions .sineIntensity() .period(60).area(10).height(1).build())}, {TimeSeries.nonHomogenousPoisson(300d, IntensityFunctions .sineIntensity() .period(60).area(10).height(1).build())}, {TimeSeries.nonHomogenousPoisson(600d, IntensityFunctions .sineIntensity() .period(600).area(200).height(1).build())} }); }
/** * Tests whether times which are outside the interval [0,length) are correctly * rejected. */ @Test(expected = IllegalArgumentException.class) public void timesFail() { final int scenarioLength = 10; final ParcelGenerator pg2 = Parcels .builder() .announceTimes( TimeSeries.homogenousPoisson(scenarioLength + 0.1, 100)) .build(); pg2.generate(123, TravelTimesUtil.distance(), scenarioLength); }
/** * Tests whether all generated times are in the interval [0,length). */ @Test public void timesTest() { final int scenarioLength = 10; final ParcelGenerator pg = Parcels.builder() .announceTimes(TimeSeries.homogenousPoisson(scenarioLength, 100)) .build(); final List<AddParcelEvent> events = pg.generate(123, TravelTimesUtil.distance(), scenarioLength); for (final AddParcelEvent ape : events) { assertTrue(ape.getTime() < scenarioLength); } TestUtil.testPrivateConstructor(Parcels.class); }
/** * Tests whether the Poisson process (crudely) approximates the intensity * function when a large number of runs is done. */ @Test public void intensityApproximationPoissonProcessTest() { final RandomGenerator rng = new MersenneTwister(123); final TimeSeriesGenerator pp = TimeSeries.nonHomogenousPoisson(100d, intensityFunction); final Multiset<Double> ms = TreeMultiset.create(); final int repetitions = 10000; for (int i = 0; i < repetitions; i++) { final List<Double> times = pp.generate(rng.nextLong()); for (final Double d : times) { ms.add(new Double(Math.ceil(d))); } } for (final Multiset.Entry<Double> entry : ms.entrySet()) { final double exp = IntensityFunctions.areaByIntegration( intensityFunction, entry.getElement() - 1d, entry.getElement()); final double observation = entry.getCount() / (double) repetitions; assertEquals(exp, observation, 0.05); } } }
.builder() .announceTimes( TimeSeries.homogenousPoisson(4 * 60 * 60 * 1000L, 10)) .locations(Locations.builder().square(5).buildUniform()) .timeWindows(TimeWindows.builder().build())
.parcels(Parcels.builder() .announceTimes( TimeSeries.nonHomogenousPoisson(scenarioLengthMs - 30 * 60 * 1000L, IntensityFunctions.sineIntensity() .period(30 * 60 * 1000L)
/** * Check whether the * {@link TimeSeries#nonHomogenousPoisson(double, StochasticSupplier)} * function behaves as expected. */ @Test public void test2() { final IntensityFunction func1 = IntensityFunctions.sineIntensity() .period(60) .height(-.5) .build(); final IntensityFunction func2 = IntensityFunctions.sineIntensity() .period(30) .height(1.5) .build(); final StochasticSupplier<IntensityFunction> funcSup = StochasticSuppliers .fromIterable(Iterables.cycle(func1, func2)); final TimeSeriesGenerator tsg = TimeSeries.nonHomogenousPoisson(120, funcSup); // note that these tests will not work for all results of the // TimeSeriesGenerator, it is possible (but less likely) that the produced // dynamism values are different from the expectations as expressed in the // tests below. for (int i = 0; i < 20; i++) { assertTrue(Metrics.measureDynamism(tsg.generate(i), 120) < .25); assertTrue(Metrics.measureDynamism(tsg.generate(i), 120) > .40); } }