예제 #1
0
        public void DefineCompetitivePopulationReturnsCurrentSearchPoints()
        {
            var originalCompetitives = new List <Genome>();

            for (int i = 0; i < 5; i++)
            {
                originalCompetitives.Add(this._genomeBuilder.CreateRandomGenome(age: i % 3));
            }

            var searchPoints = new List <GenomeSearchPoint>();

            for (int i = 0; i < 8; i++)
            {
                searchPoints.Add(
                    GenomeSearchPoint.CreateFromGenome(
                        this._genomeBuilder.CreateRandomGenome(age: 0),
                        this._parameterTree,
                        0,
                        this._genomeBuilder));
            }

            var informationFlowStrategy = new GlobalDifferentialEvolutionInformationFlow(
                this._deConfiguration,
                this._parameterTree,
                this._genomeBuilder);

            var competitiveIndividuals =
                informationFlowStrategy.DefineCompetitivePopulation(originalCompetitives, null, searchPoints);

            Assert.Equal(
                searchPoints.Select(point => point.Genome.ToString()).OrderBy(x => x).ToArray(),
                competitiveIndividuals.Select(genome => genome.ToString()).OrderBy(x => x).ToArray());
        }
예제 #2
0
 public void BaseRandomPointOnGenomeThrowsForMissingGenomeBuilder()
 {
     Assert.Throws <ArgumentNullException>(
         () => GenomeSearchPoint.BaseRandomPointOnGenome(
             this._genomeBuilder.CreateRandomGenome(age: 1),
             this._parameterTree,
             this._minimumDomainSize,
             genomeBuilder: null));
 }
예제 #3
0
 public void BaseRandomPointOnGenomeThrowsForMissingGenome()
 {
     Assert.Throws <ArgumentNullException>(
         () => GenomeSearchPoint.BaseRandomPointOnGenome(
             genome: null,
             parameterTree: this._parameterTree,
             minimumDomainSize: this._minimumDomainSize,
             genomeBuilder: this._genomeBuilder));
 }
예제 #4
0
        public void IsValidReturnsTrueForValidPoint()
        {
            var point = new GenomeSearchPoint(
                Vector <double> .Build.DenseOfArray(new[] { 1.2, 3.5, 0.3, 0.8 }),
                this._parent,
                this._genomeBuilder);

            Assert.True(point.IsValid(), $"{point} should be valid.");
        }
예제 #5
0
 public void CreateFromGenomeThrowsForMissingParameterTree()
 {
     Assert.Throws <ArgumentNullException>(
         () => GenomeSearchPoint.CreateFromGenome(
             this._genomeBuilder.CreateRandomGenome(age: 1),
             parameterTree: null,
             minimumDomainSize: this._minimumDomainSize,
             genomeBuilder: this._genomeBuilder));
 }
예제 #6
0
        public void IsValidChecksBoundaries()
        {
            var point = new GenomeSearchPoint(
                Vector <double> .Build.DenseOfArray(new[] { 1.2, 3.5, -24.3, 0.8 }),
                this._parent,
                this._genomeBuilder);

            Assert.False(point.IsValid(), $"{point} should not be valid.");
        }
예제 #7
0
        public void ToStringPrintsGenome()
        {
            var genome = this._genomeBuilder.CreateRandomGenome(age: 0);
            var point  = GenomeSearchPoint.CreateFromGenome(
                genome,
                this._parameterTree,
                this._minimumDomainSize,
                this._genomeBuilder);

            Assert.Equal(genome.ToString(), point.ToString());
        }
예제 #8
0
        /// <summary>
        /// Initializes a new instance of the <see cref="GenomeSearchPointTest"/> class.
        /// </summary>
        public GenomeSearchPointTest()
        {
            Randomizer.Configure();

            this._parameterTree = this.CreateParameterTree();
            this._genomeBuilder = new GenomeBuilder(
                this._parameterTree,
                new AlgorithmTunerConfiguration.AlgorithmTunerConfigurationBuilder().Build(1));
            this._parent = GenomeSearchPoint.CreateFromGenome(
                this._genomeBuilder.CreateRandomGenome(age: 1),
                this._parameterTree,
                this._minimumDomainSize,
                this._genomeBuilder);
        }
예제 #9
0
        public void GenomePropertyReversesCreateFromGenome()
        {
            var originalGenome = this._genomeBuilder.CreateRandomGenome(age: 2);
            var point          = GenomeSearchPoint.CreateFromGenome(
                originalGenome,
                this._parameterTree,
                this._minimumDomainSize,
                this._genomeBuilder);
            var createdGenome = point.Genome.CreateMutableGenome();

            Assert.True(
                new Genome.GeneValueComparator().Equals(originalGenome, createdGenome),
                $"{createdGenome} should have the same values as the genome it is based on, {originalGenome}.");
        }
예제 #10
0
        public void GenomeSearchPointMakesUseOfParent()
        {
            var point        = new GenomeSearchPoint(Vector <double> .Build.Dense(4), this._parent, this._genomeBuilder);
            var genome       = point.Genome.CreateMutableGenome();
            var parentGenome = this._parent.Genome.CreateMutableGenome();

            var fixedParameters = new[] { "b", "d", "aa" };

            foreach (var identifier in fixedParameters)
            {
                Assert.Equal(
                    parentGenome.GetGeneValue(identifier).GetValue(),
                    genome.GetGeneValue(identifier).GetValue());
            }
        }
        /// <summary>
        /// Creates <see cref="GenomeSearchPoint"/>s according to <see cref="GenomeBuilder"/>.
        /// </summary>
        /// <returns>The created <see cref="GenomeSearchPoint"/>s.</returns>
        private List <GenomeSearchPoint> CreateRandomSearchPoints()
        {
            var searchPoints = new List <GenomeSearchPoint>();

            for (int i = 0; i < 8; i++)
            {
                searchPoints.Add(
                    GenomeSearchPoint.CreateFromGenome(
                        this._genomeBuilder.CreateRandomGenome(age: 0),
                        this._parameterTree,
                        0,
                        this._genomeBuilder));
            }

            return(searchPoints);
        }
예제 #12
0
        public void GenomePropertyProducesIndependentGenome()
        {
            var genome = this._genomeBuilder.CreateRandomGenome(age: 0);
            var point  = GenomeSearchPoint.CreateFromGenome(
                genome,
                this._parameterTree,
                this._minimumDomainSize,
                this._genomeBuilder);

            genome.SetGene("a", new Allele <int>(234));

            var createdGenome = point.Genome.CreateMutableGenome();

            Assert.NotEqual(
                234,
                createdGenome.GetGeneValue("a").GetValue());
        }
예제 #13
0
        public void BaseRandomPointOnGenomeRandomlyChoosesContinuousValues()
        {
            var genome = this._genomeBuilder.CreateRandomGenome(age: 2);

            // Sample many points.
            int numberPoints = 1000;
            var valuesForLargeIntegerDomain = new Dictionary <int, int>();

            for (int i = 0; i < numberPoints; i++)
            {
                var point = GenomeSearchPoint.BaseRandomPointOnGenome(
                    genome,
                    this._parameterTree,
                    this._minimumDomainSize,
                    this._genomeBuilder);

                // Remember one of their values.
                var value = (int)point.Genome.CreateMutableGenome().GetGeneValue("a").GetValue();
                if (valuesForLargeIntegerDomain.ContainsKey(value))
                {
                    valuesForLargeIntegerDomain[value]++;
                }
                else
                {
                    valuesForLargeIntegerDomain.Add(value, 1);
                }
            }

            // Apply the Chi-Squared test on that gene.
            var numberPossibleGeneValues = (int)this._parameterTree.GetNumericalParameters()
                                           .Single(parameter => parameter.Identifier.Equals("a"))
                                           .Domain
                                           .DomainSize;

            double[] observed =
                valuesForLargeIntegerDomain.Select(keyValuePair => (double)keyValuePair.Value).ToArray();
            double[] expected = Enumerable.Range(0, numberPossibleGeneValues)
                                .Select(i => (double)numberPoints / numberPossibleGeneValues)
                                .ToArray();
            ChiSquareTest uniformTest = new ChiSquareTest(expected, observed, degreesOfFreedom: numberPossibleGeneValues - 1);

            Assert.False(
                uniformTest.Significant,
                $"BaseRandomPointOnGenome was found to not create uniform distributions by the Chi-Squared test test with significance level of {uniformTest.Size}.");
        }
예제 #14
0
        /// <summary>
        /// Called before every test case.
        /// </summary>
        protected override void InitializeDefault()
        {
            var parameterTree = this.GetDefaultParameterTree();
            var genomeBuilder = new GenomeBuilder(parameterTree, this.GetDefaultAlgorithmTunerConfiguration());

            this._originalIncumbent = genomeBuilder.CreateRandomGenome(age: 2);

            for (int i = 0; i < 5; i++)
            {
                var searchPoint = GenomeSearchPoint.CreateFromGenome(
                    genomeBuilder.CreateRandomGenome(age: 0),
                    parameterTree,
                    minimumDomainSize: 5,
                    genomeBuilder: genomeBuilder);
                this._mostRecentSorting.Add(searchPoint);
                this._currentEvaluationInstances.Add(new TestInstance(i.ToString()));
            }
        }
예제 #15
0
        public void BaseRandomPointOnGenomeFixesNonContinuousValues()
        {
            var genome = this._genomeBuilder.CreateRandomGenome(age: 2);
            var point  = GenomeSearchPoint.BaseRandomPointOnGenome(
                genome,
                this._parameterTree,
                this._minimumDomainSize,
                this._genomeBuilder);

            var nonContinuousIdentifiers = new[] { "b", "d", "aa" };

            foreach (var identifier in nonContinuousIdentifiers)
            {
                Assert.Equal(
                    genome.GetGeneValue(identifier).GetValue(),
                    point.Genome.CreateMutableGenome().GetGeneValue(identifier).GetValue());
            }
        }
예제 #16
0
        public void BaseRandomPointOnGenomeCopiesCorrectInformation()
        {
            var genome = this._genomeBuilder.CreateRandomGenome(age: 2);

            genome.IsEngineered = true;

            var point = GenomeSearchPoint.BaseRandomPointOnGenome(
                genome,
                this._parameterTree,
                this._minimumDomainSize,
                this._genomeBuilder);

            Assert.False(
                point.Genome.CreateMutableGenome().IsEngineered,
                "IsEngineered property should not be copied over.");
            // Age is only relevant for GGA. As points are not generated in GGA, the age should be fixed.
            Assert.Equal(
                genome.Age,
                point.Genome.CreateMutableGenome().Age);
        }
예제 #17
0
        public void GenomeSearchPointRoundsIntegerValues()
        {
            var point = new GenomeSearchPoint(
                Vector <double> .Build.DenseOfArray(new[] { 0.51, -3.2, -24.3, 12.8 }),
                this._parent,
                this._genomeBuilder);
            var genome = point.Genome.CreateMutableGenome();

            Assert.Equal(
                1,
                genome.GetGeneValue("a").GetValue());
            Assert.Equal(
                -3,
                genome.GetGeneValue("c").GetValue());
            Assert.Equal(
                -24.3,
                genome.GetGeneValue("e").GetValue());
            Assert.Equal(
                12.8,
                genome.GetGeneValue("f").GetValue());
        }
예제 #18
0
        public void IsValidChecksCustomGenomeBuilder()
        {
            var genome = this._genomeBuilder.CreateRandomGenome(age: 2);
            var point  = GenomeSearchPoint.CreateFromGenome(
                genome,
                this._parameterTree,
                this._minimumDomainSize,
                this._genomeBuilder);

            Assert.True(point.IsValid(), $"{point} should be valid.");

            var pointAsForbidden = GenomeSearchPoint.CreateFromGenome(
                genome,
                this._parameterTree,
                this._minimumDomainSize,
                new ConfigurableGenomeBuilder(this._parameterTree, isValidFunction: g => false, mutationRate: 0));

            Assert.False(
                pointAsForbidden.IsValid(),
                $"{pointAsForbidden} should not be valid for other genome builder.");
        }
예제 #19
0
        public void CreateFromGenomeExtractsCorrectValues()
        {
            var genome = this._genomeBuilder.CreateRandomGenome(age: 2);
            var point  = GenomeSearchPoint.CreateFromGenome(
                genome,
                this._parameterTree,
                this._minimumDomainSize,
                this._genomeBuilder);

            var continuousIdentifiers = new[] { "a", "c", "e", "f" };

            Assert.True(
                continuousIdentifiers.Length == point.Values.Count,
                $"There should be four continuous parameters: {TestUtils.PrintList(continuousIdentifiers)}.");
            for (int i = 0; i < continuousIdentifiers.Length; i++)
            {
                var identifier = continuousIdentifiers[i];
                Assert.Equal(
                    Convert.ToDouble(genome.GetGeneValue(identifier).GetValue()),
                    point.Values[i]);
            }
        }