public void IndexOf2(int size)
{
var random = RandomRegistry.GetRandom();
var props = new double[size];
var divisor = props.Length * (props.Length + 1) / 2.0;
for (var i = 0; i < props.Length; ++i)
{
props[i] = (i + 1) / divisor;
}
Randomize(props, random);
var incremental = ProbabilitySelector.Incremental((double[])props.Clone());
const int samples = 100000;
for (var i = 0; i < samples; ++i)
{
var value = random.NextDouble();
var index1 = ProbabilitySelector.IndexOf(incremental, value);
var index2 = IndexOf(props, value);
Assert.Equal(index2, index1);
}
}
public virtual Population <TGene, TAllele> Select(Population <TGene, TAllele> population, int count, Optimize opt)
{
if (count < 0)
{
throw new ArgumentOutOfRangeException(nameof(count),
$"Selection count must be greater or equal then zero, but was {count}.");
}
var selection = new Population <TGene, TAllele>(count);
if (count > 0 && !population.IsEmpty)
{
var pop = Copy(population);
var prob = Probabilities(pop, count, opt);
CheckAndCorrect(prob);
ProbabilitySelector.Incremental(prob);
var random = RandomRegistry.GetRandom();
selection.Fill(() => pop[ProbabilitySelector.IndexOf(prob, random.NextDouble())], count);
}
return(selection);
}
public void IndexOf1()
{
var random = RandomRegistry.GetRandom();
var props = new double[10];
var divisor = props.Length * (props.Length + 1) / 2.0;
for (var i = 0; i < props.Length; ++i)
{
props[i] = (i + 1) / divisor;
}
Randomize(props, random);
var incremental = ProbabilitySelector.Incremental((double[])props.Clone());
const double samples = 1000000;
var indices = new double[props.Length];
Array.Fill(indices, 0);
for (var i = 0; i < samples; ++i)
{
indices[ProbabilitySelector.IndexOf(incremental, random.NextDouble())] += 1;
}
for (var i = 0; i < props.Length; ++i)
{
indices[i] /= samples;
}
for (var i = 0; i < props.Length; ++i)
{
Assert.Equal(props[i], indices[i], 1);
}
}
public void Revert(int size)
{
var probabilities = Array(size, new Random());
var reverted = ProbabilitySelector.SortAndRevert(probabilities);
for (var i = 0; i < size; ++i)
{
Assert.Equal(size - 1.0, probabilities[i] + reverted[i]);
}
}
public void IndexOfSerialEqualBinary(int size)
{
var probabilities = Array(size, new Random(12));
Arithmetics.Normalize(probabilities);
ProbabilitySelector.Incremental(probabilities);
Assert.Equal(
ProbabilitySelector.IndexOfSerial(probabilities, 0.5),
ProbabilitySelector.IndexOfBinary(probabilities, 0.5)
);
}
public void RevertSortedArray(int size)
{
var values = Array(size, new Random());
System.Array.Sort(values);
var reverted = ProbabilitySelector.SortAndRevert(values);
for (var i = 0; i < values.Length; ++i)
{
Assert.Equal(values.Length - i - 1, reverted[i]);
}
}
public override double[] Probabilities(Population <TGene, TAllele> population, int count)
{
var fitness = new double[population.Count];
// Copy the fitness values to probabilities arrays.
fitness[0] = population[0].GetFitness().ToDouble(null);
var min = fitness[0];
var max = fitness[0];
for (var i = 1; i < fitness.Length; ++i)
{
fitness[i] = population[i].GetFitness().ToDouble(null);
if (fitness[i] < min)
{
min = fitness[i];
}
else if (fitness[i] > max)
{
max = fitness[i];
}
}
var diff = max - min;
if (ProbabilitySelector.Eq(diff, 0.0))
{
// Set equal probabilities if diff (almost) zero.
//Array.Fill(fitness, 1.0 / fitness.Length);
for (int index = 0; index < fitness.Length; index++)
{
fitness[index] = 1.0 / fitness.Length;
}
}
else
{
// Scale fitness values to avoid overflow.
for (var i = fitness.Length; --i >= 0;)
{
fitness[i] = (fitness[i] - min) / diff;
}
// Apply the "Boltzmann" function.
for (var i = fitness.Length; --i >= 0;)
{
fitness[i] = Math.Exp(_b * fitness[i]);
}
}
return(Arithmetics.Normalize(fitness));
}
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");
});
}
public override bool Equals(object obj)
{
return(obj is LinearRankSelector <TGene, TAllele> selector &&
ProbabilitySelector.Eq(selector._nminus, _nminus) &&
ProbabilitySelector.Eq(selector._nplus, _nplus));
}
