protected internal override int Crossover(IMutableSeq <TGene> v, IMutableSeq <TGene> w)
{
var random = RandomRegistry.GetRandom();
var min = v[0].Min.ToDouble(null);
var max = v[0].Max.ToDouble(null);
var a = Internal.Math.random.NextDouble(random, -_p, 1 + _p);
var b = Internal.Math.random.NextDouble(random, -_p, 1 + _p);
var changed = false;
for (int i = 0, n = Math.Min(v.Length, w.Length); i < n; ++i)
{
var vi = v[i].DoubleValue();
var wi = w[i].DoubleValue();
dynamic t = a * vi + (1 - a) * wi;
dynamic s = b * wi + (1 - b) * vi;
if (t >= min && s >= min && t < max && s < max)
{
v[i] = v[i].NewInstance(t);
w[i] = w[i].NewInstance(s);
changed = true;
}
}
return(changed ? 2 : 0);
}
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 static CharacterGene Of()
{
return(new CharacterGene(
DefaultCharacters,
RandomRegistry.GetRandom().NextInt(DefaultCharacters.Length)
));
}
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);
});
});
}
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 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);
}
}
protected override Factory <EvolutionResult <DoubleGene, double> > Factory()
{
return(() =>
{
var random = RandomRegistry.GetRandom();
return EvolutionResult.Of(
random.NextBoolean() ? Optimize.Maximum : Optimize.Minimum,
new Population <DoubleGene, double>(100)
.Fill(() => Phenotype.Of(
Genotype.Of(DoubleChromosome.Of(0, 1)), 1,
a => a.Gene.Allele),
100
),
random.NextInt(1000),
random.NextInt(1000),
EvolutionDurations.Of(
TimeSpan.FromMilliseconds(random.NextInt(1000000)),
TimeSpan.FromMilliseconds(random.NextInt(1000000)),
TimeSpan.FromMilliseconds(random.NextInt(1000000)),
TimeSpan.FromMilliseconds(random.NextInt(1000000)),
TimeSpan.FromMilliseconds(random.NextInt(1000000)),
TimeSpan.FromMilliseconds(random.NextInt(1000000)),
TimeSpan.FromMilliseconds(random.NextInt(1000000))
),
random.NextInt(100),
random.NextInt(100),
random.NextInt(100)
);
});
}
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 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 static CharacterGene Of(CharSeq validCharacters)
{
return(new CharacterGene(
validCharacters,
RandomRegistry.GetRandom().Next(validCharacters.Length)
));
}
public EnumGene <TAllele> NewInstance()
{
return(new EnumGene <TAllele>(
RandomRegistry.GetRandom().NextInt(_validAlleles.Length),
_validAlleles
));
}
protected internal override int Crossover(IMutableSeq <TGene> v, IMutableSeq <TGene> w)
{
var random = RandomRegistry.GetRandom();
var min = v[0].Min;
var max = v[0].Max;
for (int i = 0, n = Math.Min(v.Length, w.Length); i < n; ++i)
{
var vi = v[i].DoubleValue();
var wi = w[i].DoubleValue();
dynamic t, s;
do
{
var a = NextDouble(random, -_p, 1 + _p);
var b = NextDouble(random, -_p, 1 + _p);
t = a * vi + (1 - a) * wi;
s = b * wi + (1 - b) * vi;
} while (t < min || s < min || t >= max || s >= max);
v[i] = v[i].NewInstance(t);
w[i] = w[i].NewInstance(s);
}
return(2);
}
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 cindex = random.NextInt(Math.Min(gt1.Length, gt2.Length));
var c1 = gt1.ToSeq().Copy();
var c2 = gt2.ToSeq();
var mean = Mean(
c1[cindex].ToSeq().Copy(),
c2[cindex].ToSeq()
);
c1[cindex] = c1[cindex].NewInstance(mean.ToImmutableSeq());
population[individuals[0]] = pt1.NewInstance(gt1.NewInstance(c1.ToImmutableSeq()), generation);
return(1);
}
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);
}
}
protected override int Mutate(IMutableSeq <TGene> genes, double p)
{
var random = RandomRegistry.GetRandom();
return(Internal.Math.random.Indexes(random, genes.Length, p)
.Peek(i => genes[i] = Mutate(genes[i], random))
.Count());
}
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());
}
private Genotype <TGene> Mutate(Genotype <TGene> genotype, double p, IntRef alterations)
{
var chromosomes = genotype.ToSeq().Copy();
alterations.Value += Indexes(RandomRegistry.GetRandom(), genotype.Length, p)
.Select(i => Mutate(chromosomes, i, p)).Sum();
return(genotype.NewInstance(chromosomes.ToImmutableSeq()));
}
protected internal override int Crossover(IMutableSeq <TGene> that, IMutableSeq <TGene> other)
{
var random = RandomRegistry.GetRandom();
var index = random.NextInt(Math.Min(that.Length, other.Length));
SinglePointCrossover.Crossover(that, other, index);
return(2);
}
protected internal override int Crossover(IMutableSeq <TGene> that, IMutableSeq <TGene> other)
{
var length = Math.Min(that.Length, other.Length);
return(random
.Indexes(RandomRegistry.GetRandom(), length, _swapProbability)
.Peek(i => Swap(i, that, other))
.Count());
}
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());
}
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 void ChromosomeProbability()
{
var data = new byte[1234];
RandomRegistry.GetRandom().NextBytes(data);
var c = new BitChromosome(data);
Assert.Equal(Bits.Count(data) / (double)(data.Length * 8), c.GetOneProbability());
}
public void ToBigInteger()
{
var data = new byte[1056];
RandomRegistry.GetRandom().NextBytes(data);
var value = new BigInteger(data);
var chromosome = BitChromosome.Of(value);
Assert.Equal(chromosome.ToBigInteger(), value);
}
public static byte[] NewArray(int length, double p)
{
var bytes = NewArray(length);
foreach (var i in random.Indexes(RandomRegistry.GetRandom(), length, p))
{
bytes[bit_rol(i, 3)] |= (byte)(1 << (i & 7));
}
return(bytes);
}
protected internal override int Crossover(IMutableSeq <TGene> that, IMutableSeq <TGene> other)
{
var n = Math.Min(that.Length, other.Length);
var k = Math.Min(n, _n);
var random = RandomRegistry.GetRandom();
var points = k > 0 ? Base.Subset(n, k, random) : new int[0];
MultiPointCrossover.Crossover(that, other, points);
return(2);
}
protected override int Mutate(IMutableSeq <TGene> genes, double p)
{
var random = RandomRegistry.GetRandom();
if (genes.Length > 1)
{
return(Internal.Math.random.Indexes(random, genes.Length, p)
.Peek(i => genes.Swap(i, random.NextInt(genes.Length)))
.Count());
}
return(0);
}
protected override Factory <ExponentialScaler> Factory()
{
return(() =>
{
var random = RandomRegistry.GetRandom();
double a = random.NextInt(100) + 10;
double b = random.NextInt(100) + 10;
double c = random.NextInt(100) + 10;
return new ExponentialScaler(a, b, c);
});
}
public void FromByteArrayBitSet()
{
var random = RandomRegistry.GetRandom();
var bytes = new byte[234];
random.NextBytes(bytes);
var bits = new BitArray(bytes);
var c = BitChromosome.Of(bits);
Assert.Equal(bytes, c.ToByteArray());
Assert.Equal(bytes, bits.ToByteArray());
}
public void ToByteArray()
{
var random = RandomRegistry.GetRandom();
var data = new byte[16];
for (var i = 0; i < data.Length; ++i)
{
data[i] = (byte)(random.Next() * 256);
}
var bc = new BitChromosome(data);
Assert.Equal(data, bc.ToByteArray());
}
