public void GivenAPopulationOfOne_WhenANewPopulationIsRetrieved_ItShouldCallTheEvaluateMethodWithTheIndividualAsAParameter()
{
Mock <IFitnessEvaluationStrategy> fitnessEvaluationMock = new Mock <IFitnessEvaluationStrategy>();
IFitnessEvaluationStrategy fitnessEvaluationStrategy = fitnessEvaluationMock.Object;
Mock <ICrossoverStrategy> crossoverMock = new Mock <ICrossoverStrategy>();
crossoverMock.Setup(x => x.Cross(It.IsAny <Individual>(), It.IsAny <Individual>()))
.Returns(new Individual(fitnessEvaluationStrategy, new Configuration()));
ICrossoverStrategy crossoverStrategy = crossoverMock.Object;
Mock <IMutationStrategy> mutationMock = new Mock <IMutationStrategy>();
IMutationStrategy mutationStrategy = mutationMock.Object;
Mock <ISelectionStrategy> selectionMock = new Mock <ISelectionStrategy>();
ISelectionStrategy selectionStrategy = selectionMock.Object;
DifferentialEvolution differentialEvolution = new DifferentialEvolution(mutationStrategy,
crossoverStrategy,
selectionStrategy,
selectionStrategy,
fitnessEvaluationStrategy,
new Configuration());
Individual individual = new Individual(fitnessEvaluationStrategy, new Configuration());
differentialEvolution.population = new List <Individual>
{
individual
};
differentialEvolution.GetNewPopulation();
fitnessEvaluationMock.Verify(c => c.GetFitnessForIndividual(It.Is <Individual>(p => p == individual)));
}
public static async Task <LabellingJob> CreateLabellingJob(ILabellingJobRepository jobRepo,
IJobIterationRepository iterationRepo, IDataStore dataStore, IPredictiveModel model,
ISelectionStrategy selectionStrategy, IStoppingCriterion stoppingCriterion,
ISeedingStrategy seedingStrategy, IJobIterationNotifier notifier, IDataFormat dataFormat,
int batchSize, int seedSize)
{
var job = new LabellingJob()
{
JobID = Guid.NewGuid(),
DataStore = dataStore,
Model = model,
SelectionStrategy = selectionStrategy,
StoppingCriterion = stoppingCriterion,
DataFormat = dataFormat,
BatchSize = batchSize
};
await jobRepo.Add(job);
JobIteration iteration = new JobIteration()
{
JobID = job.JobID,
PreviousIterationID = Guid.Empty,
QueryIDs = (await seedingStrategy.GetQueryIDs(dataStore, dataFormat, seedSize)).ToArray()
};
await iterationRepo.Add(iteration);
notifier.OnLabelsRequested(iteration);
return(job);
}
private void pictureBox1_MouseUp(object sender, MouseEventArgs e)
{
if (selectionStrategy.OnMouseUp(e))
{
isSelecting = false;
pictureBox1.Image = mainScene.GetSceneImage();
if (selectionStrategy is RectangleSelection)
{
selectionStrategy = new RectangleSelection(mainScene);
}
else if (selectionStrategy is EllipseSelection)
{
selectionStrategy = new EllipseSelection(mainScene);
}
else if (selectionStrategy is PolygonSelection)
{
selectionStrategy = new PolygonSelection(mainScene);
}
RefreshPreviewPanel();
}
if (selectionStrategy is ISelectionStrategy)
{
pictureBox1.Invalidate();
}
}
/// <summary>
/// Requests 16 chromosomes, and makes sure we get all 4 at least once.
/// This test checks that the chromosomes are well distributed.
/// </summary>
private void AssertChromosomesAreScattered(ISelectionStrategy selectionStrategy)
{
var population = new[] { 0.23, 0.24, 0.26, 0.27 }.ToPopulation().Evaluate();
selectionStrategy.SetPopulation(population, 100);
bool chromosome1 = false, chromosome2 = false, chromosome3 = false, chromosome4 = false;
for (int i = 0; i < 16; i++)
{
var chromosome = selectionStrategy.SelectChromosome();
if (chromosome.Evaluate() == 0.23)
{
chromosome1 = true;
}
if (chromosome.Evaluate() == 0.24)
{
chromosome2 = true;
}
if (chromosome.Evaluate() == 0.26)
{
chromosome3 = true;
}
if (chromosome.Evaluate() == 0.27)
{
chromosome4 = true;
}
}
Assert.IsTrue(chromosome1, "Didn't get any " + nameof(chromosome1));
Assert.IsTrue(chromosome2, "Didn't get any " + nameof(chromosome2));
Assert.IsTrue(chromosome3, "Didn't get any " + nameof(chromosome3));
Assert.IsTrue(chromosome4, "Didn't get any " + nameof(chromosome4));
}
public GeneticAlgorithm(
double mutationProbability,
double crossoverPropability,
int minPopulationSize,
int maxPopulationSize,
IMutation mutationOperator,
ICrossover crossoverOperator,
IFitnessEvaluator <TWorkload> fitnessEvaluator,
IInitialPopulationCreator initialPopulationCreator,
ITerminationCondition <TState> terminationCondition,
ISelectionStrategy selectionStrategy,
IReinsertionStrategy reinsertionStrategy,
IDeploymentChromosomeFactory chromosomeFactory,
TState currentState,
TWorkload workload,
IRandomProvider randomProvider)
{
MutationProbability = mutationProbability;
CrossoverProbability = crossoverPropability;
MinPopulationSize = minPopulationSize;
MaxPopulationSize = maxPopulationSize;
MutationOperator = mutationOperator;
CrossoverOperator = crossoverOperator;
FitnessEvaluator = fitnessEvaluator;
InitialPopulationCreator = initialPopulationCreator;
TerminationCondition = terminationCondition;
SelectionStrategyStrategy = selectionStrategy;
ReinsertionStrategy = reinsertionStrategy;
ChromosomeFactory = chromosomeFactory;
CurrentState = currentState;
Workload = workload;
RandomProvider = randomProvider;
}
public Segment(string json)
{
SegmentSerializable segmSer = Newtonsoft.Json.JsonConvert.DeserializeObject <SegmentSerializable>(json);
image = StringToImage(segmSer.image);
position = segmSer.point;
switch (segmSer.selectionType)
{
case "RectangleSelection":
{
selectionStrategy = new RectangleSelection(Scene.instance);
((RectangleSelection)selectionStrategy).selectionRectangle = segmSer.rect;
break;
}
case "EllipseSelection":
{
selectionStrategy = new EllipseSelection(Scene.instance);
((EllipseSelection)selectionStrategy).selectionRectangle = segmSer.rect;
break;
}
case "PolygonSelection":
{
selectionStrategy = new PolygonSelection(Scene.instance);
((PolygonSelection)selectionStrategy).newPoints = segmSer.newPoints;
break;
}
}
}
public void GivenFiveIterationsAndThreeIndividuals_WhenTheAlgorithmIsRun_ItShouldCallTheCrossoverStrategyFifteenTimes()
{
Mock <IFitnessEvaluationStrategy> fitnessEvaluationMock = new Mock <IFitnessEvaluationStrategy>();
IFitnessEvaluationStrategy fitnessEvaluationStrategy = fitnessEvaluationMock.Object;
Mock <ICrossoverStrategy> crossoverMock = new Mock <ICrossoverStrategy>();
crossoverMock.Setup(x => x.Cross(It.IsAny <Individual>(), It.IsAny <Individual>()))
.Returns(new Individual(fitnessEvaluationStrategy, new Configuration()));
ICrossoverStrategy crossoverStrategy = crossoverMock.Object;
Mock <IMutationStrategy> mutationMock = new Mock <IMutationStrategy>();
IMutationStrategy mutationStrategy = mutationMock.Object;
Mock <ISelectionStrategy> selectionMock = new Mock <ISelectionStrategy>();
selectionMock.Setup(x => x.Select(It.IsAny <List <Individual> >()))
.Returns(new Individual(fitnessEvaluationStrategy, new Configuration()));
ISelectionStrategy selectionStrategy = selectionMock.Object;
DifferentialEvolution differentialEvolution = new DifferentialEvolution(mutationStrategy,
crossoverStrategy,
selectionStrategy,
selectionStrategy,
fitnessEvaluationStrategy,
new Configuration());
differentialEvolution.Run();
crossoverMock.Verify(c => c.Cross(It.IsAny <Individual>(), It.IsAny <Individual>()), Times.Exactly(15));
}
public void GivenADifferentialEvolutionAlgorithm_WhenTheAlgorithmIsRun_ItShouldResultInAPopulationWithAtLeastOneIndividual()
{
Mock <IFitnessEvaluationStrategy> fitnessEvaluationMock = new Mock <IFitnessEvaluationStrategy>();
IFitnessEvaluationStrategy fitnessEvaluationStrategy = fitnessEvaluationMock.Object;
Mock <ICrossoverStrategy> crossoverMock = new Mock <ICrossoverStrategy>();
crossoverMock.Setup(x => x.Cross(It.IsAny <Individual>(), It.IsAny <Individual>()))
.Returns(new Individual(fitnessEvaluationStrategy, new Configuration()));
ICrossoverStrategy crossoverStrategy = crossoverMock.Object;
Mock <IMutationStrategy> mutationMock = new Mock <IMutationStrategy>();
IMutationStrategy mutationStrategy = mutationMock.Object;
Mock <ISelectionStrategy> selectionMock = new Mock <ISelectionStrategy>();
selectionMock.Setup(x => x.Select(It.IsAny <List <Individual> >()))
.Returns(new Individual(fitnessEvaluationStrategy, new Configuration()));
ISelectionStrategy selectionStrategy = selectionMock.Object;
DifferentialEvolution differentialEvolution = new DifferentialEvolution(mutationStrategy,
crossoverStrategy,
selectionStrategy,
selectionStrategy,
fitnessEvaluationStrategy,
new Configuration());
differentialEvolution.Run();
Assert.IsTrue(differentialEvolution.population.Count > 0);
}
private void MostLikelyToChooseBestChromosome(ISelectionStrategy selection, double chromosome1Probability, double chromosome2Probability, double chromosome3Probability)
{
selection.SetPopulation(population, runs);
int chromosome1Counter = 0, chromosome2Counter = 0, chromosome3Counter = 0;
for (int i = 0; i < runs; i++)
{
var chromosome = selection.SelectChromosome();
if (chromosome.Evaluate() == SelectionStrategyTests.chromosome1Probability * 2)
{
chromosome1Counter++;
}
if (chromosome.Evaluate() == SelectionStrategyTests.chromosome2Probability * 2)
{
chromosome2Counter++;
}
if (chromosome.Evaluate() == SelectionStrategyTests.chromosome3Probability * 2)
{
chromosome3Counter++;
}
}
AssertIsWithinRange(chromosome1Counter, chromosome1Probability, runs, "Chromosome1");
AssertIsWithinRange(chromosome2Counter, chromosome2Probability, runs, "Chromosome2");
AssertIsWithinRange(chromosome3Counter, chromosome3Probability, runs, "Chromosome3");
}
public void GivenAPopulationOfThree_WhenANewPopulationIsRetrieved_ItShouldCallTheEvaluateMethodThreeTimes()
{
Mock <IFitnessEvaluationStrategy> fitnessEvaluationMock = new Mock <IFitnessEvaluationStrategy>();
IFitnessEvaluationStrategy fitnessEvaluationStrategy = fitnessEvaluationMock.Object;
Mock <ICrossoverStrategy> crossoverMock = new Mock <ICrossoverStrategy>();
crossoverMock.Setup(x => x.Cross(It.IsAny <Individual>(), It.IsAny <Individual>()))
.Returns(new Individual(fitnessEvaluationStrategy, new Configuration()));
ICrossoverStrategy crossoverStrategy = crossoverMock.Object;
Mock <IMutationStrategy> mutationMock = new Mock <IMutationStrategy>();
IMutationStrategy mutationStrategy = mutationMock.Object;
Mock <ISelectionStrategy> selectionMock = new Mock <ISelectionStrategy>();
ISelectionStrategy selectionStrategy = selectionMock.Object;
DifferentialEvolution differentialEvolution = new DifferentialEvolution(mutationStrategy,
crossoverStrategy,
selectionStrategy,
selectionStrategy,
fitnessEvaluationStrategy,
new Configuration());
differentialEvolution.population = new List <Individual>
{
new Individual(fitnessEvaluationStrategy, new Configuration()),
new Individual(fitnessEvaluationStrategy, new Configuration()),
new Individual(fitnessEvaluationStrategy, new Configuration())
};
differentialEvolution.GetNewPopulation();
fitnessEvaluationMock.Verify(c => c.GetFitnessForIndividual(It.IsAny <Individual>()), Times.Exactly(3 * 2));
}
static void Main(string[] args)
{
ILabellingJobRepository jobRepo = new LabellingJobRepositoryFactory().Create();
IJobIterationRepository iterationRepo = new JobIterationRepositoryFactory().Create();
IDataStore dataStore = new DataStoreFactory().CreateOrReplace("TestJack", DataFormats.CIFAR10.GetFormat());
IPredictiveModelFactory modelFactory = new PredictiveModelFactory();
Dictionary <string, string> modelParameters = new Dictionary <string, string>();
modelParameters.Add("k", "15");
modelParameters.Add("numberOfClasses", "10");
IPredictiveModel model = modelFactory.Create("KNearestNeighbour", modelParameters);
ISelectionStrategyFactory ssFactory = new SelectionStrategyFactory();
Dictionary <string, string> ssParameters = new Dictionary <string, string>();
ssParameters.Add("diversityFunction", DiversityFunctions.COSINE_DISTANCE.ToString());
ISelectionStrategy selectionStrategy = ssFactory.Create("DiversitySelectionStrategy", ssParameters);
IStoppingCriterionFactory scFactory = new StoppingCriterionFactory();
Dictionary <string, string> scParameters = new Dictionary <string, string>();
scParameters.Add("maxLabels", "15");
IStoppingCriterion stoppingCriterion = scFactory.Create("LabelLimit", scParameters);
ISeedingStrategyFactory seedingFactory = new SeedingStrategyFactory();
Dictionary <string, string> seedingParameters = new Dictionary <string, string>();
seedingParameters.Add("randomSeed", "15");
ISeedingStrategy seedingStrategy = seedingFactory.Create("RandomSeedingStrategy", seedingParameters);
IJobIterationNotifier notifier = new JobIterationNotifierFactory().Create();
IDataFormat dataFormat = DataFormats.CIFAR10.GetFormat();
}
public TestGeneticAlgorithm(
double mutationProbability,
double crossoverPropability,
int minPopulationSize,
int maxPopulationSize,
IMutation mutationOperator,
ICrossover crossoverOperator,
IFitnessEvaluator <TestWorkload> fitnessEvaluator,
IInitialPopulationCreator initialPopulationCreator,
ITerminationCondition <TestState> terminationCondition,
ISelectionStrategy selectionStrategy,
IReinsertionStrategy reinsertionStrategy,
IDeploymentChromosomeFactory chromosomeFactory,
TestState currentState,
TestWorkload workload,
IRandomProvider randomProvider)
: base(
mutationProbability,
crossoverPropability,
minPopulationSize,
maxPopulationSize,
mutationOperator,
crossoverOperator,
fitnessEvaluator,
initialPopulationCreator,
terminationCondition,
selectionStrategy,
reinsertionStrategy,
chromosomeFactory,
currentState,
workload,
randomProvider)
{
}
protected override IEnumerable <IStrategy> GetStrategies()
{
var generations = new[] { 50, 100, 150, 200 };
var populations = new[] { 10, 20, 30, 50 };
var mutationProbabilities = new[] { 1 };
var crossStrategies = new ICrossStrategy[] { new DoubleCrossStrategy() };
var selectionStrategies = new ISelectionStrategy[]
{
new TournamentSelectionStrategy(5, 5, 5, new RatioCorrectionStrategy()),
new TournamentSelectionStrategy(10, 5, 5, new RatioCorrectionStrategy()),
new FitnessSelectionStrategy(5, 5, new RatioCorrectionStrategy()),
new RankingSelectionStrategy(5, 5, new RatioCorrectionStrategy()),
};
foreach (var generation in generations)
{
foreach (var population in populations)
{
foreach (var mutationProbability in mutationProbabilities)
{
foreach (var crossStrategy in crossStrategies)
{
foreach (var selectionStrategy in selectionStrategies)
{
yield return(new GeneticStrategy(generation, population, mutationProbability, 50, crossStrategy,
selectionStrategy));
}
}
}
}
}
}
public SelectionStrategyType ProvideMappingType(ISelectionStrategy strategy)
{
if (strategy is RouletteStrategy)
{
return(SelectionStrategyType.RouletteStrategy);
}
return(SelectionStrategyType.None);
}
public BuildMonkey(IProjectRepository projectRepository, ISelectionStrategy<Project> projectSelectionStrategy,
ISelectionStrategy<BuildType> buildTypeSelectionStrategy, IBuildTypeRunner buildTypeRunner, ILog logger)
{
_projectRepository = projectRepository;
_projectSelectionStrategy = projectSelectionStrategy;
_buildTypeSelectionStrategy = buildTypeSelectionStrategy;
_buildTypeRunner = buildTypeRunner;
_logger = logger;
}
public void SetUp()
{
_projectRepository = A.Fake<IProjectRepository>();
_projectSelectionStrategy = A.Fake<ISelectionStrategy<Project>>();
_buildTypeSelectionStrategy = A.Fake<ISelectionStrategy<BuildType>>();
_buildTypeRunner = A.Fake<IBuildTypeRunner>();
var logger = A.Fake<ILog>();
_buildMonkey = new BuildMonkey(_projectRepository, _projectSelectionStrategy, _buildTypeSelectionStrategy, _buildTypeRunner, logger);
}
public GeneticStrategy(int generationCount, int populationSize, int mutationProbability,
int crossoverProbability, ICrossStrategy crossStrategy, ISelectionStrategy selectionStrategy)
{
Generations = generationCount;
PopulationSize = populationSize;
MutationProbability = mutationProbability;
CrossoverProbability = crossoverProbability;
CrossStrategy = crossStrategy;
SelectionStrategy = selectionStrategy;
}
private void AssertSelectionStrategyUsesLatestPopulation(ISelectionStrategy selectionStrategy)
{
selectionStrategy.SetPopulation(population, runs);
selectionStrategy.SetPopulation(new Population(new double[] { 2, 2, 2 }.ToChromosomes()), runs);
for (int i = 0; i < runs; i++)
{
var chromosome = selectionStrategy.SelectChromosome();
Assert.AreEqual(2, chromosome.Evaluate(), "Got wrong chromosome");
}
}
public void given_one_in_target_pool_returns_one_target()
{
Collider[] targetPool = new Collider[1];
ISelectionStrategy selectionStrategy = Substitute.For <ISelectionStrategy>();
selectionStrategy.GetTargets().Returns(targetPool);
MouseOverSelector selector = new MouseOverSelector(selectionStrategy, 1);
var selectedTargets = selector.GetAllTargets();
Assert.AreEqual(1, selectedTargets.Length);
}
public void given_no_available_targets_returns_zero_targets()
{
Collider[] availableTargets = new Collider[0];
ISelectionStrategy selectionStrategy = Substitute.For <ISelectionStrategy>();
selectionStrategy.GetTargets().Returns(availableTargets);
MouseOverSelector selector = new MouseOverSelector(selectionStrategy, 1);
var selectedTargets = selector.GetAllTargets();
Assert.AreEqual(0, selectedTargets.Length);
}
private void Form1_Load(object sender, EventArgs e)
{
pictureBox1.InitialImage = null;
previewPanel.AutoScroll = true;
mainScene = new Scene(pictureBox1.Width, pictureBox1.Height, previewPanel);
Image image1 = Image.FromFile("D:\\DATA\\Programming\\Grafika\\Grafika2\\Image1.jpg");
mainScene.AddSegment(new Segment(image1, new Point(0, 0)));
pictureBox1.Image = mainScene.GetSceneImage();
selectionStrategy = new RectangleSelection(mainScene);
RefreshPreviewPanel();
}
public Evolution(IInitalise initalise, ISelectionStrategy selectionStrategy, ICrossover crossoverStratergy, ISwap swap, TerminateStrategy terminate, IStepFunction stepFunction, uint populationSize, float eliteism, float mutationRate, string name = "Evolution Search")
{
this.InitalisationStrategy = initalise;
this.selectionStrategy = selectionStrategy;
this.crossoverStratergy = crossoverStratergy;
this.step = stepFunction;
this.swap = swap;
this.terminateStrategy = terminate;
this.name = name;
this.eliteism = eliteism;
this.mutationRate = mutationRate;
population = new Route[populationSize];
}
/// <summary>
/// Creates setup of genetic operators for <see cref="T:Localwire.Graphinder.Algorithms.Core.Algorithms.GeneticAlgorithm.GenetichAlgorithm"/>
/// </summary>
/// <param name="selectionStrategy">Selection strategy</param>
/// <param name="crossoverStrategy">Crossover strategy</param>
/// <param name="mutationStrategy">Mutation strategy</param>
public GeneticOperators(ISelectionStrategy selectionStrategy,
ICrossoverStrategy crossoverStrategy, IMutationStrategy mutationStrategy)
{
if (selectionStrategy == null)
throw new ArgumentNullException(nameof(selectionStrategy));
if (crossoverStrategy == null)
throw new ArgumentNullException(nameof(crossoverStrategy));
if (mutationStrategy == null)
throw new ArgumentNullException(nameof(mutationStrategy));
SelectionStrategy = selectionStrategy;
MutationStrategy = mutationStrategy;
CrossoverStrategy = crossoverStrategy;
}
public static async Task <LabellingJob> RunCreateJobTest()
{
ILabellingJobRepository jobRepo = new LabellingJobRepositoryFactory().Create();
IJobIterationRepository iterationRepo = new JobIterationRepositoryFactory().Create();
IDataParser parser = new DataParserFactory().Create(DataFormats.CIFAR10);
IDataFormat dataFormat = parser.Format;
IDataStore dataStore = new DataStoreFactory().CreateOrConnect("TestJack", dataFormat);
IPredictiveModelFactory modelFactory = new PredictiveModelFactory();
IPredictiveModel model = modelFactory.Create("LinearRegression");
ISelectionStrategyFactory ssFactory = new SelectionStrategyFactory();
Dictionary <string, string> ssParameters = new Dictionary <string, string>();
ssParameters.Add("randomSeed", "15");
ISelectionStrategy selectionStrategy = ssFactory.Create("RandomSelectionStrategy", ssParameters);
IStoppingCriterionFactory scFactory = new StoppingCriterionFactory();
Dictionary <string, string> scParameters = new Dictionary <string, string>();
scParameters.Add("maxLabels", "15");
IStoppingCriterion stoppingCriterion = scFactory.Create("LabelLimit", scParameters);
ISeedingStrategyFactory seedingFactory = new SeedingStrategyFactory();
Dictionary <string, string> seedingParameters = new Dictionary <string, string>();
seedingParameters.Add("randomSeed", "15");
ISeedingStrategy seedingStrategy = seedingFactory.Create("RandomSeedingStrategy", seedingParameters);
IJobIterationNotifier notifier = new JobIterationNotifierFactory().Create();
int batchSize = 3;
int seedSize = 3;
var job = await ActiveLoop.CreateLabellingJob(
jobRepo : jobRepo,
iterationRepo : iterationRepo,
dataStore : dataStore,
model : model,
selectionStrategy : selectionStrategy,
stoppingCriterion : stoppingCriterion,
seedingStrategy : seedingStrategy,
notifier : notifier,
dataFormat : dataFormat,
batchSize : batchSize,
seedSize : seedSize);
return(job);
}
public void GivenAPopulationOfTwo_WhenANewPopulationIsRetrieved_ItShouldReturnTheExpectedPopulationOfTwo()
{
Mock <IFitnessEvaluationStrategy> fitnessEvaluationMock = new Mock <IFitnessEvaluationStrategy>();
IFitnessEvaluationStrategy fitnessEvaluationStrategy = fitnessEvaluationMock.Object;
Individual individual1 = new Individual(fitnessEvaluationStrategy, new Configuration());
Individual child1 = new Individual(fitnessEvaluationStrategy, new Configuration());
Individual individual2 = new Individual(fitnessEvaluationStrategy, new Configuration());
Individual child2 = new Individual(fitnessEvaluationStrategy, new Configuration());
Mock <ICrossoverStrategy> crossoverMock = new Mock <ICrossoverStrategy>();
crossoverMock.Setup(x => x.Cross(It.IsAny <Individual>(), It.IsAny <Individual>()))
.Returns(new Individual(fitnessEvaluationStrategy, new Configuration()));
ICrossoverStrategy crossoverStrategy = crossoverMock.Object;
Mock <IMutationStrategy> mutationMock = new Mock <IMutationStrategy>();
IMutationStrategy mutationStrategy = mutationMock.Object;
Mock <ISelectionStrategy> selectionMock = new Mock <ISelectionStrategy>();
selectionMock.SetupSequence(x => x.Select(It.IsAny <List <Individual> >())).Returns(child1)
.Returns(individual2);
ISelectionStrategy selectionStrategy = selectionMock.Object;
Mock <ISelectionStrategy> otherSelectionMock = new Mock <ISelectionStrategy>();
ISelectionStrategy otherSelectionStrategy = otherSelectionMock.Object;
DifferentialEvolution differentialEvolution = new DifferentialEvolution(mutationStrategy,
crossoverStrategy,
selectionStrategy,
otherSelectionStrategy,
fitnessEvaluationStrategy,
new Configuration());
differentialEvolution.population = new List <Individual>
{
individual1, individual2
};
List <Individual> newPopulation = differentialEvolution.GetNewPopulation();
Assert.AreEqual(2, newPopulation.Count);
Assert.IsTrue(newPopulation.Contains(child1));
Assert.IsTrue(newPopulation.Contains(individual2));
Assert.IsFalse(newPopulation.Contains(child2));
Assert.IsFalse(newPopulation.Contains(individual1));
}
public MultiQueueHead(IModel model, string name, Guid guid, ArrayList queues, ISelectionStrategy selStrategy) // TODO: Want to add/remove queues eventually, and use an IQueueSelectionStrategy.
{
m_selStrategy = selStrategy;
selStrategy.Candidates = queues;
m_input = new SimpleInputPort(model, name, guid, this, new DataArrivalHandler(OnDataPushIn));
Outputs = new IOutputPort[queues.Count];
for (int i = 0; i < Outputs.GetLength(0); i++)
{
string portName = name + "#" + i;
Outputs[i] = new SimpleOutputPort(model, portName, Guid.NewGuid(), this, new DataProvisionHandler(OnDataPullOut), null);
ConnectorFactory.Connect(Outputs[i], ((Queue)queues[i]).Input);
}
}
public DifferentialEvolution(IMutationStrategy mutationStrategy,
ICrossoverStrategy crossoverStrategy,
ISelectionStrategy generationSelectionStrategy,
ISelectionStrategy differenceIndividualSelectionStrategy,
IFitnessEvaluationStrategy fitnessEvaluationStrategy,
IConfiguration configuration
)
{
this.mutationStrategy = mutationStrategy;
this.crossoverStrategy = crossoverStrategy;
this.generationSelectionStrategy = generationSelectionStrategy;
this.differenceIndividualSelectionStrategy = differenceIndividualSelectionStrategy;
this.fitnessEvaluationStrategy = fitnessEvaluationStrategy;
this.configuration = configuration;
}
public Evolution(IRandomNumberGenerator random,
IChromosomeFactory chromosomeFactory,
IPopulationStrategy populationStrategy,
IMutationStrategy mutationStrategy,
ICrossoverStrategy crossoverStrategy,
ISelectionStrategy selectionStrategy)
{
// TODO: Complete member initialization
this.random = random;
this.chromosomeFactory = chromosomeFactory;
this.populationStrategy = populationStrategy;
this.mutationStrategy = mutationStrategy;
this.crossoverStrategy = crossoverStrategy;
this.selectionStrategy = selectionStrategy;
}
public Individual <double>[] Apply(ISelectionStrategy <double> selection, Individual <double>[] population, int offspringsCount)
{
// Select the necessary parents
var parentGroups = selection.Apply(population, offspringsCount, 2);
// Create the offsprings
var offsprings = new Individual <double> [offspringsCount];
for (int i = 0; i < offspringsCount; ++i)
{
var parent0 = parentGroups[i][0];
var parent1 = parentGroups[i][1];
offsprings[i] = new Individual <double>(Blend(parent0.Chromosome, parent1.Chromosome));
}
return(offsprings);
}
private void OnUnLoaded(object sender, RoutedEventArgs e)
{
if (inputEventRouter != null)
{
inputEventRouter.Dispose();
inputEventRouter = null;
}
if (dragNDropController != null)
{
dragNDropController.Dispose();
dragNDropController = null;
}
Selection = null;
}
public void GivenAPopulationOfFour_WhenANewPopulationIsRetrieved_ItShouldCallTheMutationStrategyWithThreeDifferentIndividuals()
{
Mock <IFitnessEvaluationStrategy> fitnessEvaluationMock = new Mock <IFitnessEvaluationStrategy>();
IFitnessEvaluationStrategy fitnessEvaluationStrategy = fitnessEvaluationMock.Object;
Mock <ICrossoverStrategy> crossoverMock = new Mock <ICrossoverStrategy>();
crossoverMock.Setup(x => x.Cross(It.IsAny <Individual>(), It.IsAny <Individual>()))
.Returns(new Individual(fitnessEvaluationStrategy, new Configuration()));
ICrossoverStrategy crossoverStrategy = crossoverMock.Object;
Mock <IMutationStrategy> mutationMock = new Mock <IMutationStrategy>();
IMutationStrategy mutationStrategy = mutationMock.Object;
Individual individual = new Individual(fitnessEvaluationStrategy, new Configuration());
Individual target = new Individual(fitnessEvaluationStrategy, new Configuration());
Individual difference1 = new Individual(fitnessEvaluationStrategy, new Configuration());
Individual difference2 = new Individual(fitnessEvaluationStrategy, new Configuration());
Mock <ISelectionStrategy> selectionMock = new Mock <ISelectionStrategy>();
selectionMock.SetupSequence(x => x.Select(It.IsAny <List <Individual> >())).Returns(target)
.Returns(difference1)
.Returns(difference2);
ISelectionStrategy selectionStrategy = selectionMock.Object;
DifferentialEvolution differentialEvolution = new DifferentialEvolution(mutationStrategy,
crossoverStrategy,
selectionStrategy,
selectionStrategy,
fitnessEvaluationStrategy,
new Configuration());
differentialEvolution.population = new List <Individual>
{
individual, target, difference1, difference2
};
differentialEvolution.GetNewPopulation();
mutationMock.Verify(c => c.GetTrialVector(target, new List <Individual>()
{
difference1, difference2
}), Times.Once());
}
public void Run_Once_CallsRightMethods()
{
var deploymentModel = CreateDeploymentModel();
A.CallTo(() => _terminationCondition.HasReached(null, null)).WithAnyArguments().ReturnsNextFromSequence(false, true);
_deploymentChromosomeFactory = new DeploymentChromosomeFactory();
_initialPopulationCreator = new CloneInitialPopulationCreator();
_selectionStrategy = new EliteSelection();
_crossoverOperator = new IdCrossover();
_mutationOperator = new IdMutation();
_reinsertionStrategy = new EliteReinsertion();
ConstructGeneticAlgorithm();
var bestDeploymentModel = _testGeneticAlgorithm.Run(deploymentModel);
Assert.AreEqual(1, _currentState.Count);
}
public void SetUp()
{
_mutationProbability = 1;
_crossoverProbability = 1;
_minPopulationSize = 2;
_maxPopulationSize = 4;
_mutationOperator = A.Fake <IMutation>();
_crossoverOperator = A.Fake <ICrossover>();
_fitnessEvaluator = A.Fake <IFitnessEvaluator <TestWorkload> >();
_initialPopulationCreator = A.Fake <IInitialPopulationCreator>();
_terminationCondition = A.Fake <ITerminationCondition <TestState> >();
_selectionStrategy = A.Fake <ISelectionStrategy>();
_reinsertionStrategy = A.Fake <IReinsertionStrategy>();
_deploymentChromosomeFactory = A.Fake <IDeploymentChromosomeFactory>();
_currentState = new TestState();
_workload = new TestWorkload();
_randomProvider = new DefaultRandomProvider();
}
private void OnLoaded(object sender, RoutedEventArgs e)
{
var autoScroller = new AutoScroller();
dragNDropController = new DragNDropController(autoScroller);
var selectionMultiple = new SelectionMultiple(this);
Selection = selectionMultiple;
IsEditingManager = new IsEditingManager(this);
inputEventRouter = new InputEventRouter(this);
inputEventRouter.Add(IsEditingManager);
inputEventRouter.Add(autoScroller);
inputEventRouter.Add(dragNDropController);
inputEventRouter.Add(selectionMultiple.BorderSelectionLogic);
inputEventRouter.Add(selectionMultiple);
isInitialized = true;
}
private void cbSelection_Unchecked(object sender, RoutedEventArgs e)
{
selection = just_elites;
}
public SelectionStrategyType ProvideMappingType(ISelectionStrategy strategy)
{
if (strategy is RouletteStrategy)
return SelectionStrategyType.RouletteStrategy;
return SelectionStrategyType.None;
}
public SelectionFacade(ISelectionStrategy ss, IFitnessStrategy fs)
{
this._selectionMechanism = ss;
this._fitnessMechanism = fs;
}
//private void tbMut_TextChanged(object sender, TextChangedEventArgs e)
//{
// double old = mutation_chance;
// try
// {
// mutation_chance = double.Parse(tbMut.Text);
// if (mutation_chance < 0.0 || mutation_chance > 1.0)
// throw new Exception();
// tbMut.Text = mutation_chance.ToString();
// }
// catch (Exception)
// {
// mutation_chance = old;
// MessageBox.Show("Mutation chance musi byt z intervalu <0,1>");
// tbMut.Text = mutation_chance.ToString();
// }
//}
//private void tbEli_TextChanged(object sender, TextChangedEventArgs e)
//{
// double old = elite_rate;
// try
// {
// elite_rate = double.Parse(tbEli.Text);
// if (elite_rate < 0.0 || elite_rate > 1.0)
// throw new Exception();
// tbEli.Text = elite_rate.ToString();
// }
// catch (Exception)
// {
// //runtime =
// elite_rate = old;
// MessageBox.Show("Elite rate musi byt z intervalu <0,1>");
// tbEli.Text = elite_rate.ToString();
// }
//}
private void cbSelection_Checked(object sender, RoutedEventArgs e)
{
selection = tournament;
}
private void OnLoaded(object sender, RoutedEventArgs e)
{
var autoScroller = new AutoScroller();
dragNDropController = new DragNDropController(autoScroller);
var selectionMultiple = new SelectionMultiple(this);
Selection = selectionMultiple;
IsEditingManager = new IsEditingManager(this);
inputEventRouter = new InputEventRouter(this);
inputEventRouter.Add(IsEditingManager);
inputEventRouter.Add(autoScroller);
inputEventRouter.Add(dragNDropController);
inputEventRouter.Add(selectionMultiple.BorderSelectionLogic);
inputEventRouter.Add(selectionMultiple);
isInitialized = true;
}
private void OnUnLoaded(object sender, RoutedEventArgs e)
{
if (inputEventRouter != null)
{
inputEventRouter.Dispose();
inputEventRouter = null;
}
if (dragNDropController != null)
{
dragNDropController.Dispose();
dragNDropController = null;
}
Selection = null;
}
public void Selection(double percent_elites, ISelectionStrategy strategy, bool elitarism_on)
{
List<Monk> res = new List<Monk>();
if (elitarism_on)
{
res.AddRange(Elites(percent_elites));
}
res.AddRange(strategy.Selection(this));
Chromosomes.Clear();
Chromosomes.AddRange(res);
}
