public static CharacterGene Of(CharSeq validCharacters)
{
return(new CharacterGene(
validCharacters,
RandomRegistry.GetRandom().Next(validCharacters.Length)
));
}
public static CharacterGene Of(
char character,
CharSeq validCharacters
)
{
return(new CharacterGene(character, validCharacters));
}
internal static IImmutableSeq <CharacterGene> Seq(CharSeq chars, int length)
{
var r = RandomRegistry.GetRandom();
return(MutableSeq.OfLength <CharacterGene>(length)
.Fill(() => new CharacterGene(chars, r.Next(chars.Length)))
.ToImmutableSeq());
}
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));
});
});
});
});
}
public static CharacterChromosome Of(string alleles, CharSeq validChars)
{
var index = new IntRef();
var genes = MutableSeq.OfLength <CharacterGene>(alleles.Length).Fill(
delegate() {
return(CharacterGene.Of(alleles[index.Value++], validChars));
}
).ToImmutableSeq();
return(new CharacterChromosome(genes));
}
public void Crossover(string stringA, string stringB, ISeq <int> points, string expectedA, string expectedB)
{
var a = CharSeq.ToImmutableSeq(stringA);
var b = CharSeq.ToImmutableSeq(stringB);
var ma = a.Copy();
var mb = b.Copy();
var intPoints = points.Select(i => i).ToArray();
MultiPointCrossover.Crossover(ma, mb, intPoints);
Assert.Equal(ToString(ma), expectedA);
Assert.Equal(ToString(mb), expectedB);
}
protected CharacterChromosome(SerializationInfo info, StreamingContext context)
{
var length = info.GetInt32("_length");
_validCharacters = (CharSeq)info.GetValue("_validCharacters", typeof(CharSeq));
var genes = MutableSeq.OfLength <CharacterGene>(length);
for (var i = 0; i < length; ++i)
{
var gene = CharacterGene.Of(
info.GetChar("_gene_" + i),
_validCharacters
);
genes[i] = gene;
}
Genes = genes.ToImmutableSeq();
}
public void SinglePointCrossoverConsistency()
{
var a = CharSeq.ToImmutableSeq("1234567890");
var b = CharSeq.ToImmutableSeq("ABCDEFGHIJ");
for (var i = 0; i < a.Length + 1; ++i)
{
var ma1 = a.Copy();
var mb1 = b.Copy();
var ma2 = a.Copy();
var mb2 = b.Copy();
MultiPointCrossover.Crossover(ma1, mb1, new[] { i });
SinglePointCrossover.Crossover(ma2, mb2, i);
Assert.Equal(ma1, ma2);
Assert.Equal(mb1, mb2);
}
}
public void CrossoverAll1()
{
var chars = CharSeq.Of("a-zA-Z");
var g1 = new CharacterChromosome(chars, 20).ToSeq();
var g2 = new CharacterChromosome(chars, 20).ToSeq();
var crossover = new MultiPointCrossover <CharacterGene, double>(2000);
var points = new int[g1.Length];
for (var i = 0; i < points.Length; ++i)
{
points[i] = i;
}
var ms1 = g1.Copy();
var ms2 = g2.Copy();
crossover.Crossover(ms1, ms2);
}
public void ReverseCrossover(int npoints)
{
for (var i = 1; i < 500; ++i)
{
var chars = CharSeq.Of("a-zA-Z");
var a = new CharacterChromosome(chars, i).ToSeq().Select(g => g.Allele).ToImmutableSeq();
var b = new CharacterChromosome(chars, i).ToSeq().Select(g => g.Allele).ToImmutableSeq();
var ma1 = a.Copy();
var mb1 = b.Copy();
var points = Base.Subset(
a.Length + 1,
Math.Min(npoints, a.Length + 1),
new Random(1234)
);
MultiPointCrossover.Crossover(ma1, mb1, points);
MultiPointCrossover.Crossover(ma1, mb1, points);
Assert.Equal(a, ma1);
Assert.Equal(b, mb1);
}
}
private CharacterGene(char character, CharSeq validChars)
{
Allele = NonNull(character);
_validCharacters = NonNull(validChars);
_valid = _validCharacters.Contains(Allele);
}
private CharacterGene(CharSeq chars, int index)
{
Allele = chars[index];
_validCharacters = chars;
_valid = true;
}
public CharacterChromosome(CharSeq validCharacters, int length) : this(CharacterGene.Seq(validCharacters,
length))
{
Valid = true;
}
public CharacterChromosome(IImmutableSeq <CharacterGene> genes) : base(genes)
{
_validCharacters = genes[0].GetValidCharacters();
}
protected override Factory <IChromosome <EnumGene <char> > > Factory()
{
return(() => PermutationChromosome.Of(CharSeq.Of("a-zA-Z")));
}
