static void Main(string[] args)
{
var parser = new TextToSimModelParser();
var provider = new FromFileDataProvider();
var populationGenerator = new PopulationGenerator();
var selector = new GreedyItemSelector();
var mutator = new Mutator();
var popLogger = new FilePopulationLogger();
var evaluator = new Evaluator(selector);
var crossoverSelector = new RouletteSelector();
var crossBreeder = new CrossBreeder();
var problem = provider.Get();
var model = parser.Parse(problem.ToArray());
var simulation = new Simulation(model, mutator, selector, popLogger, evaluator, crossoverSelector,
crossBreeder, populationGenerator);
simulation.Run(Config.Generations, Config.CrossoverProbability, Config.MutationProbability,
Config.Population);
Console.WriteLine("FINITO");
Console.Read();
}
protected override void GenerateInitialPopulation()
{
var randomPool = PopulationGenerator.GenerateOrderedPopulation(Configuration, PossibleValues);
GARun.Population = new OrderedPopulation(Configuration, randomPool, PossibleValues);
GARun.BestChromosome = GARun.Population.Chromosomes[0];
}
public void ItCanGenerateAGenome()
{
var configuration = GATestHelper.GetTravelingSalesmanDefaultConfiguration();
var chromosome = GATestHelper.GetTravelingSalesmanChromosome();
var pool = PopulationGenerator.GenerateOrderedPopulation(configuration, chromosome.Genes);
Assert.AreEqual(configuration.PopulationSize, pool.Length);
}
public void ItCanGenerateAnUnorderedPopulation()
{
var configuration = GATestHelper.GetTravelingSalesmanDefaultConfiguration();
configuration.GeneSize = 11;
var pool = PopulationGenerator.GenerateUnorderedPopulation(configuration, typeof(PhraseGene));
Assert.AreEqual(configuration.PopulationSize, pool.Length);
}
private void CreateRandomPopulation()
{
HashSet <int> populationIndexes = PopulationGenerator.GetRandomPopulation(tileManager.NoOfRows, tileManager.NoOfCols);
List <TileLocation> population = new List <TileLocation>();
foreach (int index in populationIndexes)
{
population.Add(tileManager.GetTileLocationFromIndex(index));
}
PopulateLife(population);
}
public void ItCanUseUnorderedGenes()
{
var configuration = GATestHelper.GetTravelingSalesmanDefaultConfiguration();
configuration.GeneSize = 11;
var pool = PopulationGenerator.GenerateUnorderedPopulation(configuration, typeof(PhraseGene));
var population = new UnorderedPopulation(GATestHelper.GetTravelingSalesmanDefaultConfiguration(), _pool, typeof(PhraseGene));
Assert.IsNotNull(population.Configuration);
Assert.IsNotNull(population.Chromosomes);
}
public void ItCanGenerateAnUnorderedPopulationAndRandomizesTheirValues()
{
var configuration = GATestHelper.GetTravelingSalesmanDefaultConfiguration();
configuration.GeneSize = 24;
var pool = PopulationGenerator.GenerateUnorderedPopulation(configuration, typeof(PhraseGene));
Assert.AreEqual(configuration.PopulationSize, pool.Length);
foreach (var chromosome in pool)
{
Assert.IsNotNull(chromosome);
foreach (var gene in chromosome.Genes)
{
var phraseGene = (PhraseGene)gene;
Assert.IsNotNull(phraseGene);
}
}
}
public static Chromosome[] GetTravelingSalesmanPopulation(GAConfiguration config)
{
var chromosome = GetTravelingSalesmanChromosome();
return(PopulationGenerator.GenerateOrderedPopulation(config, chromosome.Genes));
}
private void CreateLoadPopulation()
{
PopulateLife(PopulationGenerator.GetPopulationLoaf());
}
private void CreateToadPopulation()
{
PopulateLife(PopulationGenerator.GetPopulationToad());
}
public OptimizationResult Solve(long timeLimitMilliseconds, EventHandler <ProgressReport> progress, EventHandler <string> consoleProgress)
{
this.progress = progress;
this.consoleProgress = consoleProgress;
var sw = Stopwatch.StartNew();
Log("Solving started");
Log(new ProgressReport(0.01));
// adjust time limit if unlimited
if (timeLimitMilliseconds == 0)
{
timeLimitMilliseconds = long.MaxValue;
}
// init population
var(population, mapping) = new PopulationGenerator(RandomFactory.Instance).Generate(input, config.PopulationSize, config.MaxNumberOfSantas);
var decoder = new Decoder(input, mapping);
// calculate costs
var result = new OptimizationResult()
{
OptimizationInput = input,
};
var costCalculator = new CostCalculator(decoder, new SimplifiedOptimizationResult(result));
costCalculator.RecalculateCost(population);
// Log characteristics of initial population
Log($"Genetic Algorithm started with following paramters:{Environment.NewLine}{config}");
var bestCost = GetMinCost(population);
Log($"Best solution cost in initial population is: {bestCost}");
// evolution
var evolutionOperation = new EvolutionOperation(config);
var repairOperation = new RepairOperation(input, mapping);
long generation = 0;
for (; generation < config.MaxNumberOfGenerations && sw.ElapsedMilliseconds < timeLimitMilliseconds; generation++)
{
// evolve
evolutionOperation.Evolve(population);
// repair
repairOperation.Repair(population);
// recalculate costs
costCalculator.RecalculateCost(population);
// log current solution
var currentBestCost = GetMinCost(population);
if (currentBestCost < bestCost)
{
bestCost = currentBestCost;
Log($"Found better solution in generation {generation} with cost={bestCost}");
}
}
Log($"Finished at generation {generation} with cost={bestCost}");
Log($"Current stdev is {StDev(population.Select(i => (double)i.Cost).ToList())}");
Log(new ProgressReport(0.99));
// build result
var bestSolution = population.OrderBy(i => i.Cost).First();
result.Routes = decoder.Decode(bestSolution);
result.ResultState = ResultState.Finished;
Log(new ProgressReport(1));
sw.Stop();
result.TimeElapsed = sw.ElapsedMilliseconds / 1000;
return(result);
}
protected override void GenerateInitialPopulation()
{
var randomPool = PopulationGenerator.GenerateUnorderedPopulation(Configuration, GeneType);
GARun.Population = new UnorderedPopulation(Configuration, randomPool, GeneType);
GARun.BestChromosome = GARun.Population.Chromosomes[0];
}
static void Main(string[] args)
{
var teams = GetTeams();
var generator = new FixtureGenerator(teams, 2);
var seasons = new List<Season>();
for (int i = 0; i < NumberOfSeasons; i++)
{
seasons.Add(generator.GenerateFixtures());
}
var criteria = GetCriteria();
var selectionStrategy = new TournamentSelection<Season, MatchDay>(0.8, criteria);
var seasonsCrossedOver = new List<Season>(seasons);
for (int i = 0; i < NumberOfGenerations; i++)
{
var simpleCrossover = new SimpleCrossoverStrategy<Season, MatchDay>();
var populationGenerator = new PopulationGenerator<Season, MatchDay>(seasonsCrossedOver, NumberOfChildrenPerGeneration, simpleCrossover, selectionStrategy);
seasonsCrossedOver = populationGenerator.Generate();
string statistics = populationGenerator.GetStatistics(criteria);
Console.WriteLine("Statistics for generation " + (i + 1));
Console.WriteLine(statistics);
}
var bestSeason = seasonsCrossedOver.OrderByDescending(season => new CriteriaCalculator<Season, MatchDay>(season, criteria).Calculate().Score).FirstOrDefault();
DisplayFixtures(bestSeason);
var calculator = new CriteriaCalculator<Season, MatchDay>(bestSeason, criteria);
var result = calculator.Calculate();
DisplayResults(result);
Console.ReadLine();
}
public void ItThrowsAnExceptionWhenConfigurationIsNotPassed()
{
var configuration = GATestHelper.GetTravelingSalesmanDefaultConfiguration();
var chromosome = GATestHelper.GetTravelingSalesmanChromosome();
var pool = PopulationGenerator.GenerateOrderedPopulation(null, chromosome.Genes);
}
public void ItThrowsAnExceptionWhenNoValuesArePassed()
{
var configuration = GATestHelper.GetTravelingSalesmanDefaultConfiguration();
var pool = PopulationGenerator.GenerateOrderedPopulation(configuration, new TravelingSalesmanGene[1]);
}
public void ItThrowsAnExceptionIfAnOrderedGeneIsUsedToPopulateAnUnorderedPopulation()
{
var configuration = GATestHelper.GetTravelingSalesmanDefaultConfiguration();
var pool = PopulationGenerator.GenerateUnorderedPopulation(configuration, typeof(TravelingSalesmanGene));
}
