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)); }