public static (int, int) GetTwoRandomNumbers(int max)
{
var num1 = ProbabilityUtils.GetRandomInt(0, max);
var num2 = ProbabilityUtils.GetRandomInt(0, max);
return(Math.Min(num1, num2), Math.Max(num1, num2));
}
public IChromosome Crossover(IChromosome chromosome1, IChromosome chromosome2)
{
var vector1 = ((VectorChromosome <T>)chromosome1).GetVector();
var vector2 = ((VectorChromosome <T>)chromosome2).GetVector();
var length = vector1.Length;
var indexes = ProbabilityUtils.SelectKRandomNumbersNonRepeating(length, ProbabilityUtils.GetRandomInt(0, length));
var elementsFromParent2 = new HashSet <T>();
var elementsFromParent2OrderedByIndex = new List <T>();
foreach (var index in indexes)
{
elementsFromParent2.Add(vector2[index]);
elementsFromParent2OrderedByIndex.Add(vector2[index]);
}
var newVector = new T[length];
for (int index = 0, addedElementsFromParent2 = 0; index < length; index++)
{
var elementInParent1 = vector1[index];
if (!elementsFromParent2.Contains(elementInParent1))
{
newVector[index] = elementInParent1;
}
else
{
newVector[index] = elementsFromParent2OrderedByIndex[addedElementsFromParent2];
addedElementsFromParent2++;
}
}
return(new VectorChromosome <T>(newVector, mutationManager, evaluator));
}
public IChromosome GenerateChromosome(IMatrix matrix, int maxDiffBetweenNode)
{
var tryCount = 0;
var distribution = new Dictionary <int, ChromosomePart>();
var random = new Random();
do
{
_probability = ProbabilityUtils.AdaptProbability(_probability, tryCount);
distribution.Clear();
for (var i = 0; i < matrix.Elements.Length; i++)
{
distribution.Add(i, random.NextDouble() < _probability ? ChromosomePart.First : ChromosomePart.Second);
}
tryCount++;
} while (IsNodeCountValid(distribution, maxDiffBetweenNode) == false);
return(new Chromosome
{
Id = Guid.NewGuid(),
Distribution = distribution,
Factors = GetChromosomeFactors(distribution, matrix)
});
}
public void P_CheckIsThreadSafe()
{
var attempts = 1000;
var trueCount = 0;
var falseCount = 0;
var tasks = new Task[attempts];
for (var i = 0; i < attempts; i++)
{
tasks[i] = Task.Run(() =>
{
var value = ProbabilityUtils.P(0.5);
if (value)
{
Interlocked.Increment(ref trueCount);
}
else
{
Interlocked.Increment(ref falseCount);
}
});
}
Task.WaitAll(tasks);
var marginOfError = attempts * 0.1;
trueCount.AssertIsWithinRange(attempts * 0.5, marginOfError);
falseCount.AssertIsWithinRange(attempts * 0.5, marginOfError);
}
public IChromosome Crossover(IChromosome chromosome1, IChromosome chromosome2)
{
var vector1 = ((VectorChromosome <T>)chromosome1).GetVector();
var vector2 = ((VectorChromosome <T>)chromosome2).GetVector();
var length = vector1.Length;
var indexesToTakeFromParent1 = ProbabilityUtils.SelectKRandomNumbersNonRepeating(length, ProbabilityUtils.GetRandomInt(0, length));
var genomesFromChromosome1 = new HashSet <T>();
var newVector = new T[length];
foreach (var index in indexesToTakeFromParent1)
{
newVector[index] = vector1[index];
genomesFromChromosome1.Add(vector1[index]);
}
int lastAddedIndexFromChromsome2 = 0;
for (int i = 0; i < length; i++)
{
if (indexesToTakeFromParent1.Contains(i))
{
continue;
}
while (genomesFromChromosome1.Contains(vector2[lastAddedIndexFromChromsome2]))
{
lastAddedIndexFromChromsome2++;
}
newVector[i] = vector2[lastAddedIndexFromChromsome2];
lastAddedIndexFromChromsome2++;
}
return(new VectorChromosome <T>(newVector, mutationManager, evaluator));
}
public IChromosome Crossover(IChromosome chromosome1, IChromosome chromosome2)
{
var vector1 = ((VectorChromosome <T>)chromosome1).GetVector();
var vector2 = ((VectorChromosome <T>)chromosome2).GetVector();
var length = vector1.Length;
var firstElement = vector1[ProbabilityUtils.GetRandomInt(0, vector1.Length)];
var childArray = new ReapetingAdjacencyMatrix <T>(vector1, vector2).Crossover(firstElement, length);
return(new VectorChromosome <T>(childArray, mutationManager, evaluator));
}
public T GetNeighbor(T element)
{
var neighbors = adjacencyMatrix[element];
if (neighbors.Count == 0)
{
return(adjacencyMatrix.Keys.ElementAt(ProbabilityUtils.GetRandomInt(adjacencyMatrix.Count)));
}
return(neighbors.ElementAt(ProbabilityUtils.GetRandomInt(neighbors.Count)));
}
private VectorChromosome <bool> GetChromosome()
{
var vector = new bool[vectorSize];
for (int i = 0; i < vectorSize; i++)
{
vector[i] = ProbabilityUtils.P(0.5);
}
return(new VectorChromosome <bool>(vector, mutationManager, evaluator));
}
public double[] Mutate(double[] vector)
{
for (int i = 0; i < vector.Length; i++)
{
if (ProbabilityUtils.P(1.0 / vector.Length))
{
vector[i] = ProbabilityUtils.P(0.5) ? maxValue : minValue;
}
}
return(vector);
}
public double[] Mutate(double[] vector)
{
for (int i = 0; i < vector.Length; i++)
{
if (ProbabilityUtils.P(1.0 / vector.Length))
{
vector[i] = ProbabilityUtils.GaussianDistribution(standardDeviation, vector[i]).Clip(minValue, maxValue);
}
}
return(vector);
}
public int[] Mutate(int[] vector)
{
for (int i = 0; i < vector.Length; i++)
{
if (ProbabilityUtils.P(1.0 / vector.Length))
{
vector[i] = ProbabilityUtils.GetRandomInt(minValue, maxValue + 1);
}
}
return(vector);
}
public double[] Mutate(double[] vector)
{
for (int i = 0; i < vector.Length; i++)
{
if (ProbabilityUtils.P(1.0 / vector.Length))
{
vector[i] = minValue + ProbabilityUtils.GetRandomDouble() * range;
}
}
return(vector);
}
public bool[] Mutate(bool[] vector)
{
for (int i = 0; i < vector.Length; i++)
{
if (ProbabilityUtils.P(1.0 / vector.Length))
{
vector[i] = !vector[i];
}
}
return(vector);
}
public T[] Mutate(T[] vector)
{
int from = ProbabilityUtils.GetRandomInt(vector.Length);
int to = ProbabilityUtils.GetRandomInt(vector.Length);
var temp = vector[to];
vector[to] = vector[from];
vector[from] = temp;
return(vector);
}
public void ProbabilitiesAreEqual_ShouldReturnTrue()
{
var mean = 6.32;
var sd = 0.47;
var x = 6;
var z = ProbabilityUtils.Z(x, mean, sd);
var p1 = ProbabilityUtils.ProbabilityLessThanX(z);
var p2 = ProbabilityUtils.ProbabilityLessThanX(x, mean, sd);
Assert.AreEqual(p1, p2);
}
public IEnumerable <IChromosome> GeneratePopulation(int size)
{
var chromosomes = new IChromosome[size];
for (int i = 0; i < size; i++)
{
chromosomes[i] = new MyChromosome(ProbabilityUtils.P(0.5)
? ChromosomeType.OProducer
: ChromosomeType.Oc2Producer);
}
return(chromosomes);
}
public IChromosome SelectChromosome()
{
var randomNumber = ProbabilityUtils.GetRandomDouble();
var sum = 0.0;
var index = -1;
while (sum < randomNumber)
{
index++;
sum += evaluations[index];
}
return(chromosomes[index]);
}
public void SelectKRandomNumbers_KNumbersSelectedTillTill(int till, int k)
{
var numbers = ProbabilityUtils.SelectKRandomNumbersNonRepeating(till, k);
Assert.AreEqual(k, numbers.Count, "Didn't get enough numbers");
foreach (var number in numbers)
{
Assert.AreEqual(1, numbers.Count(n => n == number), "Found the same index more then once");
}
foreach (var number in numbers)
{
Assert.IsTrue(number < till, $"{nameof(number)} = {number}, which is bigger than {nameof(till)} = {till}");
}
}
public IChromosome SelectChromosome()
{
var randomNumber = ProbabilityUtils.GetRandomDouble();
var sum = 0.0;
var index = -1;
while (sum < randomNumber)
{
index++;
sum += SortedPopulation[index].Evaluation;
}
return(SortedPopulation[index].Chromosome);
}
public int[] Mutate(int[] vector)
{
var mean = (maxValue + minValue) / 2.0;
for (int i = 0; i < vector.Length; i++)
{
if (ProbabilityUtils.P(1.0 / vector.Length))
{
vector[i] = (int)ProbabilityUtils.GaussianDistribution(standardDeviation, mean).Clip(minValue, maxValue);
}
}
return(vector);
}
public void StandardNormalDistribution_FromTables_ShouldReturnTrue()
{
var p = ProbabilityUtils.Integral(ProbabilityUtils.StandardNormalPdf, 0, 0.5);
Assert.AreEqual(0.19, Math.Round(p, 2));
p = ProbabilityUtils.Integral(ProbabilityUtils.StandardNormalPdf, 0, -1.1);
Assert.AreEqual(-0.36, Math.Round(p, 2));
p = ProbabilityUtils.Integral(ProbabilityUtils.StandardNormalPdf, 0, 2.35);
Assert.AreEqual(0.49, Math.Round(p, 2));
p = ProbabilityUtils.Integral(ProbabilityUtils.StandardNormalPdf, 0, -1.22);
Assert.AreEqual(-0.39, Math.Round(p, 2));
}
public IChromosome SelectChromosome()
{
ChromosomeEvaluationPair bestChromosome = null;
for (int i = 0; i < tournamentSize; i++)
{
var chromosome = population[ProbabilityUtils.GetRandomInt(0, population.Count())];
if (bestChromosome == null || chromosome.Evaluation > bestChromosome.Evaluation)
{
bestChromosome = chromosome;
}
}
return(bestChromosome.Chromosome);
}
public void GetRandomDouble_CheckIsThreadSafe()
{
var receivedValues = new ConcurrentDictionary <double, byte>();
var tasks = new Task[1000];
for (var i = 0; i < 1000; i++)
{
tasks[i] = Task.Run(() =>
{
var value = ProbabilityUtils.GetRandomDouble();
var addedValue = receivedValues.TryAdd(value, 1);
Assert.IsTrue(addedValue, $"Value {value} already in dictionary");
});
}
Task.WaitAll(tasks);
}
public IChromosome Crossover(IChromosome chromosome1, IChromosome chromosome2)
{
var type1 = ((MyChromosome)chromosome1).Type;
var type2 = ((MyChromosome)chromosome2).Type;
if (type1 == ChromosomeType.OProducer && type2 == ChromosomeType.OProducer)
{
return(new MyChromosome(ChromosomeType.OProducer));
}
if (type1 == ChromosomeType.Oc2Producer && type2 == ChromosomeType.Oc2Producer)
{
return(new MyChromosome(ChromosomeType.Oc2Producer));
}
return(new MyChromosome(ProbabilityUtils.P(0.5) ? ChromosomeType.OProducer : ChromosomeType.Oc2Producer));
}
/// <summary>
/// Returns the neighbor with the smallest set of neighbors, and removes the original element.
/// </summary>
public T GetNeighbor(T element)
{
var neighbors = adjacencyMatrix[element];
Remove(element, neighbors);
if (neighbors.Count == 0)
{
return(adjacencyMatrix.Keys.ElementAt(ProbabilityUtils.GetRandomInt(adjacencyMatrix.Count)));
}
if (!selectNeighborWithLeastNeighbors)
{
return(neighbors.ElementAt(ProbabilityUtils.GetRandomInt(neighbors.Count)));
}
var elemenetsWithMinNeighbors = FindNeighborsWithLeaseNeighbors(neighbors);
return(elemenetsWithMinNeighbors[ProbabilityUtils.GetRandomInt(elemenetsWithMinNeighbors.Count)]);
}
public T[] Mutate(T[] vector)
{
(var start, var end) = ComponetsUtils.GetTwoRandomNumbers(vector.Length + 1);
var insertionIndex = ProbabilityUtils.GetRandomInt(vector.Length - (end - start));
var vectorWithoutStretch = new T[vector.Length - (end - start)];
for (int i = 0; i < start; i++)
{
vectorWithoutStretch[i] = vector[i];
}
for (int addTo = start, addFrom = end; addFrom < vector.Length; addFrom++, addTo++)
{
vectorWithoutStretch[addTo] = vector[addFrom];
}
var newVector = new T[vector.Length];
for (int i = 0; i < insertionIndex; i++)
{
newVector[i] = vectorWithoutStretch[i];
}
if (inversionSttretch)
{
for (int addTo = insertionIndex, addFrom = end - 1; addFrom >= start; addFrom--, addTo++)
{
newVector[addTo] = vector[addFrom];
}
}
else
{
for (int addTo = insertionIndex, addFrom = start; addFrom < end; addFrom++, addTo++)
{
newVector[addTo] = vector[addFrom];
}
}
for (int addTo = insertionIndex + (end - start), addFrom = insertionIndex; addTo < vector.Length; addFrom++, addTo++)
{
newVector[addTo] = vectorWithoutStretch[addFrom];
}
return(newVector);
}
public T[] Mutate(T[] vector)
{
var toRemove = ProbabilityUtils.GetRandomInt(vector.Length);
var insertAt = ProbabilityUtils.GetRandomInt(vector.Length);
var newVector = new T[vector.Length];
if (toRemove < insertAt)
{
for (int i = 0; i < toRemove; i++)
{
newVector[i] = vector[i];
}
for (int i = toRemove; i < insertAt; i++)
{
newVector[i] = vector[i + 1];
}
newVector[insertAt] = vector[toRemove];
for (int i = insertAt + 1; i < vector.Length; i++)
{
newVector[i] = vector[i];
}
}
else
{
for (int i = 0; i < insertAt; i++)
{
newVector[i] = vector[i];
}
newVector[insertAt] = vector[toRemove];
for (int i = insertAt + 1; i <= toRemove; i++)
{
newVector[i] = vector[i - 1];
}
for (int i = toRemove + 1; i < vector.Length; i++)
{
newVector[i] = vector[i];
}
}
return(newVector);
}
public IChromosome Crossover(IChromosome chromosome1, IChromosome chromosome2)
{
(var shortVectorChromosome, var longVectorChromosome) =
Utils.OrderChromosomes <T>(chromosome1, chromosome2);
var newVector = new T[longVectorChromosome.GetVector().Length];
var index = 0;
for (; index < shortVectorChromosome.GetVector().Length; index++)
{
newVector[index] = ProbabilityUtils.P(0.5)
? shortVectorChromosome.GetVector()[index]
: longVectorChromosome.GetVector()[index];
}
for (; index < longVectorChromosome.GetVector().Length; index++)
{
newVector[index] = longVectorChromosome.GetVector()[index];
}
return(new VectorChromosome <T>(newVector, mutationManager, evaluator));
}
private void FillPool(int requestedChromosomes, IChromosome[] chromosomes, double[] evaluations)
{
var pointer = ProbabilityUtils.GetRandomDouble() / requestedChromosomes;
var increment = 1.0 / requestedChromosomes;
var sum = 0.0;
var chromosomeIndex = -1;
var poolChromosomes = new IChromosome[requestedChromosomes];
for (int i = 0; i < requestedChromosomes; i++)
{
while (sum <= pointer)
{
chromosomeIndex++;
sum += evaluations[chromosomeIndex];
}
poolChromosomes[i] = chromosomes[chromosomeIndex];
pointer += increment;
}
pool = new ChromosomePool(poolChromosomes);
}
public void GaussianDistribution_CommonNumbersAreMoreLikely(double mean, double sd)
{
var smallCount = 0;
var bigCount = 0;
for (int i = 0; i < 100; i++)
{
var value = ProbabilityUtils.GaussianDistribution(sd, mean);
Console.WriteLine(value);
if (value >= mean + sd || value <= mean - sd)
{
bigCount++;
}
else
{
smallCount++;
}
}
Assert.IsTrue(smallCount > bigCount, $"Got to many big genomes. Big numberes = {bigCount}; small numbers = {smallCount}");
}