private static void Main(string[] args)
{
const int populationSize = 100;
//get our cities
var cities = CreateCities().ToList();
//Each city is an object the chromosome is a special case as it needs
//to contain each city only once. Therefore, our chromosome will contain
//all the cities with no duplicates
//we can create an empty population as we will be creating the
//initial solutions manually.
var population = new Population();
//create the chromosomes
for (var p = 0; p < populationSize; p++)
{
var chromosome = new Chromosome();
foreach (var city in cities)
{
var gene = new Gene(city);
chromosome.Genes.Add(gene);
}
var rnd = GAF.Threading.RandomProvider.GetThreadRandom();
chromosome.Genes.ShuffleFast(rnd);
population.Solutions.Add(chromosome);
}
//create the elite operator
var elite = new Elite(5);
//create the crossover operator
var crossover = new Crossover(0.9)
{
CrossoverType = CrossoverType.DoublePointOrdered
};
//create the mutation operator
var mutate = new SwapMutate(0.2);
//create the GA
var ga = new GeneticAlgorithm(population, CalculateFitness);
//hook up to some useful events
ga.OnGenerationComplete += ga_OnGenerationComplete;
ga.OnRunComplete += ga_OnRunComplete;
//add the operators
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
//run the GA
ga.Run(Terminate);
Console.Read();
}
private static void SetupGeneticAlgorithm()
{
//create the elite operator
var elite = new Elite(5);
//create the crossover operator
var crossover = new Crossover(0.8)
{
CrossoverType = CrossoverType.SinglePoint //SinglePoint or DoublePoint
};
//create the mutation operator
var mutate = new SwapMutate(0.02);
//create the GA
var ga = new GeneticAlgorithm(population, CalculateFitness);
//hook up to some useful events
ga.OnGenerationComplete += ga_OnGenerationComplete;
ga.OnRunComplete += ga_OnRunComplete;
//add the operators
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
//run the GA
ga.Run(Terminate);
}
private static void Main(string[] args)
{
//get our cities
_cities = CreateCities().ToList();
//Each city can be identified by an integer within the range 0-15
//our chromosome is a special case as it needs to contain each city
//only once. Therefore, our chromosome will contain all the integers
//between 0 and 15 with no duplicates
//we can create an empty population as we will be creating the
//initial solutions manually.
var population = new Population();
//create the chromosomes
for (var p = 0; p < 5000; p++)
{
var chromosome = new Chromosome();
for (var g = 0; g < 16; g++)
{
chromosome.Genes.Add(new Gene(g));
}
var rnd = GAF.Threading.RandomProvider.GetThreadRandom();
chromosome.Genes.ShuffleFast(rnd);
population.Solutions.Add(chromosome);
}
//create the elite operator
var elite = new Elite(15);
//create the crossover operator
var crossover = new Crossover(0.7)
{
CrossoverType = CrossoverType.DoublePointOrdered
};
//create the mutation operator
var mutate = new SwapMutate(0.02);
//create the GA
var ga = new GeneticAlgorithm(population, CalculateFitness);
//hook up to some useful events
ga.OnGenerationComplete += ga_OnGenerationComplete;
ga.OnRunComplete += ga_OnRunComplete;
//add the operators
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
//run the GA
ga.Run(Terminate);
Console.Read();
}
public Board GetBoardSuggestion()
{
var population = new Population();
var randomGen = new Random();
//create the chromosomes
for (var p = 0; p < 100; p++)
{
var chromosome = new Chromosome();
for (var g = 0; g < this.tasks.Length; g++)
{
chromosome.Genes.Add(new Gene(randomGen.Next(0, this.users.Length)));
}
chromosome.Genes.ShuffleFast();
population.Solutions.Add(chromosome);
}
//create the elite operator
var elite = new Elite(5);
//create the crossover operator
var crossover = new Crossover(0.8)
{
CrossoverType = CrossoverType.SinglePoint
};
//create the mutation operator
var mutate = new SwapMutate(0.02);
//create the GA
var ga = new GeneticAlgorithm(population, CalculateFitness);
//hook up to some useful events
ga.OnGenerationComplete += ga_OnGenerationComplete;
ga.OnRunComplete += ga_OnRunComplete;
//add the operators
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
this.watch.Start();
//run the GA
ga.Run(Terminate);
var suggestedBoard = createBoardFromChromose(ga.Population.GetTop(1).First());
var doneTasks = board.tasks.Where(t => t.status.Equals("done"));
board.tasks = suggestedBoard.tasks;
board.tasks.AddRange(doneTasks);
return(board);
}
private static void Main(string[] args)
{
const int populationSize = 100;
const int elitismPercentage = 5;
const double crossoverProbability = 0.8;
const double mutationProbability = 0.02;
// Get the cities
var cities = Helper.CreateCities();
// Initialize a population
var population = new Population();
// Create the chromosomes
for (var p = 0; p < populationSize; p++)
{
var chromosome = new Chromosome();
foreach (var city in cities)
{
chromosome.Genes.Add(new Gene(city));
}
chromosome.Genes.ShuffleFast();
population.Solutions.Add(chromosome);
}
// Create the elite operator
var elite = new Elite(elitismPercentage);
// Create the crossover operator
var crossover = new Crossover(crossoverProbability)
{
CrossoverType = CrossoverType.DoublePointOrdered
};
// Create the mutation operator
var mutate = new SwapMutate(mutationProbability);
// Create the GA
var ga = new GeneticAlgorithm(population, Helper.CalculateFitness);
// Hook up to some useful events
ga.OnGenerationComplete += ga_OnGenerationComplete;
ga.OnRunComplete += ga_OnRunComplete;
// Add the operators
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
// Run the GA
ga.Run(Helper.Terminate);
// Finalize the program
Helper.PrintEnd();
}
static void Main(string[] args)
{
// Initialize the game table, matches and distances
WorldCupChronogram.Initialize();
Distances.Initialize();
// Population, with a chromossome length
var population = new Population(CHROMOSOME_SIZE);
// Random seed
var random = new Random();
// Initialize the population
for (int i = 0; i < INITIAL_POPULATION_SIZE; i++)
{
var chromossome = new Chromosome();
for (int j = 0; j < CHROMOSOME_SIZE; j++)
{
// Somedays have more or less games
var maxGamesInDays = WorldCupChronogram.Days[j].NumberOfGames;
var gene = new Gene(random.Next(maxGamesInDays));
chromossome.Add(gene);
}
population.Solutions.Add(chromossome);
}
// Elite operator
var elite = new Elite(ETILISM);
// Crossover operator
var crossover = new Crossover(CROSSOVER_PROBABILITY);
// Mutation operador
var mutate = new SwapMutate(MUTATION_PROBABILITY);
// GA
var ga = new GeneticAlgorithm(population, CalculateFitness);
// Add operators
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
// Handlers
ga.OnGenerationComplete += ga_OnGenerationComplete;
ga.OnRunComplete += ga_OnRunComplete;
ga.Run(Terminate);
Console.ReadLine();
}
public static int[,] Generate()
{
const int populationSize = 200;
var population = new Population();
Random random = new Random();
boardSize = 4;
int[,] board = new int[boardSize, boardSize];
for (var i = 0; i < boardSize; i++)
{
for (var j = 0; j < boardSize; j++)
{
board[i, j] = random.Next(0, 3);
}
}
//start point and end point
board[0, 0] = 2;
board[boardSize - 1, boardSize - 1] = 0;
for (var p = 0; p < populationSize; p++)
{
var chromosome = new Chromosome();
foreach (var field in board)
{
chromosome.Genes.Add(new Gene(field));
}
population.Solutions.Add(chromosome);
}
var elite = new Elite(10);
var crossover = new Crossover(0.8)
{
CrossoverType = CrossoverType.SinglePoint
};
var mutate = new SwapMutate(0.1);
var ga = new GeneticAlgorithm(population, CalculateFitness);
ga.OnGenerationComplete += ga_OnGenerationComplete;
ga.OnRunComplete += ga_OnRunComplete;
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
ga.Run(Terminate);
return(chromosome2Board(ga.Population.GetTop(1)[0]));
}
private static void Main(string[] args)
{
const int populationSize = 100;
//get our cities
var nodes = CreateNodes().ToList();
var population = new Population();
//create the chromosomes
for (var p = 0; p < populationSize; p++)
{
var chromosome = new Chromosome();
foreach (var node in nodes)
{
chromosome.Genes.Add(new Gene(node));
}
var rnd = GAF.Threading.RandomProvider.GetThreadRandom();
chromosome.Genes.ShuffleFast(rnd);
population.Solutions.Add(chromosome);
}
//create the elite operator
var elite = new Elite(5);
//create the crossover operator
var crossover = new Crossover(0.8)
{
CrossoverType = CrossoverType.DoublePointOrdered
};
//create the mutation operator
var mutate = new SwapMutate(0.02);
//create the GA
var ga = new GeneticAlgorithm(population, CalculateFitness);
//hook up to some useful events
ga.OnGenerationComplete += ga_OnGenerationComplete;
ga.OnRunComplete += ga_OnRunComplete;
//add the operators
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
//run the GA
ga.Run(Terminate);
Console.Read();
}
public Cut[] getBestOrder(Cut[] cuts)
{
const double crossoverProbability = 0.65;
const double mutationProbability = 0.08;
const int elitismPercentage = 5;
bestOrder = new Cut[cuts.Length];
var population = new Population();
//create the chromosomes
for (var p = 0; p < 100; p++)
{
var chromosome = new Chromosome();
foreach (var cut in cuts)
{
chromosome.Genes.Add(new Gene(cut));
}
//chromosome.Genes.ShuffleFast;
population.Solutions.Add(chromosome);
}
//create the elite operator
var elite = new Elite(5);
//create the crossover operator
var crossover = new Crossover(0.8)
{
CrossoverType = CrossoverType.DoublePointOrdered
};
//create the mutation operator
var mutate = new SwapMutate(0.1);
//create the GA
var ga = new GeneticAlgorithm(population, CalculateFitness);
//hook up to some useful events
ga.OnGenerationComplete += ga_OnGenerationComplete;
ga.OnRunComplete += ga_OnRunComplete;
//add the operators
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
//run the GA
ga.Run(Terminate);
return(bestOrder);
}
public static void geneticAlgorithm(object sender, EventArgs e, Label totalPrice, Label totalDistance, Label totalChanges, Label orderOfDests)
{
var population = new Population();
for (var p = 0; p < globals.chromosomeLength; p++)
{
var chromosome = new Chromosome();
for (var g = 0; g < globals.chromosomeLength; g++)
{
chromosome.Genes.Add(new Gene(g));
}
chromosome.Genes.ShuffleFast();
population.Solutions.Add(chromosome);
}
var elite = new Elite(8);
var crossover = new Crossover(0.8)
{
CrossoverType = CrossoverType.DoublePointOrdered
};
var mutate = new SwapMutate(0.04);
var ga = new GeneticAlgorithm(population, objectiveValue);
ga.OnRunComplete += ga_OnRunComplete;
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
ga.Run(Terminate);
globals.order = String.Join(",", globals.orderOfDestinations.ToArray());
totalPrice.Text = Convert.ToString(globals.totalPrice);
totalDistance.Text = Convert.ToString(globals.totalDistance);
totalChanges.Text = Convert.ToString(globals.totalChanges);
orderOfDests.Text = Convert.ToString(globals.order);
if (globals.errorOutput == true)
{
_Default form1 = new _Default();
form1.ErrorMessage();
}
}
static void yMain(string[] args)
{
int populationSize = 100;
double crossoverProbability = 0.65;
double mutationProbability = 0.02;
int elitismPercentage = 5;
var cities = CreateCities().ToList();
Population population = new Population();
for (var p = 0; p < populationSize; p++)
{
Chromosome chromosome = new Chromosome();
foreach (City city in cities)
{
chromosome.Genes.Add(new Gene(city));
}
var rnd = GAF.Threading.RandomProvider.GetThreadRandom();
chromosome.Genes.ShuffleFast(rnd);
population.Solutions.Add(chromosome);
}
//Once the population has been defined, the genetic algorithm can be initialised.
GeneticAlgorithm ga = new GeneticAlgorithm(population, CalculateFitness);
//To monitor progress of the algorithm, several events are available
ga.OnGenerationComplete += ga_OnGenerationComplete;
ga.OnRunComplete += ga_OnRunComplete;
Crossover crossover = new Crossover(crossoverProbability)
{
CrossoverType = CrossoverType.DoublePointOrdered
};
Elite elite = new Elite(elitismPercentage);
SwapMutate mutate = new SwapMutate(mutationProbability);
ga.Operators.Add(crossover);
ga.Operators.Add(elite);
ga.Operators.Add(mutate);
ga.Run(Terminate);
}
public void OptimizeStrategicPlan(PersonalPlanDto personalPlan)
{
PersonalPlan = personalPlan;
var population = new Population();
for (var p = 0; p < 20; p++)
{
var chromosome = new Chromosome();
foreach (var activitySlotDto in personalPlan.Activities)
{
chromosome.Genes.Add(new Gene(activitySlotDto));
}
chromosome.Genes.ShuffleFast();
population.Solutions.Add(chromosome);
}
// create the elite operator
var elite = new Elite(10);
// create the crossover operator
var crossover = new Crossover(0.8)
{
CrossoverType = CrossoverType.DoublePointOrdered
};
// create the mutation operator
var mutate = new SwapMutate(0.02);
// create the GA
var ga = new GeneticAlgorithm(population, CalculateFitness);
// hook up to some useful events
ga.OnGenerationComplete += ga_OnGenerationComplete;
ga.OnRunComplete += ga_OnRunComplete;
// add the operators
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
// run the GA
ga.Run(Terminate);
}
private static void Main(string[] args)
{
for (int i = 0; i < K; i++)
{
Factory tmp = new Factory(names[i], 0);
ListOfFactories.Add(tmp);
}
// GAF components
const int populationSize = 25;
var tasks = CreateTasks().ToList();
var population = new Population();
for (var p = 0; p < populationSize; p++)
{
var chromosome = new Chromosome();
foreach (var work in tasks)
{
chromosome.Genes.Add(new Gene(work));
}
var rnd = GAF.Threading.RandomProvider.GetThreadRandom();
chromosome.Genes.ShuffleFast(rnd);
population.Solutions.Add(chromosome);
}
var elite = new Elite(5);
var crossover = new Crossover(0.8)
{
CrossoverType = CrossoverType.DoublePointOrdered
};
var mutate = new SwapMutate(0.02);
var ga = new GeneticAlgorithm(population, CalculateFitness);
ga.OnGenerationComplete += ga_OnGenerationComplete;
ga.OnRunComplete += ga_OnRunComplete;
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
ga.Run(Terminate);
Console.Read();
}
public void TestGAF()
{
var population = new Population();
int popSize = 100;
for (int i = 0; i < popSize; i++)
{
var tmpStock = new int[stocks.Length];
var tmpItemsCount = new int[itemsCount.Length];
stocks.CopyTo(tmpStock, 0);
itemsLength.CopyTo(tmpItemsCount, 0);
Debug.WriteLine("************************************");
Debug.WriteLine("Create new Chromosome");
var chromosome = new Chromosome();
for (int k = 0; k < stocks.Length; k++)
{
Gene gene;
if (Rnd(k, ref tmpItemsCount, out gene))
chromosome.Genes.Add(gene);
}
chromosome.Genes.ShuffleFast();
population.Solutions.Add(chromosome);
}
var elite = new Elite(10);
var crossover = new Crossover(0.8) { CrossoverType = CrossoverType.SinglePoint };
var mutate = new SwapMutate(0.02);
var ga = new GeneticAlgorithm(population, CalculateFitness);
ga.OnGenerationComplete += Ga_OnGenerationComplete;
ga.OnRunComplete += Ga_OnRunComplete;
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
ga.Run(50);
}
internal void GenerateMelody(Note[] cf)
{
barlengths = new List <int>();
//Assign cantus firmus melody
cantusFirmus = cf;
//Melody constants - zero indexed
const int melodyLength = 6;
//Default GA constants
const int populationSize = 20;
const int elitePercentage = 33;
const double crossoverRate = 0.5;
const double mutationRate = 1;
//Create Population
var population = new Population();
//Values for different note durations
var wholenote = 1;
var halfnote = 0.5;
var quarternote = 0.25;
var eigthnote = 0.125;
//Get available notes
var wholenotes = CreateWholeNotes().ToList();
var halfenotes = CreateHalfNotes().ToList();
var quarternotes = CreateQuarterNotes().ToList();
var eighthnotes = CreateEigthNotes().ToList();
notes.AddRange(wholenotes);
notes.AddRange(halfenotes);
notes.AddRange(quarternotes);
notes.AddRange(eighthnotes);
notes.AddRange(quarternotes);
notes.AddRange(eighthnotes);
bool correct = false;
var chromosome = new Chromosome();
var tempchromosome = new Chromosome();
while (!correct)
{
for (var p = 0; p < populationSize; p++)
{
correct = false;
var replacechromosome = new Chromosome();
chromosome = new Chromosome();
var shufflednotes = notes.OrderBy(a => Guid.NewGuid()).ToList();
foreach (var note in shufflednotes)
{
chromosome.Genes.Add(new Gene(note));
}
//Index
var i = 0;
double total = 0;
while (total < melodyLength)
{
i++;
tempchromosome = chromosome.DeepClone();
tempchromosome.Genes.RemoveRange(0, tempchromosome.Count - i);
total = 0;
var i2 = 0;
for (int index = 0; index < tempchromosome.Count; index++)
{
var note = ((Note)tempchromosome.Genes[index].ObjectValue);
total += note.Length;
}
}
if (total == melodyLength)
{
double j = 0;
bool complete = true;
var i2 = 0;
for (var note = 0; note < tempchromosome.Count; note++)
{
i2++;
var k = ((Note)tempchromosome.Genes[note].ObjectValue);
j += k.Length;
//Ensure each bar is made up of right notes
if (j == 1)
{
j = 0;
barlengths.Add(i2);
i2 = 0;
}
if (j > 1)
{
complete = false;
}
}
if (complete == true)
{
int rangetoremove = i;
chromosome.Genes.RemoveRange(0, chromosome.Count - rangetoremove);
break;
}
}
}
Console.WriteLine("Population Size:" + population.Solutions.Count);
population.Solutions.Add(tempchromosome);
Console.WriteLine("Population Size:" + population.Solutions.Count);
if (population.Solutions.Count == populationSize)
{
correct = true;
}
}
population.Solutions.Sort((a, b) => a.Count - b.Count);
var maxrange = population.Solutions[population.Solutions.Count - 1].Count;
for (int i = 0; i < population.PopulationSize - 1; i++)
{
if (population.Solutions[i].Count != maxrange)
{
var diff = maxrange - population.Solutions[i].Count - 1;
for (int i2 = 1; i2 < diff; i2++)
{
population.Solutions[i].Add(new Gene("Null"));
}
}
}
population.Solutions.Sort((a, b) => a.Count - b.Count);
for (int i = 0; i < population.PopulationSize; i++)
{
if (population.Solutions[i].Count > population.Solutions[0].Count)
{
while (population.Solutions[i].Count != population.Solutions[0].Count)
{
population.Solutions[i].Genes.Remove(population.Solutions[i].Genes[population.Solutions[i].Genes.Count - 1]);
}
}
if (population.Solutions[i].Count > population.Solutions[0].Count)
{
while (population.Solutions[i].Count != population.Solutions[0].Count)
{
population.Solutions[i].Add(new Gene("Null"));
}
}
}
population.EvaluateInParallel = true;
population.ParentSelectionMethod = ParentSelectionMethod.TournamentSelection;
//Initialise elite operator
var elite = new Elite(elitePercentage);
//Initialise crossover operator
var crossover = new Crossover(crossoverRate,
true,
CrossoverType.SinglePoint,
ReplacementMethod.GenerationalReplacement
);
//Initialise mutation operator
var mutate = new SwapMutate(mutationRate);
//Initialise Genetic Algorithm object
var ga = new GeneticAlgorithm(population, CalculateFitness);
//Subscribe events to genetic algorithm
ga.OnGenerationComplete += ga_OnGenerationComplete;
ga.OnRunComplete += ga_OnRunComplete;
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
try
{
ga.Run(Terminate);
}
catch
{
Program.Initialise();
Program.GenerateCounterpoint();
}
Console.Read();
}
/// <summary>
/// Creates a population and let it evolve until termination condition is reached.
/// </summary>
/// <param name="terminationCondition">Evolution termination condition evaluated on each new epoch</param>
/// <returns>The best solution found across the evolution</returns>
public ISolution EvolveUntil(TerminationCondition terminationCondition)
{
var rnd = RandomProvider.GetThreadRandom();
var shiftMatrix = MatrixBuilder.Build(this.problem);
var enumerator = new IncreasingRowsRandomColumns(this.problem.Days, this.problem.Slots);
var constraints = ConstraintsBuilder.Build(this.problem);
var chromoProcessor = new ChromosomeProcessor(shiftMatrix, enumerator, constraints);
var evaluator = new FitnessEvaluator(problem);
var fitnessFunction = new Fitness.FitnessFunction(chromoProcessor, evaluator, shiftMatrix);
var chromosomeLength = shiftMatrix.GetNumberOfUnforcedSlots();
const double crossoverProbability = 0.90;
const double mutationProbability = 0.05;
const int elitismPercentage = 5;
epochs = 1;
epochsWithoutFitnessImprovement = 0;
overallBestFitness = -1;
log.Debug("Starting population.");
var population = new Population();
for (var i = 0; i < populationSize; i++)
{
var c = new Double[chromosomeLength];
for (var k = 0; k < chromosomeLength; k++)
{
c[k] = rnd.NextDouble();
}
var ch = new Chromosome(c);
population.Solutions.Add(ch);
}
//create the genetic operators
var elite = new Elite(elitismPercentage);
var crossover = new Crossover(crossoverProbability, true)
{
CrossoverType = CrossoverType.SinglePoint
};
var mutation = new SwapMutate(mutationProbability);
//create the GA itself
var ga = new GeneticAlgorithm(population, fitnessFunction.Evaluate);
//subscribe to the GAs Generation Complete event
ga.OnGenerationComplete += Ga_OnGenerationComplete;
//add the operators to the ga process pipeline
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutation);
//run the GA
ga.Run((pop, currentGeneration, currentEvaluation) =>
{
return(terminationCondition(currentGeneration, epochsWithoutFitnessImprovement, population.MaximumFitness, population.AverageFitness));
});
population.GetTop(1)[0].Evaluate(fitnessFunction.Evaluate);
return(SolutionBuilder.Build(overallBestFitness, shiftMatrix, epochs * population.PopulationSize, this.problem.Items));
}
internal void GenerateMelody(Note[] cf)
{
//Assign cantus firmus melody
cantusFirmus = cf;
//Melody constants - zero indexed
const int melodyLength = 20;
//Default GA constants
const int populationSize = 1000;
const int elitePercentage = 33;
const double crossoverRate = 0.9;
const double mutationRate = 0.9;
//Get available notes
var notes = CreateNotes().ToList();
//Create Population
var population = new Population();
for (var p = 0; p < populationSize; p++)
{
var chromosome = new Chromosome();
foreach (var note in notes)
{
chromosome.Genes.Add(new Gene(note));
chromosome.Genes.Add(new Gene(note));
chromosome.Genes.Add(new Gene(note));
chromosome.Genes.Add(new Gene(note));
chromosome.Genes.Add(new Gene(note));
}
//2nd species starts with half a bar rest in first bar and ends on whole note rather than two minims
var rnd = GAF.Threading.RandomProvider.GetThreadRandom();
chromosome.Genes.ShuffleFast(rnd);
chromosome.Genes.RemoveRange(0, 120);
population.Solutions.Add(chromosome);
}
population.EvaluateInParallel = true;
population.ParentSelectionMethod = ParentSelectionMethod.StochasticUniversalSampling;
population.LinearlyNormalised = true;
//Initialise elite operator
var elite = new Elite(elitePercentage);
//Initialise crossover operator
var crossover = new Crossover(crossoverRate,
true,
CrossoverType.SinglePoint,
ReplacementMethod.GenerationalReplacement
);
//Initialise mutation operator
var mutate = new SwapMutate(mutationRate);
//Initialise Genetic Algorithm object
var ga = new GeneticAlgorithm(population, CalculateFitness);
//Subscribe events to genetic algorithm
ga.OnGenerationComplete += ga_OnGenerationComplete;
ga.OnRunComplete += ga_OnRunComplete;
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
ga.Run(Terminate);
Console.Read();
}
private static void Main(string [] args)
{
//get our cities
var cities = CreateCities().ToList();
//Each city is an object the chromosome is a special case as it needs
//to contain each city only once. Therefore, our chromosome will contain
//all the cities with no duplicates
//we can create an empty population as we will be creating the
//initial solutions manually.
var population = new Population(false, false);
//create the initial solutions (chromosomes)
for (var p = 0; p < populationSize; p++)
{
var chromosome = new Chromosome();
foreach (var city in cities)
{
chromosome.Genes.Add(new Gene(city));
}
chromosome.Genes.ShuffleFast();
population.Solutions.Add(chromosome);
}
//create the elite operator
var elite = new Elite(5);
//create crossover operator
var crossover = new Crossover(0.85)
{
CrossoverType = CrossoverType.DoublePointOrdered
};
//create the SwapMutate operator
var mutate = new SwapMutate(0.02);
//note that for network fitness evaluation we simply pass null instead of a fitness
//function.
var ga = new GeneticAlgorithm(population, null);
//subscribe to the generation and run complete events
ga.OnGenerationComplete += ga_OnGenerationComplete;
ga.OnRunComplete += ga_OnRunComplete;
//add the operators
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
/****************************************************************************************
* Up until now the GA is configured as if it were a non-distributed example except,
* the fitness function is not specified (see note above)
*
* The NetworkWrapper (below) adds the networking and the Consul class adds service
* discovery functionality.
*
***************************************************************************************/
//we can point the service discovery client at any node running a consul service, typically
//this would be the localhost. An explicit IP/Port is stated here for clarity, see the
//constructor overloads for more details.
IServiceDiscovery serviceDiscovery = new GAF.ServiceDiscovery.Consul.Client("192.168.1.90", 8500);
/****************************************************************************************
* The StaticServices class is a IServiceDiscovery implementation that can be used to access
* the specified endpoints. Use this is no specific discovery service is available.
*
***************************************************************************************
* var endpoints = new List<IPEndPoint> ();
* endpoints.Add (NetworkWrapper.CreateEndpoint ("127.0.0.1:11000"));
* endpoints.Add (NetworkWrapper.CreateEndpoint ("127.0.0.1:11001"));
*
* IServiceDiscovery serviceDiscovery = new GAF.ServiceDiscovery.ServiceEndpoints (endpoints);
*/
var networkWrapper = new NetworkWrapper(ga, serviceDiscovery, "Example.IRemoteFitness.dll", true);
_stopWatch = new Stopwatch();
_stopWatch.Start();
//locally declared terminate function
networkWrapper.GeneticAlgorithm.Run(TerminateAlgorithm);
Console.ReadLine();
}
public void RunGAInstance()
{
// We can create an empty population as we will be creating the
// initial solutions manually.
var population = new Population();
// Create the chromosomes.
for (var p = 0; p < POPULATION_SIZE; p++)
{
var chromosome = new Chromosome();
for (var g = 0; g < NUMBER_OF_CITIES; g++)
{
chromosome.Genes.Add(new Gene(g));
}
chromosome.Genes.ShuffleFast();
population.Solutions.Add(chromosome);
}
// Create the elite operator.
var elite = new Elite(5);
// Create the crossover operator.
var crossover = new Crossover(CROSSOVER_PROBABILITY)
{
CrossoverType = CrossoverType.DoublePointOrdered
};
// Create the mutation operator.
var mutate = new SwapMutate(MUTATION_PROBABILITY);
// Create the GA.
var ga = new GeneticAlgorithm(population, CalculateFitness);
// Hook up to some useful events.
ga.OnGenerationComplete += ga_OnGenerationComplete;
ga.OnRunComplete += ga_OnRunComplete;
// Add the operators.
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
// Begin timing.
STOPWATCH.Restart();
// Run the GA.
ga.Run(Terminate);
}
public void Run()
{
Logger.Log("$ Running genetic algorithm...");
Logger.Log($" Population size (amount of choromosomes): {Population}");
Logger.Log($" Crossover probability: {this.crossoverProbability}");
Logger.Log($" Mutation probability: {this.mutationProbability}");
Logger.Log($" Generation expected: {this.generationExpected}");
Logger.Log($" Elitism percentage: {this.elitismPercentage}");
Logger.Log($" Chromosome length (amount of cities involved in the solution): {this.ChromosomeMaxLength}");
Logger.Log($" ..........................................................................................................................", true);
var population = new Population();
//create the chromosomes
for (int i = 0; i <= Population; i++)
{
var chromosome = new Chromosome();
var rnd = GAF.Threading.RandomProvider.GetThreadRandom();
var chromosomeLength = 0;
while (chromosomeLength < ChromosomeMaxLength)
{
City city = null;
var index = rnd.Next(0, TelcoSur.Cities.Count);
city = TelcoSur.Cities[index];
if (chromosome.Genes.Any(z => ((City)z.ObjectValue).Name == city.Name))
{
continue;
}
var gene = new Gene(city);
chromosome.Genes.Add(gene);
chromosome.Genes.ShuffleFast(rnd);
chromosomeLength++;
}
population.Solutions.Add(chromosome);
}
//create the elite operator
var elite = new Elite(this.elitismPercentage);
//create the crossover operator
var crossover = new Crossover(this.crossoverProbability)
{
CrossoverType = CrossoverType.SinglePoint
};
//create the mutation operator
var mutate = new SwapMutate(this.mutationProbability);
//create the GA
var ga = new GAF.GeneticAlgorithm(population, CalculateFitness);
//hook up to some useful events
ga.OnGenerationComplete += ga_OnGenerationComplete;
ga.OnRunComplete += ga_OnRunComplete;
//add the operators
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
//run the GA
ga.Run(Terminate);
}
public void TestMethod1()
{
/*
Chromosome representation
StockLength*item
*/
for (int i = 0; i < 10; i++)
{
items.Add(new Item(3, 5));
items.Add(new Item(5, 1));
items.Add(new Item(5, 2));
}
var population = CreateInitialePopulation(500);
var elite = new Elite(2);
var crossover = new Crossover(0.85) { CrossoverType = CrossoverType.DoublePointOrdered };
var mutate = new SwapMutate(0.001);
var ga = new GeneticAlgorithm(population, CalculateFitness);
ga.OnGenerationComplete += Ga_OnGenerationComplete;
ga.OnRunComplete += Ga_OnRunComplete;
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
ga.Run(200);
}
private void startButton_Click(object sender, RoutedEventArgs e)
{
startButton.IsEnabled = false;
statusLabel.Content = "Running...";
// Attempt to load board from input file if a file has been specified
if (String.IsNullOrWhiteSpace(inputFilePath.Text))
{ // If no file specified, generate randomly
gameBoard = ClickOMania.Board.GenerateRandomBoard(rand);
}
else
{ // If a file is specified, attempt to read it
try
{
gameBoard = ClickOMania.Board.LoadBoardFromFile(inputFilePath.Text);
}
catch (ApplicationException ex)
{ // If loading fails, display error message and don't attempt to run
statusLabel.Content = ex.Message;
startButton.IsEnabled = true;
return;
}
}
log = new Log(gameBoard);
crossoverProbability = crossoverProbabilitySlider.Value / 100;
mutationProbability = mutationProbabilitySlider.Value / 100;
elitismPercentage = Convert.ToInt32(elitismPercentageSlider.Value);
initialPopulationSize = Convert.ToInt32(populationSizeSlider.Value);
maxGenerations = Convert.ToInt32(maxGenerationsSlider.Value);
lastFiveGens = new Queue <double>();
var population = GenerateInitialPopulation(initialPopulationSize);
//create the genetic operators
var elite = new Elite(elitismPercentage);
var crossover = new Crossover(crossoverProbability, true)
{
AllowDuplicates = true,
CrossoverType = CrossoverType.SinglePoint,
ReplacementMethod = ReplacementMethod.GenerationalReplacement
};
var mutation = new SwapMutate(mutationProbability);
var ga = new GeneticAlgorithm(population, CalculateFitness);
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutation);
ga.OnGenerationComplete += ga_OnGenerationComplete;
ga.OnRunComplete += ga_OnRunComplete;
BackgroundWorker bw = new BackgroundWorker();
bw.WorkerReportsProgress = true;
bw.DoWork += new DoWorkEventHandler(
delegate(object o, DoWorkEventArgs args)
{
b = o as BackgroundWorker;
ga.Run(TerminateFunction);
});
bw.ProgressChanged += new ProgressChangedEventHandler(bw_ProgressChanged);
bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerComplete);
bw.RunWorkerAsync();
}
public void Initialize()
{
_maxEvaluation = SolverParameter.MaxEvaluation;
_initialPopulationCount = SolverParameter.InitialPopulationCount;
eliteOperator = new Elite(SolverParameter.ElitePercentage);
crossoverOperator = new Crossover(SolverParameter.CrossoverProbability) { CrossoverType = CrossoverType.DoublePointOrdered };
mutateOperator = new SwapMutate(SolverParameter.MutationProbability);
CuttingWidth = SolverParameter.CuttingWidth;
MiniLength = SolverParameter.MiniLength;
internalInit();
}
private void startButton_Click(object sender, RoutedEventArgs e)
{
startButton.IsEnabled = false;
statusLabel.Content = "Running...";
// Attempt to load map from input file
try
{
string inputFileContents = readInputFile();
map = buildMap(inputFileContents);
}
catch (ApplicationException ex)
{ // If loading fails, display error message and don't attempt to run
statusLabel.Content = ex.Message;
startButton.IsEnabled = true;
return;
}
log = new Log(map);
crossoverProbability = crossoverProbabilitySlider.Value / 100;
mutationProbability = mutationProbabilitySlider.Value / 100;
elitismPercentage = Convert.ToInt32(elitismPercentageSlider.Value);
initialPopulationSize = Convert.ToInt32(populationSizeSlider.Value);
maxGenerations = Convert.ToInt32(maxGenerationsSlider.Value);
plateauDetectorSize = Convert.ToInt32(plateauSizeSlider.Value);
expertPercentage = Convert.ToInt32(expertPercentageSlider.Value);
// Confirm that expert percentage is high enough to generate at least one expert
if ((expertPercentage / 100D) * initialPopulationSize < 1)
{ // Won't be able to do WoC, abort the run and report why
statusLabel.Content = "Expert percentage too low!";
startButton.IsEnabled = true;
return;
}
plateauDetectorQueue = new Queue <double>();
var population = GenerateInitialPopulation(initialPopulationSize);
//create the genetic operators
var elite = new Elite(elitismPercentage);
var crossover = new Crossover(crossoverProbability)
{
CrossoverType = CrossoverType.DoublePointOrdered
};
crossover.ReplacementMethod = ReplacementMethod.DeleteLast;
var mutation = new SwapMutate(mutationProbability);
var ga = new GeneticAlgorithm(population, CalculateFitness);
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutation);
ga.OnGenerationComplete += ga_OnGenerationComplete;
// Timing
stopwatch = Stopwatch.StartNew();
BackgroundWorker bw = new BackgroundWorker();
bw.WorkerReportsProgress = true;
bw.DoWork += new DoWorkEventHandler(
delegate(object o, DoWorkEventArgs args)
{
b = o as BackgroundWorker;
ga.Run(TerminateFunction);
});
bw.ProgressChanged += new ProgressChangedEventHandler(bw_ProgressChanged);
bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerComplete);
bw.RunWorkerAsync();
}
