public void BinaryStringEntity_UseUniqueElementValues()
        {
            BinaryStringEntity entity = new BinaryStringEntity();

            Assert.False(entity.RequiresUniqueElementValues);
            Assert.Throws <NotSupportedException>(() => entity.RequiresUniqueElementValues = true);
        }
Beispiel #2
0
        public override Task <double> EvaluateFitnessAsync(GeneticEntity entity)
        {
            BinaryStringEntity binStrEntity = (BinaryStringEntity)entity;

            // The entity's fitness is equal to the number of "true" bits (a bit representing a 1 value)
            // it contains.
            return(Task.FromResult <double>(binStrEntity.Count(bit => bit == true)));
        }
        public void BinaryStringEntity_Uninitialized()
        {
            BinaryStringEntity entity = new BinaryStringEntity();

            Assert.Throws <InvalidOperationException>(() => { entity[0] = true; });
            Assert.Throws <InvalidOperationException>(() =>
            {
                BinaryStringEntity entity2 = new BinaryStringEntity();
                entity.CopyTo(entity2);
            });
        }
        public void BinaryStringEntity_Serialization()
        {
            BinaryStringEntity entity = new BinaryStringEntity();

            entity.MinimumStartingLength = entity.MaximumStartingLength = 3;
            entity.IsFixedSize           = true;
            entity.Initialize(new MockGeneticAlgorithm());

            BinaryStringEntity result = (BinaryStringEntity)SerializationHelper.TestSerialization(
                entity, new Type[] { typeof(MockGeneticAlgorithm), typeof(DefaultTerminator) });

            for (int i = 0; i < 3; i++)
            {
                Assert.Equal(entity[i], result[i]);
            }

            Assert.True(result.IsFixedSize);
        }
        public void BinaryStringEntity_SetLengthToExpand()
        {
            BinaryStringEntity entity = new BinaryStringEntity
            {
                MinimumStartingLength = 2,
                MaximumStartingLength = 2,
            };

            entity.Initialize(new MockGeneticAlgorithm());

            Assert.Equal(2, entity.Length);

            entity.Length = 4;
            Assert.Equal(4, entity.Length);

            Assert.False(entity[2]);
            Assert.False(entity[3]);
        }
        public void BinaryStringEntity_SetLengthToContract()
        {
            BinaryStringEntity entity = new BinaryStringEntity
            {
                MinimumStartingLength = 4,
                MaximumStartingLength = 4,
            };

            entity.Initialize(new MockGeneticAlgorithm());
            Assert.Equal(4, entity.Length);

            entity[0] = true;
            Assert.True(entity[0]);

            entity.Length = 1;
            Assert.Equal(1, entity.Length);

            Assert.True(entity[0]);
        }
        public void InversionOperator_Mutate()
        {
            GeneticAlgorithm algorithm = new MockGeneticAlgorithm
            {
                SelectionOperator = new MockSelectionOperator(),
                PopulationSeed    = new MockPopulation(),
                FitnessEvaluator  = new MockFitnessEvaluator(),
                GeneticEntitySeed = new BinaryStringEntity
                {
                    MinimumStartingLength = 4,
                    MaximumStartingLength = 4
                },
                MutationOperator = new InversionOperator
                {
                    MutationRate = 1
                }
            };

            algorithm.GeneticEntitySeed.Initialize(algorithm);

            InversionOperator op = (InversionOperator)algorithm.MutationOperator;

            op.Initialize(algorithm);
            BinaryStringEntity entity = (BinaryStringEntity)algorithm.GeneticEntitySeed.CreateNewAndInitialize();

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

            FakeRandomUtil randomUtil = new FakeRandomUtil();

            RandomNumberService.Instance = randomUtil;
            randomUtil.RandomValue       = 1;

            GeneticEntity mutant = op.Mutate(entity);

            Assert.Equal("1011", mutant.Representation);
            Assert.Equal(0, mutant.Age);
        }
Beispiel #8
0
        public override Task <double> EvaluateFitnessAsync(GeneticEntity entity)
        {
            BinaryStringEntity binaryEntity = (BinaryStringEntity)entity;

            int totalBitDiffs = 0;
            int minLength     = Math.Min(binaryEntity.Length, this.TargetBinary.Length);

            for (int i = 0; i < minLength; i++)
            {
                bool bitValue = this.TargetBinary[i] == '0' ? false : true;
                if (binaryEntity[i] != bitValue)
                {
                    totalBitDiffs++;
                }
            }

            // add the difference in size as part of the difference in bits
            totalBitDiffs += Math.Abs(binaryEntity.Length - this.TargetBinary.Length);

            return(Task.FromResult <double>(totalBitDiffs));
        }
        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);
        }
Beispiel #10
0
        public void ListStartingLengthValidator_IsValid()
        {
            ListStartingLengthValidator validator = new ListStartingLengthValidator();

            BinaryStringEntity entity = new BinaryStringEntity
            {
                MinimumStartingLength = 5,
                MaximumStartingLength = 6
            };

            bool result = validator.IsValid(entity, out string errorMessage);

            Assert.True(result);
            Assert.Null(errorMessage);

            entity = new BinaryStringEntity
            {
                MinimumStartingLength = 6,
                MaximumStartingLength = 5
            };
            result = validator.IsValid(entity, out errorMessage);
            Assert.False(result);
            Assert.NotNull(errorMessage);
        }
        protected override bool GenerateMutation(GeneticEntity entity)
        {
            bool isMutated = false;

            // In addition to the base mutation implementation, each bit has a
            // probability (equal to the mutation rate) of being removed.
            BinaryStringEntity binaryEntity = (BinaryStringEntity)entity;

            for (int i = binaryEntity.Length - 1; i >= 0; i--)
            {
                if (RandomNumberService.Instance.GetDouble() <= this.MutationRate)
                {
                    binaryEntity.RemoveAt(i);
                    isMutated = true;
                }
            }

            if (base.GenerateMutation(entity))
            {
                isMutated = true;
            }

            return(isMutated);
        }
        public void SinglePointCrossoverOperator_GenerateCrossover_DifferentLength()
        {
            MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm
            {
                PopulationSeed    = new MockPopulation(),
                SelectionOperator = new MockSelectionOperator(),
                FitnessEvaluator  = new MockFitnessEvaluator(),
                CrossoverOperator = new SinglePointCrossoverOperator
                {
                    CrossoverRate = 1
                },
                GeneticEntitySeed = new BinaryStringEntity
                {
                    MinimumStartingLength = 4,
                    MaximumStartingLength = 4
                }
            };

            algorithm.GeneticEntitySeed.Initialize(algorithm);

            SinglePointCrossoverOperator op = new SinglePointCrossoverOperator {
                CrossoverRate = 1
            };

            op.Initialize(algorithm);
            BinaryStringEntity entity1 = (BinaryStringEntity)algorithm.GeneticEntitySeed.CreateNewAndInitialize();

            entity1.Length = 5;
            entity1[0]     = true;
            entity1[1]     = false;
            entity1[2]     = false;
            entity1[3]     = true;
            entity1[4]     = true;

            BinaryStringEntity entity2 = (BinaryStringEntity)algorithm.GeneticEntitySeed.CreateNewAndInitialize();

            entity2.Initialize(algorithm);
            entity2[0] = true;
            entity2[1] = true;
            entity2[2] = false;
            entity2[3] = false;

            TestRandomUtil randomUtil = new TestRandomUtil();

            RandomNumberService.Instance = randomUtil;

            randomUtil.RandomVal = 1;
            IList <GeneticEntity> result = op.Crossover(new GeneticEntity[] { entity1, entity2 }).ToList();

            BinaryStringEntity resultEntity1 = (BinaryStringEntity)result[0];
            BinaryStringEntity resultEntity2 = (BinaryStringEntity)result[1];

            Assert.Equal("1100", resultEntity1.Representation);
            Assert.Equal("10011", resultEntity2.Representation);

            randomUtil.RandomVal = 3;
            result = op.Crossover(new GeneticEntity[] { entity1, entity2 }).ToList();

            resultEntity1 = (BinaryStringEntity)result[0];
            resultEntity2 = (BinaryStringEntity)result[1];

            Assert.Equal("1000", resultEntity1.Representation);
            Assert.Equal("11011", resultEntity2.Representation);
        }