public static IEnumerable <uint> ToUintEnumerator(this IRando rando)
{
while (true)
{
yield return(rando.NextUint());
}
}
public static ISorter MakePhenotype(this GenomeSorterBits genomeSorterBits,
IRando randy)
{
return(0u.CountUp(genomeSorterBits.StageBitsCount)
.Select(i => genomeSorterBits.StageBits[i].ToSorterStage(i))
.ToSorter(id: Guid.NewGuid(), genomeId: genomeSorterBits.Id));
}
public static GaData EvolveSortersDirect(
this GaData sortingGaData, IRando randy)
{
return(sortingGaData.Eval()
.SelectWinningSorters()
.UpdateSortersDirect(randy));
}
public static GenomeSorterDual Mutate(this
GenomeSorterDual genomeDualSorter, IRando randy)
{
var mutantIndex = randy.NextUint(genomeDualSorter.StageCount);
var newChromA = genomeDualSorter.ChromosomeA;
var newChromB = genomeDualSorter.ChromosomeB;
var newChoices = genomeDualSorter.Choices;
if (randy.NextBool(0.5))
{
var mutantStage = randy.RewireSorterStage(genomeDualSorter.ChromoA(mutantIndex));
newChromA = newChromA.ReplaceAtIndex(mutantIndex, mutantStage);
}
else
{
var mutantStage = randy.RewireSorterStage(genomeDualSorter.ChromoB(mutantIndex));
newChromB = newChromB.ReplaceAtIndex(mutantIndex, mutantStage);
}
return(new GenomeSorterDual(
id: Guid.NewGuid(),
chromA: newChromA,
chromB: newChromB,
choices: newChoices));
}
public static StageDimer Mutate(this StageDimer genomeStageDimer, IRando randy)
{
var newStage1 = genomeStageDimer.Stage1;
var newStage2 = genomeStageDimer.Stage2;
var newModifier = genomeStageDimer.Modifier;
var spot = randy.NextUint(3);
switch (spot)
{
case 0:
newStage1 = newStage1.ConjugateBy(randy.ToSingleTwoCyclePermutation(newStage1.Order));
break;
case 1:
newStage2 = newStage2.ConjugateBy(randy.ToSingleTwoCyclePermutation(newStage2.Order));
break;
case 2:
newModifier = newModifier.ConjugateBy(randy.ToSingleTwoCyclePermutation(newModifier.Order));
break;
default:
throw new Exception($"spot {spot} not handled in StageDimerExt.Mutate");
}
return(new StageDimer(
stage1: newStage1,
stage2: newStage2,
modifier: newModifier
));
}
public static IChromosome CopyChromosome
(
this ISwitchableGroupGenome switchableGroupGenome,
IRando randy,
double mutationRate,
double insertionRate,
double deletionRate
)
{
switch (switchableGroupGenome.SwitchableGroupGenomeType)
{
case SwitchableGroupGenomeType.UInt:
var chrom = (IChromosome <IGeneUintModN>)switchableGroupGenome.Chromosome;
return(chrom.StandardPropigate(randy, mutationRate, insertionRate, deletionRate));
case SwitchableGroupGenomeType.ULong:
var chrom2 = (IChromosome <IGeneUlongModN>)switchableGroupGenome.Chromosome;
return(chrom2.StandardPropigate(randy, mutationRate, insertionRate, deletionRate));
case SwitchableGroupGenomeType.BitArray:
var chrom3 = (IChromosome <IGeneBits>)switchableGroupGenome.Chromosome;
return(chrom3.StandardPropigate(randy, mutationRate, insertionRate, deletionRate));
case SwitchableGroupGenomeType.IntArray:
var chrom4 = (IChromosome <IGenePermutation>)switchableGroupGenome.Chromosome;
return(chrom4.StandardPropigate(randy, mutationRate, insertionRate, deletionRate));
default:
throw new Exception("SwitchableGroupGenomeType not handled");
}
}
public static IEnumerable <int> ToIntEnumerator(this IRando rando, int maxValue)
{
while (true)
{
yield return(rando.NextInt(maxValue));
}
}
public static IEnumerable <double> PowDist(this IRando rando, double max, double pow)
{
while (true)
{
yield return(Math.Pow(rando.NextDouble(), pow) * max);
}
}
public static IEnumerable <IRando> ToRandomEnumerator(this IRando rando)
{
while (true)
{
yield return(Fast(rando.NextInt()));
}
}
public static IEnumerable <T> Pick <T>(this IRando rando, IReadOnlyList <T> items)
{
while (true)
{
yield return(items[rando.NextInt(items.Count)]);
}
}
public static IEnumerable <double> ToDoubleEnumerator(this IRando rando)
{
while (true)
{
yield return(rando.NextDouble());
}
}
public static IEnumerable <bool> ToBoolEnumerator(this IRando rando, double trueProbability)
{
while (true)
{
yield return(rando.NextDouble() < trueProbability);
}
}
public static Func <IReadOnlyList <T>, IReadOnlyList <T> > StandardMutator <T>
(
double deletionRate,
double insertionRate,
double mutationRate,
Func <T> geneMutator,
IRando rando
)
{
return(list =>
{
var lp = new ListPropigator <T>
(
deletor: (l, i) => l.RemoveAt(i),
deletionFrequency: deletionRate,
inserter: (l, i) => l.Insert(i, geneMutator.Invoke()),
insertionFrequency: insertionRate,
mutator: (l, i) => l.SetItem(i, geneMutator.Invoke()),
mutationFrequency: mutationRate,
finalIndex: list.Count
);
return list.Mutate(lp, rando);
});
}
public static ISorter Mutate(this ISorter sorter, IRando rando, StageReplacementMode stageReplacementMode)
{
var mutantIndex = rando.NextUint(sorter.StageCount);
var stageToReplace = sorter[(int)mutantIndex];
ISorterStage mutantStage = null;
switch (stageReplacementMode)
{
case StageReplacementMode.RandomReplace:
mutantStage = rando.ToFullSorterStage(order: sorter.Order, stageNumber: mutantIndex);
break;
case StageReplacementMode.RandomRewire:
mutantStage = rando.RewireSorterStage(stageToReplace);
break;
case StageReplacementMode.RandomConjugate:
mutantStage = stageToReplace.ConjugateByRandomPermutation(rando).ToSorterStage(mutantIndex);
break;
case StageReplacementMode.RCTC:
mutantStage = stageToReplace.ConjugateByRandomSingleTwoCycle(rando).ToSorterStage(mutantIndex);
break;
default:
throw new Exception($"{stageReplacementMode.ToString()}");
}
return(sorter.SorterStages.ReplaceAtIndex(mutantIndex, mutantStage)
.ToSorter(id: Guid.NewGuid(), genomeId: Guid.Empty));
}
public static GenomePool <GenomeSorterConjOrbit> ToGenomePoolConjOrbits(
this IRando rando, uint order, uint stageCount, uint poolCount)
{
return(0u.CountUp(poolCount)
.Select(i => rando.ToGenomeConjOrbit(order, stageCount))
.ToGenomePoolConjOrbits(Guid.NewGuid()));
}
public static GenomePool <GenomeSorterStageDimer> ToRecombFine(
this IEnumerable <GenomeSorterStageDimer> genomeDimers, IRando rando)
{
return(genomeDimers.ToRandomPairs(rando)
.SelectMany(rp => rando.RecombineFine(rp.Item1, rp.Item2).Split())
.ToGenomePoolStageDimer(Guid.NewGuid()));
}
public static GaDualSorter EvolveSortersRecomb(this GaDualSorter gaDualSorter,
Dictionary <Guid, SorterResult> sorterResults,
IRando randy,
int selectionFactor)
{
var winSortersCount = gaDualSorter.SorterPool.Count() / selectionFactor;
var bestSorterResults = sorterResults.Values
.OrderBy(r => r.AverageSortedness)
.Take(winSortersCount)
.ToList();
var bestGenomes = bestSorterResults.GroupBy(s => s.Sorter.GenomeId)
.Select(g => gaDualSorter.GenomePoolDualSorter.SorterGenomes[g.Key]);
var bestPairs = bestGenomes.ToRandomPairs(randy);
var recombies = bestPairs.SelectMany(p => p.Item1.Recombine(p.Item2, randy).Split());
var newGenomes = recombies.SelectMany(g =>
Enumerable.Range(0, selectionFactor).Select(i => g.Mutate(randy)));
return(new GaDualSorter(
genomePoolDualSorter: newGenomes.ToGenomePoolDualSorter(Guid.NewGuid()),
sortablePool: gaDualSorter.SortablePool,
randy: randy));
}
public static GenomePool <GenomeSorterDual> ToGenomePoolDualSorter(
this IRando rando, uint order, uint stageCount, uint poolCount)
{
return(new GenomePool <GenomeSorterDual>(Guid.NewGuid(),
0u.CountUp(poolCount).Select(i =>
rando.ToDualSorterGenome(order, stageCount))));
}
public static GenomePool <GenomeSorterStageDimer> ToGenomePoolStageDimer(
this IRando rando, uint order, uint stageCount, uint poolCount)
{
return(0u.CountUp(poolCount)
.Select(i => rando.ToGenomeDimer(order, stageCount))
.ToGenomePoolStageDimer(Guid.NewGuid()));
}
public static uint[] ToFullTwoCycleArray(this IRando rando, uint order)
{
var aRet = uint.MaxValue.Repeat(order).ToArray();
var rem = order;
if (order % 2 == 1)
{
var cd = rando.NextUint(rem);
aRet[cd] = cd;
rem--;
}
var curDex = 0u;
while (rem > 0)
{
if (aRet[curDex] == uint.MaxValue)
{
var steps = rando.NextUint(rem - 1) + 1;
var wr = WalkAndTag(aRet, curDex, steps);
aRet[curDex] = wr;
rem -= 2;
}
curDex++;
}
return(aRet);
}
public static IPermutation ToPermutation(this IRando rando, uint order)
{
return(new Permutation(
order: order,
terms: rando.FisherYatesShuffle(0u.CountUp(order).ToArray())
.ToArray()));
}
public static IEnumerable <ulong> ToUlongEnumerator(this IRando rando)
{
while (true)
{
var retVal = (ulong)rando.NextUint();
yield return((retVal << 32) + rando.NextUint());
}
}
public static StageBits2 Mutate(this StageBits2 stageBits, IRando randy, double mutationRate)
{
return(new StageBits2(
order: stageBits.Order,
masks: stageBits.Masks.Mutate(randy, mutationRate),
bits: stageBits.Bits.Mutate(randy, mutationRate)
));
}
public static StageBits Mutate(this StageBits stageBits, IRando randy, double mutationRate)
{
return(new StageBits(
order: stageBits.Order,
mask: stageBits.Mask.AsEnumerable().Mutate(randy, mutationRate).First(),
bits: stageBits.Bits.Mutate(randy, mutationRate)
));
}
public static ISortable Mutate(this ISortable sortable, IRando rando, float replacementRate)
{
if (rando.NextDouble() < replacementRate)
{
return(rando.ToPermutation(sortable.Order).ToSortable());
}
return(sortable);
}
public static IPermutation Mutate(this Permutation permutation, IRando rando, float mutationRate)
{
if (rando.NextDouble() < mutationRate)
{
return(rando.ToPermutation(permutation.Order));
}
return(permutation);
}
public static ISorter ToSorter(this IRando randy, uint order, uint stageCount)
{
return(new Sorter(
id: Guid.NewGuid(),
genomeId: Guid.Empty,
stages: 0u.CountUp(stageCount)
.Select(i => randy.ToFullSorterStage(order, i))));
}
public static ISwitchable <uint[]> ToSwitchableIntArray(this IRando random, int keyCount)
{
return(Enumerable.Range(0, keyCount)
.Cast <uint>()
.ToArray()
.FisherYatesShuffle(random)
.ToSwitchableIntArray());
}
public static StageDimer ToGenomeStageDimer(this IRando randy, uint order)
{
return(new StageDimer(
stage1: randy.ToFullTwoCyclePermutation(order),
stage2: randy.ToFullTwoCyclePermutation(order),
modifier: randy.ToPermutation(order)
));
}
public static ISorterStage RewireSorterStage(this IRando rando, ISorterStage sorterStage)
{
if (sorterStage.Order % 2 == 1)
{
return(rando.MutateSorterStageOdd(sorterStage));
}
return(rando.MutateSorterStageEven(sorterStage));
}
