/** * Combine the given alterers. * * @param <G> the gene type * @param <C> the fitness function result type * @param alterers the alterers to combine. * @return a new alterer which consists of the given one * @throws NullPointerException if one of the alterers is {@code null}. */ @SafeVarargs public static <G extends Gene<?, G>, C extends Comparable<? super C>> Alterer<G, C> of(final Alterer<G, C>... alterers) { return alterers.length == 0 ? (p, g) -> AltererResult.of(p.asISeq()) : alterers.length == 1 ? alterers[0] : new CompositeAlterer<>(ISeq.of(alterers)); }
@Override public AltererResult<G, C> alter(final Seq<Phenotype<G, C>> population, final long generation) { final Random random = RandomRegistry.getRandom(); final Seq<MutatorResult<Phenotype<G, C>>> result = population .map(pt -> mutate(pt, generation, _probability, random)); return AltererResult.of( result.map(MutatorResult::getResult).asISeq(), result.stream().mapToInt(MutatorResult::getMutations).sum() ); }
@Override public AltererResult<G, C> alter( final Seq<Phenotype<G, C>> population, final long generation ) { AltererResult<G, C> result = AltererResult.of(population.asISeq()); for (Alterer<G, C> alterer : _alterers) { final AltererResult<G, C> as = alterer.alter( result.getPopulation(), generation ); result = AltererResult.of( as.getPopulation(), as.getAlterations() + result.getAlterations() ); } return result; }
@Override public final AltererResult<G, C> alter( final Seq<Phenotype<G, C>> population, final long generation ) { final AltererResult<G, C> result; if (population.size() >= 2) { final Random random = RandomRegistry.getRandom(); final int order = Math.min(_order, population.size()); // Selection of the individuals for recombination. final IntFunction<int[]> individuals = i -> { final int[] ind = subset(population.size(), order, random); ind[0] = i; return ind; }; final MSeq<Phenotype<G, C>> pop = MSeq.of(population); final int count = indexes(random, population.size(), _probability) .mapToObj(individuals) .mapToInt(i -> recombine(pop, i, generation)) .sum(); result = AltererResult.of(pop.toISeq(), count); } else { result = AltererResult.of(population.asISeq()); } return result; }
/** * Concrete implementation of the alter method. It uses the following * mutation methods: {@link #mutate(Phenotype, long, double, Random)}, * {@link #mutate(Genotype, double, Random)}, * {@link #mutate(Chromosome, double, Random)}, {@link #mutate(Gene, Random)}, * in this specific order. * * @see #mutate(Phenotype, long, double, Random) * @see #mutate(Genotype, double, Random) * @see #mutate(Chromosome, double, Random) * @see #mutate(Gene, Random) */ @Override public AltererResult<G, C> alter( final Seq<Phenotype<G, C>> population, final long generation ) { assert population != null : "Not null is guaranteed from base class."; final Random random = RandomRegistry.getRandom(); final double p = pow(_probability, 1.0/3.0); final int P = probability.toInt(p); final Seq<MutatorResult<Phenotype<G, C>>> result = population .map(pt -> random.nextInt() < P ? mutate(pt, generation, p, random) : MutatorResult.of(pt)); return AltererResult.of( result.map(MutatorResult::getResult).asISeq(), result.stream().mapToInt(MutatorResult::getMutations).sum() ); }
@Override public AltererResult<G, C> alter( final Seq<Phenotype<G, C>> population, final long generation ) { final double p = pow(_probability, 1.0/3.0); final IntRef alterations = new IntRef(0); final MSeq<Phenotype<G, C>> pop = MSeq.of(population); indexes(RandomRegistry.getRandom(), pop.size(), p).forEach(i -> { final Phenotype<G, C> pt = pop.get(i); final Genotype<G> gt = pt.getGenotype(); final Genotype<G> mgt = mutate(gt, p, alterations); final Phenotype<G, C> mpt = pt.newInstance(mgt, generation); pop.set(i, mpt); }); return AltererResult.of(pop.toISeq(), alterations.value); }
@Override public AltererResult<G, C> alter( final Seq<Phenotype<G, C>> population, final long generation ) { final AltererResult<G, C> result = _adoptee.alter(population, generation); final MSeq<Phenotype<G, C>> pop = MSeq.of(population); for (int i = 0, n = pop.size(); i < n; ++i) { if (!pop.get(i).isValid()) { pop.set(i, repair(pop.get(i))); } } return AltererResult.of(pop.toISeq(), result.getAlterations()); }