public void PopulationRecombine()
{
RandomRegistry.Using(new Random(123), r =>
{
var pop = TestUtils.NewDoubleGenePopulation(5, 1, 2);
var copy = pop.Copy();
var recombinator = new IntermediateCrossover <DoubleGene, double>(1);
recombinator.Alter(pop, 10);
for (var i = 0; i < pop.Count; ++i)
{
ISeq <DoubleGene> genes = pop[i]
.GetGenotype()
.GetChromosome()
.ToSeq();
ISeq <DoubleGene> genesCopy = copy[i]
.GetGenotype()
.GetChromosome()
.ToSeq();
foreach (var t in genes)
{
Assert.NotEqual(t, genesCopy[i]);
}
}
});
}
public void SelectDistribution(int tournamentSize, Named <double[]> expected, Optimize opt)
{
if (!Enum.IsDefined(typeof(Optimize), opt))
{
throw new InvalidEnumArgumentException(nameof(opt), (int)opt, typeof(Optimize));
}
if (!Enum.IsDefined(typeof(Optimize), opt))
{
throw new InvalidEnumArgumentException(nameof(opt), (int)opt, typeof(Optimize));
}
Retry <Exception>(3, () =>
{
const int loops = 1;
const int npopulation = PopulationCount;
//ThreadLocal<LCG64ShiftRandom> random = new LCG64ShiftRandom.ThreadLocal();
var random = RandomRegistry.GetRandom();
RandomRegistry.Using(random, r =>
{
var distribution = Distribution(
new TournamentSelector <DoubleGene, double>(tournamentSize),
opt,
npopulation,
loops
);
StatisticsAssert.AssertDistribution(distribution, expected.Value, 0.001, 20);
});
});
}
public void CrossoverChanges()
{
var g1 = CharacterChromosome.Of("1234567890").ToSeq();
var g2 = CharacterChromosome.Of("abcdefghij").ToSeq();
RandomRegistry.Using(new Random(10), r =>
{
var crossover = new UniformCrossover <CharacterGene, char>(0.5, 0.5);
var statistics = new DoubleMomentStatistics();
for (var j = 0; j < 1000; ++j)
{
var g1C = g1.Copy();
var g2C = g2.Copy();
var changed = crossover.Crossover(g1C, g2C);
Assert.Equal(Enumerable
.Range(0, g2C.Length)
.Count(i => char.IsDigit(g2C[i].Allele)), changed
);
statistics.Accept(changed);
}
Assert.Equal(5.0, statistics.Mean, 1);
});
}
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 void Crossover()
{
var g1 = CharacterChromosome.Of("1234567890").ToSeq();
var g2 = CharacterChromosome.Of("abcdefghij").ToSeq();
RandomRegistry.Using(new Random(10), r =>
{
var crossover = new UniformCrossover <CharacterGene, char>(0.5, 0.5);
var g1C = g1.Copy();
var g2C = g2.Copy();
var changed = crossover.Crossover(g1C, g2C);
Assert.Equal(Enumerable.Range(0, g2C.Length).Count(i => char.IsDigit(g2C[i].Allele)), changed);
});
}
public void SelectionPerformance(int size, int count, Optimize opt)
{
Func <Genotype <DoubleGene>, double> ff = g => g.Gene.Allele;
Func <Phenotype <DoubleGene, double> > F = delegate()
{
return(Phenotype.Of(Genotype.Of(DoubleChromosome.Of(0.0, 100.0)), 1, ff));
};
RandomRegistry.Using(new Random(543455), r =>
{
var population = Enumerable.Range(0, size)
.Select(i => F())
.ToPopulation();
ISelector <DoubleGene, double> selector = Selector();
if (!(selector is MonteCarloSelector <DoubleGene, double>))
{
var monteCarloSelectionSum =
new MonteCarloSelector <DoubleGene, double>()
.Select(population, count, opt)
.Select(p => p.GetFitness())
.Sum();
var selectionSum =
selector
.Select(population, count, opt)
.Select(p => p.GetFitness())
.Sum();
if (opt == Optimize.Maximum)
{
Assert.True(
selectionSum > monteCarloSelectionSum,
$"{selectionSum} <= {monteCarloSelectionSum}");
}
else
{
Assert.True(
selectionSum < monteCarloSelectionSum,
$"{selectionSum} >= {monteCarloSelectionSum}");
}
}
});
}
public void SelectDistribution(Named <double[]> expected, Optimize opt)
{
Retry <Exception>(3, () =>
{
const int loops = 50;
var npopulation = PopulationCount;
//ThreadLocal<LCG64ShiftRandom> random = new LCG64ShiftRandom.ThreadLocal();
var random = RandomRegistry.GetRandom();
RandomRegistry.Using(random, r =>
{
var distribution = Distribution(
new RouletteWheelSelector <DoubleGene, double>(),
opt,
npopulation,
loops
);
StatisticsAssert.AssertDistribution(distribution, expected.Value, 0.001, 5);
});
});
}
public void Maximize()
{
RandomRegistry.Using(new Random(), r =>
{
Func <Genotype <IntegerGene>, int> ff =
g => g.GetChromosome().GetGene().Allele;
Phenotype <IntegerGene, int> F()
{
return(Phenotype.Of(Genotype.Of(IntegerChromosome.Of(0, 100)), 1, ff));
}
var population = Enumerable.Range(0, 1000)
.Select(i => F())
.ToPopulation();
var selector =
new RouletteWheelSelector <IntegerGene, int>();
var p = selector.Probabilities(population, 100, Optimize.Maximum);
Assert.True(ProbabilitySelector.Sum2One(p), p + " != 1");
});
}
