예제 #1
0
        public async Task Metric_Calculate()
        {
            GeneticAlgorithm algorithm = new MockGeneticAlgorithm
            {
                MinimumEnvironmentSize = 2,
                GeneticEntitySeed      = new MockEntity(),
                FitnessEvaluator       = new MockFitnessEvaluator(),
                SelectionOperator      = new MockSelectionOperator(),
                PopulationSeed         = new MockPopulation()
            };

            algorithm.Metrics.Add(new FakeMetric());

            await algorithm.InitializeAsync();

            FakeMetric metric = (FakeMetric)algorithm.Metrics[0];

            metric.Calculate(algorithm.Environment, 1);

            Assert.Equal(4, metric.GetResultValueCallCount);

            ObservableCollection <MetricResult> results = metric.GetResults(0);

            Assert.Equal(2, results.Count);
            Assert.Equal(0, results[0].GenerationIndex);
            Assert.Equal(0, results[0].PopulationIndex);
            Assert.Equal(1, results[0].ResultValue);
            Assert.Same(metric, results[0].Metric);

            results = metric.GetResults(1);
            Assert.Equal(0, results[0].GenerationIndex);
            Assert.Equal(1, results[0].PopulationIndex);
            Assert.Equal(2, results[0].ResultValue);
            Assert.Same(metric, results[0].Metric);
        }
예제 #2
0
        public async Task SinglePointCrossoverOperator_Validation_IsFixedSize()
        {
            MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm
            {
                GeneticEntitySeed = new IntegerListEntity
                {
                    MinElementValue       = 0,
                    MaxElementValue       = 10,
                    MinimumStartingLength = 5,
                    MaximumStartingLength = 5,
                    IsFixedSize           = true
                },
                PopulationSeed    = new MockPopulation(),
                FitnessEvaluator  = new MockFitnessEvaluator2(),
                SelectionOperator = new MockSelectionOperator(),
                CrossoverOperator = new VariableSinglePointCrossoverOperator()
            };

            await Assert.ThrowsAsync <ValidationException>(() => algorithm.InitializeAsync());
        }
        public async Task UniformBitMutationOperator_Mutate()
        {
            MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm
            {
                PopulationSeed    = new MockPopulation(),
                SelectionOperator = new MockSelectionOperator(),
                FitnessEvaluator  = new MockFitnessEvaluator2(),
                GeneticEntitySeed = new BinaryStringEntity
                {
                    MinimumStartingLength = 4,
                    MaximumStartingLength = 4
                },
                MutationOperator = new UniformBitMutationOperator
                {
                    MutationRate = 1
                }
            };
            await algorithm.InitializeAsync();

            UniformBitMutationOperator op = new UniformBitMutationOperator {
                MutationRate = 1
            };

            op.Initialize(algorithm);
            BinaryStringEntity entity = new BinaryStringEntity {
                MinimumStartingLength = 4, MaximumStartingLength = 4
            };

            entity.Age = 10;
            entity.Initialize(algorithm);
            entity[0] = true;
            entity[1] = true;
            entity[2] = false;
            entity[3] = true;
            GeneticEntity mutant = op.Mutate(entity);

            Assert.Equal("0010", mutant.Representation);
            Assert.Equal(0, mutant.Age);
        }