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 <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 IPermutation Mutate(this Permutation permutation, IRando rando, float mutationRate) { if (rando.NextDouble() < mutationRate) { return(rando.ToPermutation(permutation.Order)); } return(permutation); }
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 IEnumerable <double> ExpDist(this IRando rando, double max) { var logMax = Math.Log(max); while (true) { yield return(Math.Exp(rando.NextDouble() * logMax)); } }
public static IEnumerable <Tuple <int, bool> > ToIndexedBoolEnumerator(this IRando rando, double trueProbability) { var curdex = 0; while (true) { yield return(new Tuple <int, bool>(curdex++, rando.NextDouble() < trueProbability)); } }
public Tuple <IImmutableList <T>, int> Propigate( IImmutableList <T> source, IRando rando, int index) { if ((index == FinalIndex - 1) && (source.Count > FinalIndex)) // trim excess length { return(new Tuple <IImmutableList <T>, int> ( source.RemoveRange(FinalIndex, source.Count - FinalIndex), index + 1 )); } if ((index == source.Count) && (source.Count < FinalIndex)) // pad the end using the inserter { return(new Tuple <IImmutableList <T>, int>( Inserter(source, source.Count), index + 1 )); } var rand = rando.NextDouble(); if (rand > _mutationBound) // no change { return(new Tuple <IImmutableList <T>, int>(source, index + 1)); } if (rand > _insertionBound) // mutate { return(new Tuple <IImmutableList <T>, int>( Mutator(source, index), index + 1 )); } if (rand > _deletionBound) // insert { return(new Tuple <IImmutableList <T>, int>( Inserter(source, index), index + 1 )); } // delete { return(new Tuple <IImmutableList <T>, int>( Deletor(source, index), index )); } }
public T Draw(IRando rando) { var rv = rando.NextDouble(); for (var i = 0; i < _bins.Count; i++) { if (_bins[i].Item1 > rv) { return(_bins[i].Item2); } } throw new Exception("bin not selected in DiscDistrib.Draw"); }
public static IEnumerable <ulong> Mutate(this IEnumerable <ulong> bits, IRando randy, double mutationRate) { const int bitsLen = 64; return(bits.Select(b => { var bp = b; for (uint i = 0; i < bitsLen; i++) { if (randy.NextDouble() < mutationRate) { bp = bp.BitFlip(i); } } return bp; })); }
public static T[] FisherYatesPartialShuffle <T>(this IReadOnlyList <T> origList, IRando rando, double mixingRate) { var arrayLength = origList.Count; var retArray = origList.ToArray(); for (var i = arrayLength - 1; i > 0; i--) { if (rando.NextDouble() > mixingRate) { continue; } var j = rando.NextInt(i + 1); var temp = retArray[i]; retArray[i] = retArray[j]; retArray[j] = temp; } return(retArray); }
StandardRecombinator <T>( IRando rando, double recombinationRate ) { return((tLeft, tRight) => { var retLeft = new List <T>(); var retRight = new List <T>(); var minCount = Math.Min(tLeft.Count, tRight.Count); var feedLeft = tLeft; var feedRight = tRight; for (var i = 0; i < minCount; i++) { retLeft.Add(feedLeft[i]); retRight.Add(feedRight[i]); if (rando.NextDouble() > recombinationRate) { continue; } var temp = feedLeft; feedLeft = feedRight; feedRight = temp; } if (feedLeft.Count > minCount) { retLeft.AddRange(feedLeft.Skip(minCount).Take(feedLeft.Count - minCount)); } if (feedRight.Count > minCount) { retRight.AddRange(feedRight.Skip(minCount).Take(feedRight.Count - minCount)); } return new Tuple <IReadOnlyList <T>, IReadOnlyList <T> >(retLeft, retRight); }); }