@Override public boolean test(final EvolutionResult<G, ?> result) { final ISeq<DoubleMoments> stat = statistics(result.getPopulation()); return result.getTotalGenerations() <= 1 || stat.stream() .filter(_convergence) .count() <= _convergenceRate*stat.size(); }
protected double[] fitness(final P param) { final Predicate<? super EvolutionResult<G, N>> terminator = _terminator.apply(param); final long start = System.currentTimeMillis(); final EvolutionResult<G, N> result = _engine.apply(param).stream() .limit(terminator) .collect(EvolutionResult.toBestEvolutionResult()); final long end = System.currentTimeMillis(); return new double[] { result.getTotalGenerations(), result.getBestFitness() != null ? result.getBestFitness().doubleValue() : Double.NEGATIVE_INFINITY, end - start }; }
@Override public boolean test(final EvolutionResult<?, N> result) { final DoubleMomentStatistics fitness = new DoubleMomentStatistics(); result.getPopulation() .forEach(p -> fitness.accept(p.getFitness().doubleValue())); return result.getTotalGenerations() <= 1 || _proceed.test( result.getBestFitness() != null ? result.getBestFitness().doubleValue() : Double.NaN, DoubleMoments.of(fitness) ); }
@Test public void cycle1() { final EvolutionStreamable<DoubleGene, Double> engine = CyclicEngine.of( _engine1.limit(10), _engine2.limit(10), _engine3.limit(10) ); final AtomicLong count = new AtomicLong(0); final EvolutionResult<DoubleGene, Double> result = engine.stream() .limit(100) .peek(r -> count.incrementAndGet()) .collect(EvolutionResult.toBestEvolutionResult()); Assert.assertEquals(count.intValue(), 100); Assert.assertEquals(result.getTotalGenerations(), 100); }
EvolutionResult<G, C> with(final ISeq<Phenotype<G, C>> population) { return EvolutionResult.of( getOptimize(), population, getGeneration(), getTotalGenerations(), getDurations(), getKillCount(), getInvalidCount(), getAlterCount() ); }
@Test(dataProvider = "generations") public void generationCount(final Long generations) { final Engine<DoubleGene, Double> engine = Engine .builder(a -> a.getGene().getAllele(), DoubleChromosome.of(0, 1)) .build(); final EvolutionResult<DoubleGene, Double> result = engine.stream() .limit(generations) .collect(EvolutionResult.toBestEvolutionResult()); Assert.assertEquals(generations.longValue(), result.getTotalGenerations()); }
@Test public void limit1() { final Engine<DoubleGene, Double> engine = Engine .builder( gt -> gt.getGene().getAllele(), DoubleChromosome.of(0, 1)) .build(); final AtomicLong count = new AtomicLong(); final EvolutionResult<DoubleGene, Double> result = engine.stream() .limit(new CountLimit(1)) .peek(r -> count.incrementAndGet()) .collect(EvolutionResult.toBestEvolutionResult()); Assert.assertEquals(count.get(), 1L); Assert.assertEquals(result.getTotalGenerations(), 1L); }
@Test // https://github.com/jenetics/jenetics/issues/318 public void initialPopulationConvergence() { final Problem<Double, DoubleGene, Double> problem = Problem.of( d -> 1.0, Codecs.ofScalar(DoubleRange.of(0, 1)) ); final Engine<DoubleGene, Double> engine = Engine.builder(problem).build(); final AtomicInteger count = new AtomicInteger(); final EvolutionResult<DoubleGene, Double> result = engine.stream() .limit(Limits.byPopulationConvergence(0.03)) .peek(er -> count.incrementAndGet()) .collect(EvolutionResult.toBestEvolutionResult()); Assert.assertNotNull(result); Assert.assertEquals(count.get(), 1); Assert.assertEquals(result.getTotalGenerations(), 1); Assert.assertEquals(result.getGeneration(), 1); }
@Test // https://github.com/jenetics/jenetics/issues/318 public void initialFitnessConvergence() { final Problem<Double, DoubleGene, Double> problem = Problem.of( d -> 1.0, Codecs.ofScalar(DoubleRange.of(0, 1)) ); final Engine<DoubleGene, Double> engine = Engine.builder(problem).build(); final AtomicInteger count = new AtomicInteger(); final EvolutionResult<DoubleGene, Double> result = engine.stream() .limit(Limits.byFitnessThreshold(0.3)) .peek(er -> count.incrementAndGet()) .collect(EvolutionResult.toBestEvolutionResult()); Assert.assertNotNull(result); Assert.assertEquals(count.get(), 1); Assert.assertEquals(result.getTotalGenerations(), 1); Assert.assertEquals(result.getGeneration(), 1); }
@Test // https://github.com/jenetics/jenetics/issues/318 public void initialFitnessConvergence() { final Problem<Double, DoubleGene, Double> problem = Problem.of( d -> 1.0, Codecs.ofScalar(DoubleRange.of(0, 1)) ); final Engine<DoubleGene, Double> engine = Engine.builder(problem).build(); final AtomicInteger count = new AtomicInteger(); final EvolutionResult<DoubleGene, Double> result = engine.stream() .limit(Limits.byFitnessConvergence(1, 2, 0.03)) .peek(er -> count.incrementAndGet()) .collect(EvolutionResult.toBestEvolutionResult()); Assert.assertNotNull(result); Assert.assertEquals(count.get(), 1); Assert.assertEquals(result.getTotalGenerations(), 1); Assert.assertEquals(result.getGeneration(), 1); }
@Test public void concat1() { final EvolutionStreamable<DoubleGene, Double> engine = ConcatEngine.of( _engine1.limit(10), _engine2.limit(10), _engine3.limit(10) ); final AtomicLong count = new AtomicLong(0); final EvolutionResult<DoubleGene, Double> result = engine.stream() .limit(Limits.byFixedGeneration(40)) .limit(100) .peek(r -> count.incrementAndGet()) .collect(EvolutionResult.toBestEvolutionResult()); Assert.assertEquals(count.intValue(), 30); Assert.assertEquals(result.getTotalGenerations(), 30); }
@Test public void cycle2() { final EvolutionStreamable<DoubleGene, Double> engine = CyclicEngine.of( _engine1.limit(10), _engine2.limit(10), _engine3.limit(10) ); final AtomicLong count = new AtomicLong(0); final EvolutionResult<DoubleGene, Double> result = engine.stream() .limit(Limits.byFixedGeneration(50)) .limit(100) .peek(r -> count.incrementAndGet()) .collect(EvolutionResult.toBestEvolutionResult()); Assert.assertEquals(count.intValue(), 50); Assert.assertEquals(result.getTotalGenerations(), 50); }
@Test public void cycle3() { final EvolutionStreamable<DoubleGene, Double> engine = CyclicEngine.of( _engine1.limit(10), _engine2.limit(10), _engine3.limit(10) ); final AtomicLong count = new AtomicLong(0); final EvolutionResult<DoubleGene, Double> result = engine.stream() .limit(Limits.byFixedGeneration(50)) .limit(15) .peek(r -> count.incrementAndGet()) .collect(EvolutionResult.toBestEvolutionResult()); Assert.assertEquals(count.intValue(), 15); Assert.assertEquals(result.getTotalGenerations(), 15); }
@Test public void concat2() { final EvolutionStreamable<DoubleGene, Double> engine = ConcatEngine.of( _engine1.limit(10), _engine2.limit(10), _engine3.limit(10) ); final AtomicLong count = new AtomicLong(0); final EvolutionResult<DoubleGene, Double> result = engine.stream() .limit(Limits.byFixedGeneration(15)) .limit(100) .peek(r -> count.incrementAndGet()) .collect(EvolutionResult.toBestEvolutionResult()); Assert.assertEquals(count.intValue(), 15); Assert.assertEquals(result.getTotalGenerations(), 15); }
@Test public void concat3() { final EvolutionStreamable<DoubleGene, Double> engine = ConcatEngine.of( _engine1.limit(10), _engine2.limit(10), _engine3.limit(10) ); final AtomicLong count = new AtomicLong(0); final EvolutionResult<DoubleGene, Double> result = engine.stream() .limit(Limits.byFixedGeneration(15)) .limit(9) .peek(r -> count.incrementAndGet()) .collect(EvolutionResult.toBestEvolutionResult()); Assert.assertEquals(count.intValue(), 9); Assert.assertEquals(result.getTotalGenerations(), 9); }
@Test public void parallelStream() { final Engine<DoubleGene, Double> engine = Engine .builder(a -> a.getGene().getAllele(), DoubleChromosome.of(0, 1)) .build(); final EvolutionResult<DoubleGene, Double> result = engine .stream() .limit(Limits.byFixedGeneration(1000)) .parallel() .collect(EvolutionResult.toBestEvolutionResult()); Assert.assertTrue( result.getTotalGenerations() >= 1000, "Total generation must be bigger than 1000: " + result.getTotalGenerations() ); }
@Test(dataProvider = "generations") public void generationLimit(final Long generations) { final Engine<DoubleGene, Double> engine = Engine .builder(a -> a.getGene().getAllele(), DoubleChromosome.of(0, 1)) .build(); final EvolutionResult<DoubleGene, Double> result = engine.stream() .limit(Limits.byFixedGeneration(generations)) .collect(EvolutionResult.toBestEvolutionResult()); Assert.assertEquals(generations.longValue(), result.getTotalGenerations()); }
@Test(dataProvider = "generations") public void engineGenerationLimit1(final Long generations) { final Engine<DoubleGene, Double> engine = Engine .builder(a -> a.getGene().getAllele(), DoubleChromosome.of(0, 1)) .build(); final EvolutionResult<DoubleGene, Double> result = engine .limit(() -> Limits.byFixedGeneration(generations)) .stream() .collect(EvolutionResult.toBestEvolutionResult()); Assert.assertEquals(generations.longValue(), result.getTotalGenerations()); }
@Test(dataProvider = "generations") public void engineGenerationLimit2(final Long generations) { final Engine<DoubleGene, Double> engine = Engine .builder(a -> a.getGene().getAllele(), DoubleChromosome.of(0, 1)) .build(); final EvolutionResult<DoubleGene, Double> result = engine .limit(() -> Limits.byFixedGeneration(generations)) .limit(() -> Limits.byFixedGeneration(Math.min(generations, 5))) .stream() .collect(EvolutionResult.toBestEvolutionResult()); Assert.assertEquals(Math.min(generations, 5), result.getTotalGenerations()); }
@Test(invocationCount = 5) public void onesCountLimit() { final Problem<ISeq<BitGene>, BitGene, Integer> problem = Problem.of( genes -> (int)genes.stream().filter(BitGene::getBit).count(), Codec.of( Genotype.of(BitChromosome.of(20, 0.125)), gt -> gt.getChromosome().toSeq() ) ); final Engine<BitGene, Integer> engine = Engine.builder(problem) .build(); final EvolutionResult<BitGene, Integer> result = engine.stream() .limit(Limits.byPopulationConvergence(0.015)) .collect(toBestEvolutionResult()); Assert.assertTrue( result.getTotalGenerations() < 2901, "Gen: " + result.getTotalGenerations() ); }