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