protected internal override int Recombine(Population <TGene, TAllele> population, int[] individuals,
long generation)
{
var random = RandomRegistry.GetRandom();
var pt1 = population[individuals[0]];
var pt2 = population[individuals[1]];
var gt1 = pt1.GetGenotype();
var gt2 = pt2.GetGenotype();
var chIndex = random.NextInt(Math.Min(gt1.Length, gt2.Length));
var c1 = MutableSeq.Of <IChromosome <TGene> >(gt1.ToSeq());
var c2 = MutableSeq.Of <IChromosome <TGene> >(gt2.ToSeq());
var genes1 = MutableSeq.Of <TGene>(c1[chIndex].ToSeq());
var genes2 = MutableSeq.Of <TGene>(c2[chIndex].ToSeq());
Crossover(genes1, genes2);
c1[chIndex] = c1[chIndex].NewInstance(genes1.ToImmutableSeq());
c2[chIndex] = c2[chIndex].NewInstance(genes2.ToImmutableSeq());
population[individuals[0]] = pt1.NewInstance(gt1.NewInstance(c1.ToImmutableSeq()), generation);
population[individuals[1]] = pt2.NewInstance(gt1.NewInstance(c2.ToImmutableSeq()), generation);
return(Order);
}
public void Crossover()
{
var chars = CharSeq.Of("a-zA-Z");
var g1 = new CharacterChromosome(chars, 20).ToSeq();
var g2 = new CharacterChromosome(chars, 20).ToSeq();
const int rv1 = 12;
RandomRegistry.Using(new ConstRandom(rv1), r =>
{
var crossover = new SinglePointCrossover <CharacterGene, double>();
var g1C = MutableSeq.Of <CharacterGene>(g1);
var g2C = MutableSeq.Of <CharacterGene>(g2);
crossover.Crossover(g1C, g2C);
Assert.Equal(g1C.ToImmutableSeq().SubSeq(0, rv1), g1.SubSeq(0, rv1));
Assert.Equal(g1C.SubSeq(rv1), g2.SubSeq(rv1));
Assert.NotEqual(g1C, g2);
Assert.NotEqual(g2C, g1);
const int rv2 = 0;
RandomRegistry.Using(new ConstRandom(rv2), r2 =>
{
var g1C2 = MutableSeq.Of <CharacterGene>(g1);
var g2C2 = MutableSeq.Of <CharacterGene>(g2);
crossover.Crossover(g1C2, g2C2);
Assert.Equal(g1C2, g2);
Assert.Equal(g2C2, g1);
Assert.Equal(g1C2.SubSeq(0, rv2), g1.SubSeq(0, rv2));
Assert.Equal(g1C2.SubSeq(rv2), g2.SubSeq(rv2));
const int rv3 = 1;
RandomRegistry.Using(new ConstRandom(rv3), r3 =>
{
var g1C3 = MutableSeq.Of <CharacterGene>(g1);
var g2C3 = MutableSeq.Of <CharacterGene>(g2);
crossover.Crossover(g1C3, g2C3);
Assert.Equal(g1C3.SubSeq(0, rv3), g1.SubSeq(0, rv3));
Assert.Equal(g1C3.SubSeq(rv3), g2.SubSeq(rv3));
var rv4 = g1.Length;
RandomRegistry.Using(new ConstRandom(rv4), r4 =>
{
var g1C4 = MutableSeq.Of <CharacterGene>(g1);
var g2C4 = MutableSeq.Of <CharacterGene>(g2);
crossover.Crossover(g1C4, g2C);
Assert.Equal(g1C4, g1);
Assert.Equal(g2C4, g2);
Assert.Equal(g1C4.SubSeq(0, rv4), g1.SubSeq(0, rv4));
Assert.Equal(g1C4.SubSeq(rv4), g2.SubSeq(rv4));
});
});
});
});
}
protected int Mutate(IMutableSeq <IChromosome <TGene> > c, int i, double p)
{
var chromosome = c[i];
var genes = MutableSeq.Of <TGene>(chromosome.ToSeq());
var mutations = Mutate(genes, p);
if (mutations > 0)
{
c[i] = chromosome.NewInstance(genes.ToImmutableSeq());
}
return(mutations);
}
public void Recombine()
{
Func <DoubleGene> Factory = delegate()
{
return(DoubleGene.Of(0, 100));
};
var v = MutableSeq.Of(Factory, 10);
var w = MutableSeq.Of(Factory, 10);
var recombinator = new IntermediateCrossover <DoubleGene, double>(0.1, 10);
recombinator.Crossover(v, w);
Assert.True(v.ForAll(dg => dg.IsValid));
Assert.True(w.ForAll(dg => dg.IsValid));
}
public void Recombine()
{
DoubleGene Factory()
{
return(DoubleGene.Of(0, 100));
}
var v = MutableSeq.Of(Factory, 10);
var w = MutableSeq.Of(Factory, 10);
var recombinator = new LineCrossover <DoubleGene, double>();
recombinator.Crossover(v, w);
Assert.True(v.ForAll(dg => dg.IsValid));
Assert.True(w.ForAll(dg => dg.IsValid));
}
