public GeneticSettings(int populationSize,
int geneCount,
int selectionSize,
double mutationProbabiltyAgents,
double mutationProbabilityGenes,
IRandomNumberGenerator randomNumberGenerator,
IFitnessCalculator fitnessCalculator,
IMutator mutator,
ISelector selector,
ICrossover crossover,
IAgentViewer agentViewer,
int topKAgentsCount)
{
if (populationSize < selectionSize)
{
throw new Exception("The population size has to be greater than the selection size");
}
PopulationSize = populationSize;
GeneCount = geneCount;
SelectionSize = selectionSize;
MutationProbabiltyAgents = mutationProbabiltyAgents;
MutationProbabilityGenes = mutationProbabilityGenes;
RandomNumberGenerator = randomNumberGenerator;
FitnessCalculator = fitnessCalculator;
Mutator = mutator;
Selector = selector;
Crossover = crossover;
AgentViewer = agentViewer;
TopKAgentsCount = topKAgentsCount;
}
/// <summary>
/// Creates a new fitness operator.
/// </summary>
/// <param name="solver"></param>
/// <param name="op"></param>
public FitnessComparer(
Solver <GenomeType, ProblemType, WeightType> solver,
IFitnessCalculator <GenomeType, ProblemType, WeightType> op)
{
_op = op;
_solver = solver;
}
public GeneticAlgorithm(IGeneticAlgorithmHelper helper, IUnitOfWork unitOfWork, IFitnessCalculator fitnessCalculator)
{
this.fitnessCalculator = fitnessCalculator;
this.helper = helper;
this.unitOfWork = unitOfWork;
Population = new Collection <Schedule>();
}
/// <summary>
/// Calculates the fitness for this individual.
/// </summary>
/// <param name="op"></param>
/// <param name="problem"></param>
/// <param name="validate"></param>
public void CalculateFitness(
ProblemType problem,
IFitnessCalculator <GenomeType, ProblemType, WeightType> op,
bool validate)
{
_fitness_calculated = true;
_fitness = op.Fitness(problem, this, validate);
}
public ScheduleDNA(IRandomSlotsGenerator slotsGenerator, IFitnessCalculator fitnessCalculator, Random random, bool shouldInitGenes = true, int slotsCount = 80)
{
_slotsGenerator = slotsGenerator;
_fitnessCalculator = fitnessCalculator;
_random = random;
_slotsCount = slotsCount;
Genes = shouldInitGenes ? _slotsGenerator.GetRandomFilledSlots() : new List <Slot>(slotsCount);
}
public OptimiserMock(
DecisionVector decisionVector,
Population initialPopulation,
IFitnessCalculator fitnessCalculator)
: base(initialPopulation, fitnessCalculator)
{
this.decisionVector = decisionVector;
updateDecisionVector(false);
}
/// <summary>
/// Sorts the population according to
/// </summary>
/// <param name="solver"></param>
/// <param name="op"></param>
public void Sort(
Solver <GenomeType, ProblemType, WeightType> solver,
IFitnessCalculator <GenomeType, ProblemType, WeightType> op)
{
// create comparer.
FitnessComparer comparer = new FitnessComparer(solver, op);
// sort using comparer.
_individuals.Sort(comparer);
}
/// <summary>
/// Invokes the calculate fitness method on all agents in the population.
/// </summary>
public void CalculateFitness(IFitnessCalculator fitnessCalculator)
{
double totalFitness = 0;
for (int i = 0; i < Agents.Count; i++)
{
Agents[i].CalculateFitness(fitnessCalculator);
totalFitness += Agents[i].Fitness;
}
fitnessCalculated = true;
AverageFitness = CalculateAverageFitness(totalFitness);
}
/// <summary>
/// Creates a new solver.
/// </summary>
/// <param name="settings"></param>
/// <param name="selector"></param>
/// <param name="combined_operation"></param>
/// <param name="problem"></param>
/// <param name="fitness_calculator"></param>
public Solver(
ProblemType problem,
SolverSettings settings,
ISelector <GenomeType, ProblemType, WeightType> selector,
IOperation <GenomeType, ProblemType, WeightType> combined_operation,
IFitnessCalculator <GenomeType, ProblemType, WeightType> fitness_calculator)
{
_problem = problem;
_settings = settings;
_selector = selector;
_mutation_operation = combined_operation;
_crossOverOperation = combined_operation;
_generation_operation = combined_operation;
_fitness_calculator = fitness_calculator;
}
/// <summary>
/// Constructs a new Nelder-Mead Simplex local search optimiser.
/// </summary>
/// <param name="fitnessCalculator">A <see cref="FitnessCalculatorSingleObjective"/>. <see cref="Optimiser"/></param>
/// <param name="initialLocation">Starting location for the search.</param>
/// <param name="hyperParameters">
/// Instance of <see cref="HyperParameterManager"/> containing values for
/// all the coefficients required by <see cref="NelderMeadHyperParameters"/>.
/// </param>
public NelderMead(
IFitnessCalculator fitnessCalculator,
DecisionVector initialLocation,
HyperParameterManager hyperParameters) :
base(new Simplex(initialLocation.Count), fitnessCalculator)
{
// Set up simplex operations
OperationsManager = new NelderMeadSimplexOperationsManager(hyperParameters);
//Set up simplex
InitialVerticesStillUnevaluated = Simplex.CreateInitialVertices(
initialLocation,
hyperParameters.GetHyperParameterValue <double>(NelderMeadHyperParameters.Simplex_Creation_Step_Size));
//Initialise historian
tempProgress.Add(NelderMeadSimplexOperations.R);
}
/// <summary>
/// Creates an Evolutionary Algorithm.
/// </summary>
/// <param name="initialPopulation">The initial population (can be empty).</param>
/// <param name="fitnessCalculator">A <see cref="FitnessCalculatorSingleObjective"/>. <see cref="Optimiser"/></param>
/// <param name="initialIndividualGenerator">Creates new decision vectors to build the first population. <seealso cref="Base.Conversion.IModel"/></param>
/// <param name="parentSelector">The <see cref="IParentSelectionOperator"/> to use.</param>
/// <param name="recombinationOperator">The <see cref="IRecombinationOperator"/> to use.</param>
/// <param name="mutationOperator">The <see cref="IMutationOperator"/> to use.</param>
/// <param name="reinsertionOperator">The <see cref="IReinsertionOperator"/> to use.</param>
/// <param name="hyperParameters">The <see cref="HyperParameterManager"/> object with relevant settings.</param>
public EvolutionaryAlgorithm(
Population initialPopulation,
IFitnessCalculator fitnessCalculator,
Func <DecisionVector> initialIndividualGenerator,
IParentSelectionOperator parentSelector,
IRecombinationOperator recombinationOperator,
IMutationOperator mutationOperator,
IReinsertionOperator reinsertionOperator,
HyperParameterManager hyperParameters)
: base(initialPopulation, fitnessCalculator)
{
this.initialIndividualGenerator = initialIndividualGenerator;
this.parentSelector = parentSelector;
numberOfParents = hyperParameters.GetHyperParameterValue <int>(EvolutionaryAlgorithmHyperParameters.Number_Of_Parents);
this.recombinationOperator = recombinationOperator;
this.mutationOperator = mutationOperator;
this.reinsertionOperator = reinsertionOperator;
}
/// <summary>
/// Creates a new solver.
/// </summary>
/// <param name="problem"></param>
/// <param name="settings"></param>
/// <param name="selector"></param>
/// <param name="mutation"></param>
/// <param name="cross_over"></param>
/// <param name="generation"></param>
/// <param name="fitness_calculator"></param>
/// <param name="accept_only_better_cross_over"></param>
/// <param name="accept_only_better_mutation"></param>
public Solver(
ProblemType problem,
SolverSettings settings,
ISelector <GenomeType, ProblemType, WeightType> selector,
IMutationOperation <GenomeType, ProblemType, WeightType> mutation,
ICrossOverOperation <GenomeType, ProblemType, WeightType> cross_over,
IGenerationOperation <GenomeType, ProblemType, WeightType> generation,
IFitnessCalculator <GenomeType, ProblemType, WeightType> fitness_calculator,
bool accept_only_better_cross_over, bool accept_only_better_mutation)
{
_problem = problem;
_settings = settings;
_selector = selector;
_generation_operation = generation;
_mutation_operation = mutation;
_crossOverOperation = cross_over;
_fitness_calculator = fitness_calculator;
_accept_only_better_on_cross_over = accept_only_better_cross_over;
_accept_only_better_on_mutation = accept_only_better_mutation;
}
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()}
";
}
/// <summary>
/// Constructs the optimiser.
/// </summary>
/// <param name="initialPopulation">An initial population (can be empty).</param>
/// <param name="fitnessCalculator">Conversion function to assign Fitness to an Individual. <seealso cref="Individual.SetFitness"/></param>
protected Optimiser(Population initialPopulation,
IFitnessCalculator fitnessCalculator)
{
Population = initialPopulation;
this.fitnessCalculator = fitnessCalculator;
}
public SchedulePopulationGenerator(IRandomSlotsGenerator slotsGenerator, IFitnessCalculator fitnessCalculator, Random random)
{
_slotsGenerator = slotsGenerator;
_fitnessCalculator = fitnessCalculator;
_random = random;
}
/// <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 PolygonAdapter(IFitnessCalculator <PolygonIndividual, IPolygonGene> fitnessCalculator) : base(fitnessCalculator)
{
}
/// <summary>
/// Calculates the fitness for this individual.
/// </summary>
/// <param name="problem"></param>
/// <param name="op"></param>
public void CalculateFitness(
ProblemType problem,
IFitnessCalculator <GenomeType, ProblemType, WeightType> op)
{
this.CalculateFitness(problem, op, true);
}
protected GeneticAlgorithmAdapter(IFitnessCalculator <TIndividual, TGene> fitnessCalculator)
{
FitnessCalculator = fitnessCalculator;
}
