@Override
    public void accept(final EvolutionResult<?, C> result) {
      if (_fitness.getMax() == null) {
        _fitness = MinMax.of(result.getOptimize().ascending());
      }

      super.accept(result);
    }
  @Override
  public void accept(final EvolutionResult<?, C> result) {
    accept(result.getDurations());

    _killed.accept(result.getKillCount());
    _invalids.accept(result.getInvalidCount());
    _altered.accept(result.getAlterCount());

    result.getPopulation().forEach(pt -> accept(pt, result.getGeneration()));
  }
Exemple #3
0
  /**
   * Perform one evolution step with the given evolution {@code start} object New phenotypes are
   * created with the fitness function and fitness scaler defined by this <em>engine</em>
   *
   * <p><em>This method is thread-safe.</em>
   *
   * @since 3.1
   * @see #evolve(org.jenetics.Population, long)
   * @param start the evolution start object
   * @return the evolution result
   * @throws java.lang.NullPointerException if the given evolution {@code start} is {@code null}
   */
  public EvolutionResult<G, C> evolve(final EvolutionStart<G, C> start) {
    final Timer timer = Timer.of().start();

    final Population<G, C> startPopulation = start.getPopulation();

    // Initial evaluation of the population.
    final Timer evaluateTimer = Timer.of(_clock).start();
    evaluate(startPopulation);
    evaluateTimer.stop();

    // Select the offspring population.
    final CompletableFuture<TimedResult<Population<G, C>>> offspring =
        _executor.async(() -> selectOffspring(startPopulation), _clock);

    // Select the survivor population.
    final CompletableFuture<TimedResult<Population<G, C>>> survivors =
        _executor.async(() -> selectSurvivors(startPopulation), _clock);

    // Altering the offspring population.
    final CompletableFuture<TimedResult<AlterResult<G, C>>> alteredOffspring =
        _executor.thenApply(offspring, p -> alter(p.result, start.getGeneration()), _clock);

    // Filter and replace invalid and to old survivor individuals.
    final CompletableFuture<TimedResult<FilterResult<G, C>>> filteredSurvivors =
        _executor.thenApply(survivors, pop -> filter(pop.result, start.getGeneration()), _clock);

    // Filter and replace invalid and to old offspring individuals.
    final CompletableFuture<TimedResult<FilterResult<G, C>>> filteredOffspring =
        _executor.thenApply(
            alteredOffspring, pop -> filter(pop.result.population, start.getGeneration()), _clock);

    // Combining survivors and offspring to the new population.
    final CompletableFuture<Population<G, C>> population =
        filteredSurvivors.thenCombineAsync(
            filteredOffspring,
            (s, o) -> {
              final Population<G, C> pop = s.result.population;
              pop.addAll(o.result.population);
              return pop;
            },
            _executor.get());

    // Evaluate the fitness-function and wait for result.
    final Population<G, C> pop = population.join();
    final TimedResult<Population<G, C>> result = TimedResult.of(() -> evaluate(pop), _clock).get();

    final EvolutionDurations durations =
        EvolutionDurations.of(
            offspring.join().duration,
            survivors.join().duration,
            alteredOffspring.join().duration,
            filteredOffspring.join().duration,
            filteredSurvivors.join().duration,
            result.duration.plus(evaluateTimer.getTime()),
            timer.stop().getTime());

    final int killCount =
        filteredOffspring.join().result.killCount + filteredSurvivors.join().result.killCount;

    final int invalidCount =
        filteredOffspring.join().result.invalidCount + filteredSurvivors.join().result.invalidCount;

    return EvolutionResult.of(
        _optimize,
        result.result,
        start.getGeneration(),
        durations,
        killCount,
        invalidCount,
        alteredOffspring.join().result.alterCount);
  }
 private static EvolutionResult<DoubleGene, Double> result(
     final int min, final int max, final Optimize opt) {
   return EvolutionResult.of(opt, population(min, max), 1L, EvolutionDurations.ZERO, 1, 1, 1);
 }