public TIndividual SelectForRouletteBreeding(Population <TIndividual, TGene> sourcePopulation, TIndividual forbiddenForBreeding = default(TIndividual))
{
double populationFitnessSum = sourcePopulation.Sum(indiv => FitnessCalculator.CalculateFitness(indiv));
while (true) //repeat in case forbiddenIndividual happens to be last and happens to be chosen
{
double rouletteSumReached = 0;
double randomRouletteSelectionPoint = UniqueRandom.Instance.NextDouble() * populationFitnessSum;
foreach (var individual in sourcePopulation)
{
rouletteSumReached += FitnessCalculator.CalculateFitness(individual);
if (!ExceededSelectionPoint(rouletteSumReached, randomRouletteSelectionPoint, populationFitnessSum))
{
continue;
}
if (forbiddenForBreeding == null || forbiddenForBreeding.Equals(default(TIndividual)))
{
return(individual);
}
if (!forbiddenForBreeding.Equals(individual))
{
return(individual);
}
}
}
}
public void Simulate(int maxTabuListCount, int boardSize,
IChessboardGenerator generator,
IFitnessCalculator calculator)
{
Fitness BestPossibleFitness = calculator.BestFitness;
IntelligentRandom random = new IntelligentRandom();
Chessboard currentCentralPoint = random.Generate(boardSize);
Chessboard currentBestSolution = currentCentralPoint;
HashSet <Chessboard> tabuList = new HashSet <Chessboard>();
Fitness currentBestSolutionFitness = calculator.WorstFitness;
while (tabuList.Count < maxTabuListCount &&
currentBestSolutionFitness.IsWorseThan(BestPossibleFitness))
{
Chessboard bestCandidate = currentCentralPoint?
.GetNeighbourhoodOf()
.Except(tabuList)
.OrderBy(ch => calculator.CalculateFitness(ch).Value)
.FirstOrDefault();
Fitness bestCandidateFitness = calculator.CalculateFitness(bestCandidate);
currentBestSolutionFitness = calculator.CalculateFitness(currentBestSolution);
currentCentralPoint = bestCandidate;
if (bestCandidateFitness.IsBetterThan(currentBestSolutionFitness))
{
currentBestSolution = bestCandidate;
}
tabuList.Add(bestCandidate);
}
FinalChessboard = currentBestSolution;
Result = $@"
-- Tabu Search Result --
Tabu List Count: {tabuList.Count}
Fitness: {calculator.CalculateFitness(FinalChessboard).Value}
{FinalChessboard.ToString()}
";
}
public void Simulate(int startTemperature, int boardSize,
IChessboardGenerator generator,
IFitnessCalculator calculator)
{
Fitness BestPossibleFitness = calculator.BestFitness;
int tenPercent = startTemperature / 10;
Chessboard currentBestChessboard = generator.Generate(boardSize);
Temperature currentTemperature = new Temperature(startTemperature);
Fitness currentBestFitness = calculator.WorstFitness;
while (currentTemperature.IsNotZero &&
currentBestFitness.IsWorseThan(BestPossibleFitness))
{
Chessboard chessboard = generator.Generate(boardSize);
Fitness currentFitness = calculator.CalculateFitness(chessboard);
if (currentFitness.IsBetterThan(currentBestFitness))
{
currentBestFitness = currentFitness;
currentBestChessboard = chessboard;
currentTemperature.IncreaseBy(tenPercent);
}
else
{
currentTemperature.DecreaseBy(1);
}
}
FinalChessboard = currentBestChessboard;
Result = $@"
-- Simulated Annealing Result --
Current Temperature: {currentTemperature.Value}
Fitness: {calculator.CalculateFitness(FinalChessboard).Value}
{FinalChessboard.ToString()}
";
}
private ICollection <Schedule> NaturalSelection(IEnumerable <ScheduleEntry> scheduleEntries)
{
List <Schedule> matingPool = new List <Schedule>();
foreach (var item in Population)
{
item.Fitness = fitnessCalculator.CalculateFitness(item, scheduleEntries);
}
var fitnessSum = Population.Sum(p => p.Fitness);
foreach (var item in Population)
{
var normalizedFitness = (item.Fitness * 100 / fitnessSum) * GeneticAlgorithmConf.POPULATION_SIZE;
for (int i = 0; i < normalizedFitness; i++)
{
matingPool.Add(item);
}
}
return(matingPool);
}
/// <summary>
/// Calculates the fitness of the agent using the given fitnessCalculator.
/// </summary>
/// <param name="fitnessCalculator"></param>
public void CalculateFitness(IFitnessCalculator fitnessCalculator)
{
TotalFitnessCalculations++;
FitnessInfo = fitnessCalculator.CalculateFitness(Chromosome.ToArray());
Fitness = FitnessInfo.Fitness; // Assign fitness directly also, so direct access from outside.
}
public float CalculateFitness()
{
Fitness = _fitnessCalculator.CalculateFitness(Genes);
return(Fitness);
}
