public void ValueOfIndexOutOfBounds2()
{
const int length = 100;
var alleles = MutableSeq.OfLength <int>(length).Fill(Factories.Int()).ToImmutableSeq();
Assert.Throws <IndexOutOfRangeException>(() => new EnumGene <int>(-1, alleles));
}
public void ValueOfZeroLength()
{
const int length = 0;
var alleles = MutableSeq.OfLength <int>(length).Fill(Factories.Int()).ToImmutableSeq();
Assert.Throws <ArgumentException>(() => EnumGene.Of(alleles));
}
public static Population <EnumGene <double>, double> NewPermutationDoubleGenePopulation(int ngenes,
int nchromosomes, int npopulation)
{
var random = new Random(122343);
var alleles = MutableSeq.OfLength <double>(ngenes);
for (var i = 0; i < ngenes; ++i)
{
alleles[i] = random.NextDouble() * 10;
}
var ialleles = alleles.ToImmutableSeq();
var chromosomes = MutableSeq.OfLength <PermutationChromosome <double> >(nchromosomes);
for (var i = 0; i < nchromosomes; ++i)
{
chromosomes[i] = PermutationChromosome.Of(ialleles);
}
var genotype =
new Genotype <EnumGene <double> >(chromosomes.Cast <IChromosome <EnumGene <double> > >().ToImmutableSeq());
var population = new Population <EnumGene <double>, double>(npopulation);
for (var i = 0; i < npopulation; ++i)
{
population.Add(Phenotype.Of(genotype.NewInstance(), 0, gt => gt.Gene.Allele));
}
return(population);
}
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 pmco = new PartiallyMatchedCrossover <int, double>(1);
const int length = 1000;
var alleles = MutableSeq.OfLength <int>(length).Fill(Factories.Int());
var ialleles = alleles.ToImmutableSeq();
var that = alleles.Select(i => new EnumGene <int>(i, ialleles)).ToMutableSeq();
var other = alleles.Select(i => new EnumGene <int>(i, ialleles)).ToMutableSeq();
that.Shuffle();
other.Shuffle();
var thatChrom1 = new PermutationChromosome <int>(that.ToImmutableSeq());
Assert.True(thatChrom1.IsValid, "thatChrom1 not valid");
var otherChrom1 = new PermutationChromosome <int>(other.ToImmutableSeq());
Assert.True(otherChrom1.IsValid, "otherChrom1 not valid");
pmco.Crossover(that, other);
var thatChrom2 = new PermutationChromosome <int>(that.ToImmutableSeq());
Assert.True(thatChrom2.IsValid, "thatChrom2 not valid: " + thatChrom2.ToImmutableSeq());
var otherChrom2 = new PermutationChromosome <int>(other.ToImmutableSeq());
Assert.True(otherChrom2.IsValid, "otherChrom2 not valid: " + otherChrom2.ToImmutableSeq());
Assert.False(thatChrom1.Equals(thatChrom2), "That chromosome must not be equal");
Assert.False(otherChrom1.Equals(otherChrom2), "That chromosome must not be equal");
}
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 IImmutableSeq <DoubleGene> Seq(double minimum, double maximum, int length)
{
var min = minimum;
var max = maximum;
var r = RandomRegistry.GetRandom();
return(MutableSeq.OfLength <DoubleGene>(length).Fill(() =>
new DoubleGene(random.NextDouble(r, min, max), minimum, maximum)).ToImmutableSeq());
}
public void InvalidChromosome()
{
var alleles = ImmutableSeq.Of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
var gene = new EnumGene <int>(3, alleles);
var genes = MutableSeq.OfLength <EnumGene <int> >(10).Fill(() => gene).ToImmutableSeq();
var chromosome = new PermutationChromosome <int>(genes);
Assert.False(chromosome.IsValid);
}
internal static IImmutableSeq <IntegerGene> Seq(int minimum, int maximum, int length)
{
var min = minimum;
var max = maximum;
var r = RandomRegistry.GetRandom();
return(MutableSeq.OfLength <IntegerGene>(length)
.Fill(() => new IntegerGene(r.NextInt(min, max), minimum, maximum))
.ToImmutableSeq());
}
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 CrossoverWithIllegalChromosome()
{
var pmco = new PartiallyMatchedCrossover <int, double>(1);
const int length = 1000;
var alleles = MutableSeq.OfLength <int>(length).Fill(Factories.Int());
var ialleles = alleles.ToImmutableSeq();
var that = alleles.Select(i => new EnumGene <int>(i, ialleles)).ToMutableSeq();
var other = alleles.Select(i => new EnumGene <int>(i, ialleles)).ToMutableSeq();
pmco.Crossover(that, other);
}
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);
}
protected LongChromosome(SerializationInfo info, StreamingContext context)
{
var genes = MutableSeq.OfLength <LongGene>(info.GetInt32("_length"));
Min = info.GetInt64("_min");
Max = info.GetInt64("_max");
for (var i = 0; i < genes.Length; ++i)
{
genes[i] = new LongGene(info.GetInt64("_gene_" + i), Min, Max);
}
Genes = genes.ToImmutableSeq();
}
internal static IImmutableSeq <LongGene> Seq(
long minimum,
long maximum,
int length
)
{
Require.Positive(length);
var min = minimum;
var max = maximum;
var r = RandomRegistry.GetRandom();
return(MutableSeq.OfLength <LongGene>(length)
.Fill(() => new LongGene(random.NextLong(r, min, max), minimum, maximum))
.ToImmutableSeq());
}
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 ValueOf()
{
const int length = 100;
var alleles = MutableSeq.OfLength <int>(length).Fill(Factories.Int()).ToImmutableSeq();
Assert.Equal(alleles.Length, length);
for (var i = 0; i < alleles.Length; ++i)
{
Assert.Equal(alleles[i], i);
}
for (var i = 0; i < alleles.Length; ++i)
{
Assert.Equal(new EnumGene <int>(i, alleles).Allele, i);
Assert.Same(new EnumGene <int>(i, alleles).GetValidAlleles(), alleles);
}
}
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));
}
public static Population <DoubleGene, double> Population(int ngenes, int nchromosomes, int npopulation)
{
var chromosomes = MutableSeq.OfLength <IChromosome <DoubleGene> >(nchromosomes);
for (var i = 0; i < nchromosomes; ++i)
{
chromosomes[i] = DoubleChromosome.Of(0, 10, ngenes);
}
var genotype = new Genotype <DoubleGene>(chromosomes.ToImmutableSeq());
var population = new Population <DoubleGene, double>(npopulation);
for (var i = 0; i < npopulation; ++i)
{
population.Add(Phenotype.Of(genotype.NewInstance(), 0, TestUtils.Ff));
}
return(population);
}
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();
}
