Module io.jenetics.ext
Package io.jenetics.ext.engine

Class ConcatEngine<G extends Gene<?,G>,C extends Comparable<? super C>>

java.lang.Object
io.jenetics.ext.engine.ConcatEngine<G,C>
Type Parameters:
G - the gene type
C - the fitness type
All Implemented Interfaces:
EvolutionStreamable<G,C>
public final class ConcatEngine<G extends Gene<?,G>,C extends Comparable<? super C>> extends Object
The ConcatEngine lets you concatenate two (or more) evolution Engine, with different configurations, and let it use as one engine EvolutionStreamable. 
 
                  +----------+               +----------+
                  |       ES |               |       ES |
          +-------+----+     |       +-------+----+     |
  (Start) |            +-----+ Start |            +-----+
   ------>|  Engine 1  |------------>|  Engine 2  |----------->
          |            | Result      |            |      Result
          +------------+             +------------+
The sketch above shows how the engine concatenation works. In this example, the evolution stream of the first engine is evaluated until it terminates. The result of the first stream is then used as start input of the second evolution stream, which then delivers the final result.

Concatenating evolution engines might be useful, if you want to explore your search space with random search first and then start the real GA search. 

 final Problem<double[], DoubleGene, Double> problem = Problem.of(
     v -> Math.sin(v[0])*Math.cos(v[1]),
     Codecs.ofVector(DoubleRange.of(0, 2*Math.PI), 2)
 );

 final Engine<DoubleGene, Double> engine1 = Engine.builder(problem)
     .minimizing()
     .alterers(new Mutator<>(0.2))
     .selector(new MonteCarloSelector<>())
     .build();

 final Engine<DoubleGene, Double> engine2 = Engine.builder(problem)
     .minimizing()
     .alterers(
         new Mutator<>(0.1),
         new MeanAlterer<>())
     .selector(new RouletteWheelSelector<>())
     .build();

 final Genotype<DoubleGene> result =
     ConcatEngine.of(
         engine1.limit(50),
         engine2.limit(() -> Limits.bySteadyFitness(30)))
     .stream()
         .collect(EvolutionResult.toBestGenotype());

 System.out.println(result + ": " +
         problem.fitness().apply(problem.codec().decode(result)));
An essential part, when concatenating evolution engines, is to make sure your engines are creating limited evolution streams. This is what the EvolutionStreamable.limit(Supplier) and EvolutionStreamable.limit(long) methods are for. Limiting an engine means, that this engine will surely create only streams, which are limited with the predicate/generation given to the engine. If you have limited your engines, it is no longer necessary to limit your final evolution stream, but you are still able to do so.
Since:
4.1
Version:
4.1
See Also:

  • Constructor Details

    • ConcatEngine

      public ConcatEngine(List<? extends EvolutionStreamable<G,C>> engines)
      Create a new concatenating evolution engine with the given list of engines.
      Parameters:
      engines - the engines which are concatenated to one engine
      Throws:
      NullPointerException - if the engines or one of its elements is null

  • Method Details

    • stream

      public EvolutionStream<G,C> stream(Supplier<EvolutionStart<G,C>> start)
      Description copied from interface: EvolutionStreamable
      Create a new, possibly infinite, evolution stream with the given evolution start. If an empty Population is given, the engine's genotype factory is used for creating the population. The given population might be the result of another engine, and this method allows to start the evolution with the outcome of a different engine. The fitness function is replaced by the one defined for this engine.
      Parameters:
      start - the data the evolution stream starts with
      Returns:
      a new infinite evolution stream

    • stream

      public EvolutionStream<G,C> stream(EvolutionInit<G> init)
      Description copied from interface: EvolutionStreamable
      Create a new, possibly infinite, evolution stream with the given initial value. If an empty Population is given, the engines genotype factory is used for creating the population. The given population might be the result of another engine, and this method allows to start the evolution with the outcome of a different engine. The fitness function is replaced by the one defined for this engine.
      Parameters:
      init - the data the evolution stream is initialized with
      Returns:
      a new infinite evolution stream

    • of

      @SafeVarargs public static <G extends Gene<?, G>, C extends Comparable<? super C>> ConcatEngine<G,C> of(EvolutionStreamable<G,C>... engines)
      Create a new concatenating evolution engine with the given array of engines.
      Type Parameters:
      G - the gene type
      C - the fitness type
      Parameters:
      engines - the engines which are concatenated to one engine
      Returns:
      a new concatenating evolution engine
      Throws:
      NullPointerException - if the engines or one of its elements is null