G - the gene typeC - the fitness typepublic final class ConcatEngine<G extends Gene<?,G>,C extends Comparable<? super C>> extends Object
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)));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
your are still able to do so.AdaptiveEngine,
CyclicEngine| Constructor and Description |
|---|
ConcatEngine(List<? extends EvolutionStreamable<G,C>> engines)
Create a new concatenating evolution engine with the given list of engines.
|
| Modifier and Type | Method and Description |
|---|---|
static <G extends Gene<?,G>,C extends Comparable<? super C>> |
of(EvolutionStreamable<G,C>... engines)
Create a new concatenating evolution engine with the given array of
engines.
|
EvolutionStream<G,C> |
stream(EvolutionInit<G> init) |
EvolutionStream<G,C> |
stream(Supplier<EvolutionStart<G,C>> start) |
public ConcatEngine(List<? extends EvolutionStreamable<G,C>> engines)
engines - the engines which are concatenated to one engineNullPointerException - if the engines or one of it's
elements is nullpublic EvolutionStream<G,C> stream(Supplier<EvolutionStart<G,C>> start)
public EvolutionStream<G,C> stream(EvolutionInit<G> init)
@SafeVarargs public static <G extends Gene<?,G>,C extends Comparable<? super C>> ConcatEngine<G,C> of(EvolutionStreamable<G,C>... engines)
G - the gene typeC - the fitness typeengines - the engines which are concatenated to one engineNullPointerException - if the engines or one of it's
elements is null© 2007-2018 Franz Wilhelmstötter (2018-10-28 17:23)