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