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));
}
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);
}
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));
}
/// <inheritdoc />
protected override void InitializeContinuousOptimizer(
Population basePopulation,
IncumbentGenomeWrapper <TResult> currentIncumbent)
{
if (basePopulation == null)
{
throw new ArgumentNullException(nameof(basePopulation));
}
if (!basePopulation.GetCompetitiveIndividuals().Any())
{
throw new ArgumentOutOfRangeException(
nameof(basePopulation),
"Population must have competitive individuals.");
}
// Continue the parameter adaptation where we left off before, but re-initialize everything else.
// If the adaptation was restarted every time, we would need quite long phases to actually see the
// adaptation happening.
this._differentialEvolutionRunner = this.CreateDifferentialEvolutionRunner(
meanMutationFactor: this._differentialEvolutionRunner.MeanMutationFactor,
meanCrossoverRate: this._differentialEvolutionRunner.MeanCrossoverRate);
var initialPositions = this._informationFlow
.DetermineInitialPoints(basePopulation, currentIncumbent?.IncumbentGenome)
.ToList();
this._differentialEvolutionRunner.Initialize(
initialPositions,
this._strategyConfiguration.MaximumNumberGenerations);
LoggingHelper.WriteLine(
VerbosityLevel.Debug,
$"Tuning {initialPositions.First().Values.Count} continuous parameters.");
}
static void Main(string[] args)
{
IConfiguration configuration = new Configuration();
IMutationStrategy trialVectorMutationStrategy = new TrialIndividualMutationStrategy(configuration);
ICrossoverStrategy crossoverStrategy = new BinomialCrossoverStrategy(configuration);
ISelectionStrategy generationSelectionStrategy = new MinimisationElitistSelectionStrategy();
ISelectionStrategy differenceVectorSelectionStrategy = new RandomSelectionStrategy();
IFitnessEvaluationStrategy fitnessEvaluationStrategy = new RastriginFitnessEvaluationStrategy();
DifferentialEvolution differentialEvolution = new DifferentialEvolution(
trialVectorMutationStrategy,
crossoverStrategy,
generationSelectionStrategy,
differenceVectorSelectionStrategy,
fitnessEvaluationStrategy,
configuration
);
differentialEvolution.Run();
var population = differentialEvolution.population;
foreach (Individual individual in population)
{
foreach (double dimension in individual.Position)
{
Console.Write(Math.Round(dimension) + ", ");
}
Console.WriteLine();
}
Console.Read();
}
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)));
}
/// <summary>
/// Initializes a new instance of the <see cref="DifferentialEvolutionStrategy{TInstance, TResult}"/> class.
/// </summary>
/// <param name="configuration">Options used for this instance.</param>
/// <param name="parameterTree">Provides the tunable parameters.</param>
/// <param name="genomeBuilder">Responsible for creation, modification and crossover of genomes.
/// Needs to be compatible with the given parameter tree and configuration.</param>
/// <param name="genomeSorter">
/// An <see cref="IActorRef" /> to a <see cref="GenomeSorter{TInstance,TResult}" />.
/// </param>
/// <param name="targetRunResultStorage">
/// An <see cref="IActorRef" /> to a <see cref="ResultStorageActor{TInstance,TResult}" />
/// which knows about all executed target algorithm runs and their results.
/// </param>
public DifferentialEvolutionStrategy(
AlgorithmTunerConfiguration configuration,
ParameterTree parameterTree,
GenomeBuilder genomeBuilder,
IActorRef genomeSorter,
IActorRef targetRunResultStorage)
: base(configuration, parameterTree, targetRunResultStorage, new GenomeSearchPointSorter <TInstance>(genomeSorter))
{
this._strategyConfiguration =
this.Configuration.ExtractDetailedConfiguration <DifferentialEvolutionStrategyConfiguration>(
DifferentialEvolutionStrategyArgumentParser.Identifier);
if (this._strategyConfiguration.FocusOnIncumbent)
{
this._informationFlow = new LocalDifferentialEvolutionInformationFlow(
this._strategyConfiguration,
parameterTree,
genomeBuilder);
}
else
{
this._informationFlow = new GlobalDifferentialEvolutionInformationFlow(
this._strategyConfiguration,
parameterTree,
genomeBuilder);
}
this._searchPointFactory = (vector, parent) => new GenomeSearchPoint(vector, parent, genomeBuilder);
this._differentialEvolutionRunner = this.CreateDifferentialEvolutionRunner(
this._strategyConfiguration.DifferentialEvolutionConfiguration.InitialMeanMutationFactor,
this._strategyConfiguration.DifferentialEvolutionConfiguration.InitialMeanCrossoverRate);
}
public string Resolve(double [] coeffs, int degree)
{
TextToReturn = "";
Polynom polynom = ReadPolynom(coeffs, degree);
int numberOfRoots = polynom.GetDegree();
DifferentialEvolution alg = new DifferentialEvolution();
for (int i = 0; i < numberOfRoots; ++i)
{
alg.SetEquation(polynom);
double[] result = alg.ExecuteDifferential();
Console.WriteLine("Solutia {0} : {1} + i*{2}", i, Math.Round(result[0], 4), Math.Round(result[1], 4));
TextToReturn += string.Format("Solutia {0} : {1} + i*{2}\r\n", i, Math.Round(result[0], 4), Math.Round(result[1], 4));
if (i < numberOfRoots - 1)
{
polynom = polynom.SimplifyEquation(
new Complex(Math.Round(result[0], 5), Math.Round(result[1], 5))
);
}
}
return(TextToReturn);
}
public void GivenADifferentialEvolutionAlgorithm_WhenThePopulationIsInitialisedWithAPopulationSizeOfTen_ItShouldReturnAPopulationOfTenIndividuals()
{
DifferentialEvolution differentialEvolution = new DifferentialEvolution(null, null, null, null, null, new Configuration());
List <Individual> population = differentialEvolution.InitialisePopulation(10);
Assert.AreEqual(10, population.Count);
}
public void ShouldRun()
{
var engine = new DifferentialEvolution(2, 10, new double[] { 10, 10 }, new double[] { -10, -10 }, (double[] d) => { return(-Math.Abs((d[0] + d[1]) - 5)); }, (double f) => { return(f == 0); });
engine.RunUntilTargetReached();
Assert.True(engine.BestFitness == 0);
}
/// <summary>
/// Initializes a new instance of the <see cref="DifferentialEvolutionTest"/> class.
/// </summary>
public DifferentialEvolutionTest()
{
this._configuration = new DifferentialEvolutionConfiguration.DifferentialEvolutionConfigurationBuilder()
.SetBestPercentage(0.2)
.SetInitialMeanMutationFactor(0.5)
.SetInitialMeanCrossoverRate(0.5)
.SetLearningRate(0.1)
.BuildWithFallback(null);
this._runner =
new DifferentialEvolution <SearchPoint>(this._sorter, this._searchPointFactory, this._configuration);
Randomizer.Configure(0);
}
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 static void RunMain(string[] args)
{
CostFunction_RosenbrockSaddle f = new CostFunction_RosenbrockSaddle();
int maxIterations = 200;
DifferentialEvolution s = new DifferentialEvolution(f);
s.SolutionUpdated += (best_solution, step) =>
{
Console.WriteLine("Step {0}: Fitness = {1}", step, best_solution.Cost);
};
ContinuousSolution finalSolution = s.Minimize(f, maxIterations);
}
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 GivenAPopulationOfOne_WhenANewPopulationIsRetrieved_ItShouldCallTheSelectionStrategyWithTheIndividualAndTheChild()
{
Mock <IFitnessEvaluationStrategy> fitnessEvaluationMock = new Mock <IFitnessEvaluationStrategy>();
IFitnessEvaluationStrategy fitnessEvaluationStrategy = fitnessEvaluationMock.Object;
Individual individual = new Individual(fitnessEvaluationStrategy, new Configuration());
Individual child = new Individual(fitnessEvaluationStrategy, new Configuration());
Mock <ICrossoverStrategy> crossoverMock = new Mock <ICrossoverStrategy>();
crossoverMock.Setup(x => x.Cross(It.IsAny <Individual>(), It.IsAny <Individual>())).Returns(child);
ICrossoverStrategy crossoverStrategy = crossoverMock.Object;
Mock <IMutationStrategy> mutationMock = new Mock <IMutationStrategy>();
IMutationStrategy mutationStrategy = mutationMock.Object;
List <Individual> receivedIndividuals = new List <Individual>();
Mock <ISelectionStrategy> selectionMock = new Mock <ISelectionStrategy>();
selectionMock.Setup(x => x.Select(It.IsAny <List <Individual> >())).Callback((List <Individual> individualList) =>
receivedIndividuals = individualList
);
ISelectionStrategy selectionStrategy = selectionMock.Object;
DifferentialEvolution differentialEvolution = new DifferentialEvolution(mutationStrategy,
crossoverStrategy,
selectionStrategy,
selectionStrategy,
fitnessEvaluationStrategy,
new Configuration());
differentialEvolution.population = new List <Individual>
{
individual
};
differentialEvolution.GetNewPopulation();
Assert.AreEqual(2, receivedIndividuals.Count);
Assert.IsTrue(receivedIndividuals.Contains(individual));
Assert.IsTrue(receivedIndividuals.Contains(child));
}
public void GivenAPopulationOfThreeAndAnInvalidIndividual_WhenTheGettingTheDifferenceIndividual_ItShouldCallTheSelectionStrategyWithAPopulationExcludingTheInvalidIndividual()
{
Individual individual1 = new Individual(null, new Configuration())
{
Position = new double[] { 1.0, 2.0, 3.0 }
};
Individual individual2 = new Individual(null, new Configuration())
{
Position = new double[] { 2.0, 3.0, 4.0 }
};
Individual individual3 = new Individual(null, new Configuration())
{
Position = new double[] { 5.0, 6.0, 7.0 }
};
List <Individual> population = new List <Individual>
{
individual1, individual2, individual3
};
List <Individual> invalidIndividuals = new List <Individual>
{
individual2
};
List <Individual> resultingPopulation = new List <Individual>();
Mock <ISelectionStrategy> mock = new Mock <ISelectionStrategy>();
mock.Setup(c => c.Select(It.IsAny <List <Individual> >()))
.Callback((List <Individual> validPopulation) => resultingPopulation = validPopulation);
DifferentialEvolution differentialEvolution = new DifferentialEvolution(null, null, null,
mock.Object, null, new Configuration());
differentialEvolution.SelectDifferenceIndividual(population, invalidIndividuals);
Assert.AreEqual(2, resultingPopulation.Count);
Assert.IsFalse(resultingPopulation.Contains(individual2));
Assert.IsTrue(resultingPopulation.Contains(individual1));
Assert.IsTrue(resultingPopulation.Contains(individual3));
}
public void GivenAPopulationOfOne_WhenANewPopulationIsRetrieved_ItShouldCallTheCrossoverStrategyWithTheIndividualAndTheTrialIndividual()
{
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;
Individual individual = new Individual(fitnessEvaluationStrategy, new Configuration());
Individual mutant = new Individual(fitnessEvaluationStrategy, new Configuration());
Mock <IMutationStrategy> mutationMock = new Mock <IMutationStrategy>();
mutationMock.Setup(x => x.GetTrialVector(It.IsAny <Individual>(), It.IsAny <List <Individual> >()))
.Returns(mutant);
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>
{
individual
};
differentialEvolution.GetNewPopulation();
crossoverMock.Verify(c => c.Cross(individual, mutant), Times.Once());
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(DifferentialEvolution obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
public void testDifferentialEvolution()
{
//BOOST_TEST_MESSAGE("Testing differential evolution...");
/* Note:
*
* The "ModFourthDeJong" doesn't have a well defined optimum because
* of its noisy part. It just has to be <= 15 in our example.
* The concrete value might differ for a different input and
* different random numbers.
*
* The "Griewangk" function is an example where the adaptive
* version of DifferentialEvolution turns out to be more successful.
*/
DifferentialEvolution.Configuration conf =
new DifferentialEvolution.Configuration()
.withStepsizeWeight(0.4)
.withBounds()
.withCrossoverProbability(0.35)
.withPopulationMembers(500)
.withStrategy(DifferentialEvolution.Strategy.BestMemberWithJitter)
.withCrossoverType(DifferentialEvolution.CrossoverType.Normal)
.withAdaptiveCrossover()
.withSeed(3242);
DifferentialEvolution.Configuration conf2 =
new DifferentialEvolution.Configuration()
.withStepsizeWeight(1.8)
.withBounds()
.withCrossoverProbability(0.9)
.withPopulationMembers(1000)
.withStrategy(DifferentialEvolution.Strategy.Rand1SelfadaptiveWithRotation)
.withCrossoverType(DifferentialEvolution.CrossoverType.Normal)
.withAdaptiveCrossover()
.withSeed(3242);
DifferentialEvolution deOptim2 = new DifferentialEvolution(conf2);
List <DifferentialEvolution> diffEvolOptimisers = new List <DifferentialEvolution>();
diffEvolOptimisers.Add(new DifferentialEvolution(conf));
diffEvolOptimisers.Add(new DifferentialEvolution(conf));
diffEvolOptimisers.Add(new DifferentialEvolution(conf));
diffEvolOptimisers.Add(new DifferentialEvolution(conf));
diffEvolOptimisers.Add(deOptim2);
List <CostFunction> costFunctions = new List <CostFunction>();
costFunctions.Add(new FirstDeJong());
costFunctions.Add(new SecondDeJong());
costFunctions.Add(new ModThirdDeJong());
costFunctions.Add(new ModFourthDeJong());
costFunctions.Add(new Griewangk());
List <BoundaryConstraint> constraints = new List <BoundaryConstraint>();
constraints.Add(new BoundaryConstraint(-10.0, 10.0));
constraints.Add(new BoundaryConstraint(-10.0, 10.0));
constraints.Add(new BoundaryConstraint(-10.0, 10.0));
constraints.Add(new BoundaryConstraint(-10.0, 10.0));
constraints.Add(new BoundaryConstraint(-600.0, 600.0));
List <Vector> initialValues = new List <Vector>();
initialValues.Add(new Vector(3, 5.0));
initialValues.Add(new Vector(2, 5.0));
initialValues.Add(new Vector(5, 5.0));
initialValues.Add(new Vector(30, 5.0));
initialValues.Add(new Vector(10, 100.0));
List <EndCriteria> endCriteria = new List <EndCriteria>();
endCriteria.Add(new EndCriteria(100, 10, 1e-10, 1e-8, null));
endCriteria.Add(new EndCriteria(100, 10, 1e-10, 1e-8, null));
endCriteria.Add(new EndCriteria(100, 10, 1e-10, 1e-8, null));
endCriteria.Add(new EndCriteria(500, 100, 1e-10, 1e-8, null));
endCriteria.Add(new EndCriteria(1000, 800, 1e-12, 1e-10, null));
List <double> minima = new List <double>();
minima.Add(0.0);
minima.Add(0.0);
minima.Add(0.0);
minima.Add(10.9639796558);
minima.Add(0.0);
for (int i = 0; i < costFunctions.Count; ++i)
{
Problem problem = new Problem(costFunctions[i], constraints[i], initialValues[i]);
diffEvolOptimisers[i].minimize(problem, endCriteria[i]);
if (i != 3)
{
// stable
if (Math.Abs(problem.functionValue() - minima[i]) > 1e-8)
{
QAssert.Fail("costFunction # " + i
+ "\ncalculated: " + problem.functionValue()
+ "\nexpected: " + minima[i]);
}
}
else
{
// this case is unstable due to randomness; we're good as
// long as the result is below 15
if (problem.functionValue() > 15)
{
QAssert.Fail("costFunction # " + i
+ "\ncalculated: " + problem.functionValue()
+ "\nexpected: " + "less than 15");
}
}
}
}
