Menu
▾
▴
Re: [cilib-devel] [PATCH 2/2] Always increment evaluations problem.
|
From: Gary P. <gpa...@gm...> - 2009-07-31 08:31:48
|
Chatted to Leo.
There are exceptions when it comes to dynamic environments. Positions that
have not changed that need to be re-evaluated based on an environment change
should not count as a fitness evaluation.
Will adjust the patch to cater for such situations.
On Friday 31 July 2009 09:56:20 Gary Pampara wrote:
> When the fitness is determined from the problem, the number of fitness
> evaluations must be incremented.
>
> Signed-off-by: Gary Pampara <gpa...@gm...>
> ---
> .../algorithm/MultistartOptimisationAlgorithm.java | 2 +-
> .../net/sourceforge/cilib/boa/bee/AbstractBee.java | 2 +-
> .../cilib/clustering/kmeans/KMeans.java | 6 +-
> .../cilib/cooperative/CooperativeEntity.java | 9 +--
> .../SelectiveContributionUpdateStrategy.java | 2 +-
> .../java/net/sourceforge/cilib/ec/Individual.java | 2 +-
> .../java/net/sourceforge/cilib/entity/Harmony.java | 2 +-
> .../criterion/CriterionBasedMOProblemAdapter.java | 2 +-
> .../ArchivingIterationStrategy.java | 4 +-
> .../foundation/NeuralNetworkProblem.java | 7 +-
> .../CooperativeOptimisationProblemAdapter.java | 2 +-
> .../net/sourceforge/cilib/problem/MOFitness.java | 8 +-
> .../cilib/problem/MOOptimisationProblem.java | 12 ++--
> .../cilib/problem/OptimisationProblem.java | 3 +-
> .../cilib/problem/OptimisationProblemAdapter.java | 6 +-
> .../cilib/pso/dynamic/DynamicParticle.java | 2 +-
> .../RandomSentryDetectionStrategy.java | 2 +-
> .../ArchiveReevaluationResponseStrategy.java | 4 +-
> ...lutionParticleReevaluationResponseStrategy.java | 2 +-
> .../DominantGuideUpdateStrategy.java | 4 +-
> .../cilib/pso/particle/MultiObjectiveParticle.java | 2 +-
> .../cilib/pso/particle/StandardParticle.java | 2 +-
> .../DEPositionUpdateStrategy.java | 4 +-
> .../GCVelocityUpdateStrategy.java | 2 +-
> .../calculator/EntityBasedFitnessCalculator.java | 6 +-
> .../cilib/util/calculator/FitnessCalculator.java | 4 +-
> .../calculator/PropertyBasedFitnessCalculator.java | 4 +-
> .../StructuredTypeFitnessCalculator.java | 4 +-
> .../crossover/BlendCrossoverStrategyTest.java | 2 +-
> .../crossover/OnePointCrossoverStrategyTest.java | 2 +-
> .../crossover/UniformCrossoverStrategyTest.java | 2 +-
> .../cilib/moo/archive/constrained/ArchiveTest.java | 74
> ++++++++++---------- .../constrained/ConstrainedArchiveTest.java |
> 4 +-
> .../solutionweighing/SolutionWeighingTest.java | 12 ++--
> .../sourceforge/cilib/problem/MOFitnessTest.java | 10 +--
> 35 files changed, 104 insertions(+), 113 deletions(-)
>
> diff --git
> a/src/main/java/net/sourceforge/cilib/algorithm/MultistartOptimisationAlgor
>ithm.java
> b/src/main/java/net/sourceforge/cilib/algorithm/MultistartOptimisationAlgor
>ithm.java index 0ed1bc5..8ef8f51 100644
> ---
> a/src/main/java/net/sourceforge/cilib/algorithm/MultistartOptimisationAlgor
>ithm.java +++
> b/src/main/java/net/sourceforge/cilib/algorithm/MultistartOptimisationAlgor
>ithm.java @@ -251,7 +251,7 @@ public class MultistartOptimisationAlgorithm
> extends Algorithm implements Partic * @see
> net.sourceforge.cilib.Problem.OptimisationProblemAdapter#calculateFitness(j
>ava.lang.Object) */
> protected Fitness calculateFitness(Type solution) {
> - return target.getFitness(solution, true);
> + return target.getFitness(solution);
> }
>
> public void resetFitnessCounter() {
> diff --git a/src/main/java/net/sourceforge/cilib/boa/bee/AbstractBee.java
> b/src/main/java/net/sourceforge/cilib/boa/bee/AbstractBee.java index
> ceea52b..2f4e1ab 100644
> --- a/src/main/java/net/sourceforge/cilib/boa/bee/AbstractBee.java
> +++ b/src/main/java/net/sourceforge/cilib/boa/bee/AbstractBee.java
> @@ -97,7 +97,7 @@ public abstract class AbstractBee extends AbstractEntity
> implements HoneyBee { */
> @Override
> public void calculateFitness() {
> - this.getProperties().put(EntityType.FITNESS,
> getFitnessCalculator().getFitness(this, true)); +
> this.getProperties().put(EntityType.FITNESS,
> getFitnessCalculator().getFitness(this)); }
>
> /**
> diff --git
> a/src/main/java/net/sourceforge/cilib/clustering/kmeans/KMeans.java
> b/src/main/java/net/sourceforge/cilib/clustering/kmeans/KMeans.java index
> d4fd66c..8f85a73 100644
> --- a/src/main/java/net/sourceforge/cilib/clustering/kmeans/KMeans.java
> +++ b/src/main/java/net/sourceforge/cilib/clustering/kmeans/KMeans.java
> @@ -73,7 +73,7 @@ public class KMeans extends SingularAlgorithm {
>
> /**
> * Create a copy of the provided instance.
> - * @param rhs The instance to copy.
> + * @param copy The instance to copy.
> */
> public KMeans(KMeans copy) {
> super(copy);
> @@ -105,7 +105,7 @@ public class KMeans extends SingularAlgorithm {
> */
> @Override
> public void algorithmIteration() {
> - calculator.getFitness(centroids, true);
> + calculator.getFitness(centroids);
>
> // the fitness calculation step already arranged the clusters and
> centroids for us ClusteringUtils helper = ClusteringUtils.get();
> @@ -163,7 +163,7 @@ public class KMeans extends SingularAlgorithm {
> */
> @Override
> public OptimisationSolution getBestSolution() {
> - return new OptimisationSolution(centroids.getClone(),
> getOptimisationProblem().getFitness(centroids, false)); + return new
> OptimisationSolution(centroids.getClone(),
> getOptimisationProblem().getFitness(centroids)); }
>
> /**
> diff --git
> a/src/main/java/net/sourceforge/cilib/cooperative/CooperativeEntity.java
> b/src/main/java/net/sourceforge/cilib/cooperative/CooperativeEntity.java
> index 4ae1f95..640c41d 100644
> ---
> a/src/main/java/net/sourceforge/cilib/cooperative/CooperativeEntity.java
> +++
> b/src/main/java/net/sourceforge/cilib/cooperative/CooperativeEntity.java @@
> -29,7 +29,6 @@ import net.sourceforge.cilib.problem.OptimisationProblem;
> import net.sourceforge.cilib.type.types.Numeric;
> import net.sourceforge.cilib.type.types.Type;
> import net.sourceforge.cilib.type.types.container.StructuredType;
> -import net.sourceforge.cilib.type.types.container.TypeList;
> import net.sourceforge.cilib.type.types.container.Vector;
>
> /**
> @@ -52,6 +51,7 @@ public class CooperativeEntity extends AbstractEntity {
> fitness = rhs.fitness;
> }
>
> + @Override
> public CooperativeEntity getClone() {
> return new CooperativeEntity(this);
> }
> @@ -137,11 +137,8 @@ public class CooperativeEntity extends AbstractEntity
> { throw new UnsupportedOperationException("Methd not implemented"); }
>
> + @Override
> public void calculateFitness() {
> - calculateFitness(true);
> - }
> -
> - public void calculateFitness(boolean count) {
> - fitness = getFitnessCalculator().getFitness(this, count);
> + fitness = getFitnessCalculator().getFitness(this);
> }
> }
> diff --git
> a/src/main/java/net/sourceforge/cilib/cooperative/contributionupdatestrateg
>ies/SelectiveContributionUpdateStrategy.java
> b/src/main/java/net/sourceforge/cilib/cooperative/contributionupdatestrateg
>ies/SelectiveContributionUpdateStrategy.java index 5452c99..ddf5bef 100644
> ---
> a/src/main/java/net/sourceforge/cilib/cooperative/contributionupdatestrateg
>ies/SelectiveContributionUpdateStrategy.java +++
> b/src/main/java/net/sourceforge/cilib/cooperative/contributionupdatestrateg
>ies/SelectiveContributionUpdateStrategy.java @@ -38,7 +38,7 @@ public class
> SelectiveContributionUpdateStrategy implements ContributionUpdateSt
> dstTest.update(src, srcPos, dstPos, length);
>
> // calculate new fitness of updated clone
> - dstTest.calculateFitness(false);
> + dstTest.calculateFitness();
>
> // if updated clone is better than original context, update
> context if(dstTest.compareTo(dst) > 0) {
> diff --git a/src/main/java/net/sourceforge/cilib/ec/Individual.java
> b/src/main/java/net/sourceforge/cilib/ec/Individual.java index
> c1ea82f..c6373e0 100644
> --- a/src/main/java/net/sourceforge/cilib/ec/Individual.java
> +++ b/src/main/java/net/sourceforge/cilib/ec/Individual.java
> @@ -145,7 +145,7 @@ public class Individual extends AbstractEntity {
> */
> @Override
> public void calculateFitness() {
> - this.getProperties().put(EntityType.FITNESS,
> this.getFitnessCalculator().getFitness(this, true)); +
> this.getProperties().put(EntityType.FITNESS,
> this.getFitnessCalculator().getFitness(this)); }
>
> /**
> diff --git a/src/main/java/net/sourceforge/cilib/entity/Harmony.java
> b/src/main/java/net/sourceforge/cilib/entity/Harmony.java index
> 85fe665..6b21457 100644
> --- a/src/main/java/net/sourceforge/cilib/entity/Harmony.java
> +++ b/src/main/java/net/sourceforge/cilib/entity/Harmony.java
> @@ -80,7 +80,7 @@ public class Harmony extends AbstractEntity {
> */
> @Override
> public void calculateFitness() {
> - Fitness fitness = getFitnessCalculator().getFitness(this, true);
> + Fitness fitness = getFitnessCalculator().getFitness(this);
> this.getProperties().put(EntityType.FITNESS, fitness);
> }
>
> diff --git
> a/src/main/java/net/sourceforge/cilib/moo/criterion/CriterionBasedMOProblem
>Adapter.java
> b/src/main/java/net/sourceforge/cilib/moo/criterion/CriterionBasedMOProblem
>Adapter.java index e2687c0..c0c23ff 100644
> ---
> a/src/main/java/net/sourceforge/cilib/moo/criterion/CriterionBasedMOProblem
>Adapter.java +++
> b/src/main/java/net/sourceforge/cilib/moo/criterion/CriterionBasedMOProblem
>Adapter.java @@ -83,7 +83,7 @@ public class CriterionBasedMOProblemAdapter
> extends OptimisationProblemAdapter {
>
> @Override
> protected Fitness calculateFitness(Type solution) {
> - return this.problem.getFitness(this.activeIndex, solution, true);
> + return this.problem.getFitness(this.activeIndex, solution);
> }
>
> @Override
> diff --git
> a/src/main/java/net/sourceforge/cilib/moo/iterationstrategies/ArchivingIter
>ationStrategy.java
> b/src/main/java/net/sourceforge/cilib/moo/iterationstrategies/ArchivingIter
>ationStrategy.java index f8e38ff..124747d 100644
> ---
> a/src/main/java/net/sourceforge/cilib/moo/iterationstrategies/ArchivingIter
>ationStrategy.java +++
> b/src/main/java/net/sourceforge/cilib/moo/iterationstrategies/ArchivingIter
>ationStrategy.java @@ -72,12 +72,12 @@ public class
> ArchivingIterationStrategy<E extends PopulationBasedAlgorithm> impl }
>
> protected void updateArchive(Topology<? extends Entity> population) {
> - Algorithm topLevelAlgorithm = (Algorithm)
> Algorithm.getAlgorithmList().get(0); + Algorithm topLevelAlgorithm =
> Algorithm.getAlgorithmList().get(0); List<OptimisationSolution>
> optimisationSolutions = new ArrayList<OptimisationSolution>(); for (Entity
> entity : population) {
> Type solution = entity.getCandidateSolution().getClone();
> optimisationSolutions.add(new OptimisationSolution(solution,
> -
> topLevelAlgorithm.getOptimisationProblem().getFitness(solution, false))); +
>
> topLevelAlgorithm.getOptimisationProblem().getFitness(solution))); }
> Archive.get().addAll(optimisationSolutions);
> }
> diff --git
> a/src/main/java/net/sourceforge/cilib/neuralnetwork/foundation/NeuralNetwor
>kProblem.java
> b/src/main/java/net/sourceforge/cilib/neuralnetwork/foundation/NeuralNetwor
>kProblem.java index 8f54433..de82adf 100644
> ---
> a/src/main/java/net/sourceforge/cilib/neuralnetwork/foundation/NeuralNetwor
>kProblem.java +++
> b/src/main/java/net/sourceforge/cilib/neuralnetwork/foundation/NeuralNetwor
>kProblem.java @@ -76,11 +76,10 @@ public class NeuralNetworkProblem
> implements OptimisationProblem, Initializable return
> evaluationStrategy.evaluate(p);
> }
>
> - public Fitness getFitness(Type solution, boolean count) {
> + @Override
> + public Fitness getFitness(Type solution) {
> + ++fitnessEvaluations;
>
> - if (count) {
> - ++fitnessEvaluations;
> - }
> this.getTopology().setWeights((Vector) solution);
>
> //Defaults to first error element as the main fitness...
> diff --git
> a/src/main/java/net/sourceforge/cilib/problem/CooperativeOptimisationProble
>mAdapter.java
> b/src/main/java/net/sourceforge/cilib/problem/CooperativeOptimisationProble
>mAdapter.java index 316d620..42ed4ab 100644
> ---
> a/src/main/java/net/sourceforge/cilib/problem/CooperativeOptimisationProble
>mAdapter.java +++
> b/src/main/java/net/sourceforge/cilib/problem/CooperativeOptimisationProble
>mAdapter.java @@ -111,7 +111,7 @@ public class
> CooperativeOptimisationProblemAdapter extends OptimisationProblemAd for
> (int i = 0; i < dimension; ++i) {
> ((Vector) context.getCandidateSolution()).setReal(offset + i,
> participant.getReal(i)); }
> - return problem.getFitness(context.getCandidateSolution(), true);
> + return problem.getFitness(context.getCandidateSolution());
> }
>
> public DomainRegistry getDomain() {
> diff --git a/src/main/java/net/sourceforge/cilib/problem/MOFitness.java
> b/src/main/java/net/sourceforge/cilib/problem/MOFitness.java index
> a6144a6..4edfc45 100644
> --- a/src/main/java/net/sourceforge/cilib/problem/MOFitness.java
> +++ b/src/main/java/net/sourceforge/cilib/problem/MOFitness.java
> @@ -34,19 +34,19 @@ public class MOFitness implements Fitness {
> private static final long serialVersionUID = 1477723759384827131L;
> private Fitness[] fitnesses;
>
> - public MOFitness(MOOptimisationProblem problem, Type[] solution,
> boolean count) { + public MOFitness(MOOptimisationProblem problem,
> Type[] solution) { int size = problem.size();
> fitnesses = new Fitness[size];
> for (int i = 0; i < size; ++i) {
> - fitnesses[i] = problem.getFitness(i, solution[i], count);
> + fitnesses[i] = problem.getFitness(i, solution[i]);
> }
> }
>
> - public MOFitness(MOOptimisationProblem problem, Type solution, boolean
> count) { + public MOFitness(MOOptimisationProblem problem, Type
> solution) { int size = problem.size();
> fitnesses = new Fitness[size];
> for (int i = 0; i < size; ++i) {
> - fitnesses[i] = problem.getFitness(i, solution, count);
> + fitnesses[i] = problem.getFitness(i, solution);
> }
> }
>
> diff --git
> a/src/main/java/net/sourceforge/cilib/problem/MOOptimisationProblem.java
> b/src/main/java/net/sourceforge/cilib/problem/MOOptimisationProblem.java
> index 54b4b4a..ccc139f 100644
> ---
> a/src/main/java/net/sourceforge/cilib/problem/MOOptimisationProblem.java
> +++
> b/src/main/java/net/sourceforge/cilib/problem/MOOptimisationProblem.java @@
> -56,17 +56,17 @@ public class MOOptimisationProblem implements
> OptimisationProblem, List<Optimisa return new MOOptimisationProblem(this);
> }
>
> - public MOFitness getFitness(Type[] solutions, boolean count) {
> - return new MOFitness(this, solutions, count);
> + public MOFitness getFitness(Type[] solutions) {
> + return new MOFitness(this, solutions);
> }
>
> @Override
> - public MOFitness getFitness(Type solution, boolean count) {
> - return new MOFitness(this, solution, count);
> + public MOFitness getFitness(Type solution) {
> + return new MOFitness(this, solution);
> }
>
> - public Fitness getFitness(int index, Type solution, boolean count) {
> - return problems.get(index).getFitness(solution, count);
> + public Fitness getFitness(int index, Type solution) {
> + return problems.get(index).getFitness(solution);
> }
>
> @Override
> diff --git
> a/src/main/java/net/sourceforge/cilib/problem/OptimisationProblem.java
> b/src/main/java/net/sourceforge/cilib/problem/OptimisationProblem.java
> index a5437c2..454aaa9 100644
> --- a/src/main/java/net/sourceforge/cilib/problem/OptimisationProblem.java
> +++ b/src/main/java/net/sourceforge/cilib/problem/OptimisationProblem.java
> @@ -53,10 +53,9 @@ public interface OptimisationProblem extends Problem {
> * falls outside the search space of this problem.
> *
> * @param solution The potential solution found by the optimisation
> algorithm. - * @param count True if this call should contribute to the
> fitness evaluation count, see {@link #getFitnessEvaluations()}. * @return
> The fitness of the solution.
> */
> - public Fitness getFitness(Type solution, boolean count);
> + public Fitness getFitness(Type solution);
>
> /**
> * Returns the number of times the underlying fitness function has
> been evaluated. diff --git
> a/src/main/java/net/sourceforge/cilib/problem/OptimisationProblemAdapter.ja
>va
> b/src/main/java/net/sourceforge/cilib/problem/OptimisationProblemAdapter.ja
>va index 1b2e37d..aa7288d 100644
> ---
> a/src/main/java/net/sourceforge/cilib/problem/OptimisationProblemAdapter.ja
>va +++
> b/src/main/java/net/sourceforge/cilib/problem/OptimisationProblemAdapter.ja
>va @@ -72,10 +72,8 @@ public abstract class OptimisationProblemAdapter
> implements OptimisationProblem /**
> * {@inheritDoc}
> */
> - public final Fitness getFitness(Type solution, boolean count) {
> - if (count) {
> - fitnessEvaluations.incrementAndGet();
> - }
> + public final Fitness getFitness(Type solution) {
> + fitnessEvaluations.incrementAndGet();
>
> if (this.changeStrategy.shouldApply(this))
> changeEnvironment();
> diff --git
> a/src/main/java/net/sourceforge/cilib/pso/dynamic/DynamicParticle.java
> b/src/main/java/net/sourceforge/cilib/pso/dynamic/DynamicParticle.java
> index efa583e..a69ac96 100644
> --- a/src/main/java/net/sourceforge/cilib/pso/dynamic/DynamicParticle.java
> +++ b/src/main/java/net/sourceforge/cilib/pso/dynamic/DynamicParticle.java
> @@ -52,7 +52,7 @@ public class DynamicParticle extends StandardParticle {
> * Re-evaluate both best and current position of the particle.
> */
> public void reevaluate() {
> - this.getProperties().put(EntityType.Particle.BEST_FITNESS,
> getFitnessCalculator().getFitness(this, true)); +
> this.getProperties().put(EntityType.Particle.BEST_FITNESS,
> getFitnessCalculator().getFitness(this)); this.calculateFitness();
> }
> }
> diff --git
> a/src/main/java/net/sourceforge/cilib/pso/dynamic/detectionstrategies/Rando
>mSentryDetectionStrategy.java
> b/src/main/java/net/sourceforge/cilib/pso/dynamic/detectionstrategies/Rando
>mSentryDetectionStrategy.java index 11f0fb3..95387a7 100644
> ---
> a/src/main/java/net/sourceforge/cilib/pso/dynamic/detectionstrategies/Rando
>mSentryDetectionStrategy.java +++
> b/src/main/java/net/sourceforge/cilib/pso/dynamic/detectionstrategies/Rando
>mSentryDetectionStrategy.java @@ -79,7 +79,7 @@ public class
> RandomSentryDetectionStrategy<E extends PopulationBasedAlgorithm> e for
> (Entity nextSentry : sentryList) {
> double oldSentryFitness = nextSentry.getFitness().getValue();
> nextSentry.calculateFitness();
> - double newSentryFitness =
> algorithm.getOptimisationProblem().getFitness(nextSentry.getCandidateSoluti
>on(), false).getValue(); + double newSentryFitness =
> algorithm.getOptimisationProblem().getFitness(nextSentry.getCandidateSoluti
>on()).getValue();
>
> if(Math.abs(oldSentryFitness - newSentryFitness) >= theta) {
> envChangeOccured = true;
> diff --git
> a/src/main/java/net/sourceforge/cilib/pso/dynamic/responsestrategies/Archiv
>eReevaluationResponseStrategy.java
> b/src/main/java/net/sourceforge/cilib/pso/dynamic/responsestrategies/Archiv
>eReevaluationResponseStrategy.java index 10db1e8..cce4afd 100644
> ---
> a/src/main/java/net/sourceforge/cilib/pso/dynamic/responsestrategies/Archiv
>eReevaluationResponseStrategy.java +++
> b/src/main/java/net/sourceforge/cilib/pso/dynamic/responsestrategies/Archiv
>eReevaluationResponseStrategy.java @@ -46,7 +46,7 @@ public class
> ArchiveReevaluationResponseStrategy extends EnvironmentChangeRespon
> @Override
> protected void performReaction(PopulationBasedAlgorithm algorithm) {
> for (Entity entity : algorithm.getTopology()) {
> - entity.getProperties().put(EntityType.Particle.BEST_FITNESS,
> entity.getFitnessCalculator().getFitness(entity, true)); +
> entity.getProperties().put(EntityType.Particle.BEST_FITNESS,
> entity.getFitnessCalculator().getFitness(entity));
> //entity.getProperties().put(EntityType.Particle.BEST_POSITION,
> entity.getCandidateSolution()); entity.calculateFitness();
> }
> @@ -56,7 +56,7 @@ public class ArchiveReevaluationResponseStrategy extends
> EnvironmentChangeRespon
>
> List<OptimisationSolution> newList = new
> LinkedList<OptimisationSolution>(); for (OptimisationSolution solution :
> Archive.get()) {
> - OptimisationSolution os = new
> OptimisationSolution(solution.getPosition(),
> problem.getFitness(solution.getPosition(), false)); +
> OptimisationSolution os = new OptimisationSolution(solution.getPosition(),
> problem.getFitness(solution.getPosition())); newList.add(os);
> }
>
> diff --git
> a/src/main/java/net/sourceforge/cilib/pso/dynamic/responsestrategies/Compet
>itiveCoevolutionParticleReevaluationResponseStrategy.java
> b/src/main/java/net/sourceforge/cilib/pso/dynamic/responsestrategies/Compet
>itiveCoevolutionParticleReevaluationResponseStrategy.java index
> f3140f8..15c0b15 100644
> ---
> a/src/main/java/net/sourceforge/cilib/pso/dynamic/responsestrategies/Compet
>itiveCoevolutionParticleReevaluationResponseStrategy.java +++
> b/src/main/java/net/sourceforge/cilib/pso/dynamic/responsestrategies/Compet
>itiveCoevolutionParticleReevaluationResponseStrategy.java @@ -70,7 +70,7 @@
> public class CompetitiveCoevolutionParticleReevaluationResponseStrategy<E
> extend Blackboard<Enum<?>, Type> blackboard = new Blackboard<Enum<?>,
> Type>(); blackboard.put(EntityType.CANDIDATE_SOLUTION,
> ((AbstractParticle)e).getBestPosition());
> blackboard.put(EntityType.Coevolution.BOARD, new EntityScoreboard()); -
> Fitness val =
> currentAlgorithm.getOptimisationProblem().getFitness(blackboard, false); +
> Fitness val =
> currentAlgorithm.getOptimisationProblem().getFitness(blackboard);
> e.getProperties().put(EntityType.Particle.BEST_FITNESS, val); //if currentV
> is better than re-evaluated pBest, then replace it if
> (e.getFitness().compareTo(e.getBestFitness()) > 0) { diff --git
> a/src/main/java/net/sourceforge/cilib/pso/moo/guideupdatestrategies/Dominan
>tGuideUpdateStrategy.java
> b/src/main/java/net/sourceforge/cilib/pso/moo/guideupdatestrategies/Dominan
>tGuideUpdateStrategy.java index 22d529e..fccbd7d 100644
> ---
> a/src/main/java/net/sourceforge/cilib/pso/moo/guideupdatestrategies/Dominan
>tGuideUpdateStrategy.java +++
> b/src/main/java/net/sourceforge/cilib/pso/moo/guideupdatestrategies/Dominan
>tGuideUpdateStrategy.java @@ -56,8 +56,8 @@ public class
> DominantGuideUpdateStrategy implements GuideUpdateStrategy { Vector
> previousGuide = (Vector) particle.getProperties().get(guideType); Algorithm
> topLevelAlgorithm = Algorithm.getAlgorithmList().get(0);
> OptimisationProblem problem = topLevelAlgorithm.getOptimisationProblem(); -
> Fitness currentFitness = problem.getFitness(newGuide, false); -
> if (previousGuide == null ||
> currentFitness.compareTo(problem.getFitness(previousGuide, false)) > 0) { +
> Fitness currentFitness = problem.getFitness(newGuide);
> + if (previousGuide == null ||
> currentFitness.compareTo(problem.getFitness(previousGuide)) > 0) {
> particle.getProperties().put(guideType, newGuide);
> }
> }
> diff --git
> a/src/main/java/net/sourceforge/cilib/pso/particle/MultiObjectiveParticle.j
>ava
> b/src/main/java/net/sourceforge/cilib/pso/particle/MultiObjectiveParticle.j
>ava index 272f0ab..cc66ed5 100644
> ---
> a/src/main/java/net/sourceforge/cilib/pso/particle/MultiObjectiveParticle.j
>ava +++
> b/src/main/java/net/sourceforge/cilib/pso/particle/MultiObjectiveParticle.j
>ava @@ -33,7 +33,7 @@ public class MultiObjectiveParticle extends
> StandardParticle { private static final long serialVersionUID =
> 2449622504036301616L;
>
> public void setBestPosition(Type bestPosition) {
> - Fitness bestPositionFitness =
> Algorithm.get().getOptimisationProblem().getFitness(bestPosition, false); +
> Fitness bestPositionFitness =
> Algorithm.get().getOptimisationProblem().getFitness(bestPosition);
>
> this.getProperties().put(EntityType.Particle.BEST_POSITION,
> bestPosition.getClone());
> this.getProperties().put(EntityType.Particle.BEST_FITNESS,
> bestPositionFitness); diff --git
> a/src/main/java/net/sourceforge/cilib/pso/particle/StandardParticle.java
> b/src/main/java/net/sourceforge/cilib/pso/particle/StandardParticle.java
> index 5176e8f..6f2cb2d 100644
> ---
> a/src/main/java/net/sourceforge/cilib/pso/particle/StandardParticle.java
> +++
> b/src/main/java/net/sourceforge/cilib/pso/particle/StandardParticle.java @@
> -163,7 +163,7 @@ public class StandardParticle extends AbstractParticle {
> */
> @Override
> public void calculateFitness() {
> - Fitness fitness = getFitnessCalculator().getFitness(this, true);
> + Fitness fitness = getFitnessCalculator().getFitness(this);
> this.getProperties().put(EntityType.FITNESS, fitness);
>
> this.personalBestUpdateStrategy.updatePersonalBest(this);
> diff --git
> a/src/main/java/net/sourceforge/cilib/pso/positionupdatestrategies/DEPositi
>onUpdateStrategy.java
> b/src/main/java/net/sourceforge/cilib/pso/positionupdatestrategies/DEPositi
>onUpdateStrategy.java index 3c244cd..2ac5646 100755
> ---
> a/src/main/java/net/sourceforge/cilib/pso/positionupdatestrategies/DEPositi
>onUpdateStrategy.java +++
> b/src/main/java/net/sourceforge/cilib/pso/positionupdatestrategies/DEPositi
>onUpdateStrategy.java @@ -123,8 +123,8 @@ public class
> DEPositionUpdateStrategy implements PositionUpdateStrategy {
>
>
> //position should only become the offspring if its fitness is
> better - Fitness trialFitness =
> pso.getOptimisationProblem().getFitness(dePosition, false); -
> Fitness currentFitness =
> pso.getOptimisationProblem().getFitness(particle.getCandidateSolution(),
> false); + Fitness trialFitness =
> pso.getOptimisationProblem().getFitness(dePosition); + Fitness
> currentFitness =
> pso.getOptimisationProblem().getFitness(particle.getCandidateSolution());
>
> if (trialFitness.compareTo(currentFitness) > 0) {
> particle.setCandidateSolution(dePosition);
> diff --git
> a/src/main/java/net/sourceforge/cilib/pso/velocityupdatestrategies/GCVeloci
>tyUpdateStrategy.java
> b/src/main/java/net/sourceforge/cilib/pso/velocityupdatestrategies/GCVeloci
>tyUpdateStrategy.java index 9bdfee4..cba2489 100644
> ---
> a/src/main/java/net/sourceforge/cilib/pso/velocityupdatestrategies/GCVeloci
>tyUpdateStrategy.java +++
> b/src/main/java/net/sourceforge/cilib/pso/velocityupdatestrategies/GCVeloci
>tyUpdateStrategy.java @@ -159,7 +159,7 @@ public class
> GCVelocityUpdateStrategy extends StandardVelocityUpdate { PSO pso = (PSO)
> Algorithm.get();
>
> if (particle == pso.getTopology().getBestEntity(new
> SocialBestFitnessComparator<Particle>())) { - Fitness newFitness
> = particle.getFitnessCalculator().getFitness(particle, false); +
> Fitness newFitness = particle.getFitnessCalculator().getFitness(particle);
>
> if (!newFitness.equals(oldFitness)) {
> this.failureCount = 0;
> diff --git
> a/src/main/java/net/sourceforge/cilib/util/calculator/EntityBasedFitnessCal
>culator.java
> b/src/main/java/net/sourceforge/cilib/util/calculator/EntityBasedFitnessCal
>culator.java index afd5933..8b19b18 100644
> ---
> a/src/main/java/net/sourceforge/cilib/util/calculator/EntityBasedFitnessCal
>culator.java +++
> b/src/main/java/net/sourceforge/cilib/util/calculator/EntityBasedFitnessCal
>culator.java @@ -35,6 +35,7 @@ public class EntityBasedFitnessCalculator
> implements FitnessCalculator<Entity> { /**
> * {@inheritDoc}
> */
> + @Override
> public EntityBasedFitnessCalculator getClone() {
> return this;
> }
> @@ -42,9 +43,10 @@ public class EntityBasedFitnessCalculator implements
> FitnessCalculator<Entity> { /**
> * {@inheritDoc}
> */
> - public Fitness getFitness(Entity entity, boolean count) {
> + @Override
> + public Fitness getFitness(Entity entity) {
> Algorithm algorithm = Algorithm.get();
> - return
> algorithm.getOptimisationProblem().getFitness(entity.getCandidateSolution()
>, count); + return
> algorithm.getOptimisationProblem().getFitness(entity.getCandidateSolution()
>); }
>
> }
> diff --git
> a/src/main/java/net/sourceforge/cilib/util/calculator/FitnessCalculator.jav
>a
> b/src/main/java/net/sourceforge/cilib/util/calculator/FitnessCalculator.jav
>a index 51ecf75..8ef9a07 100644
> ---
> a/src/main/java/net/sourceforge/cilib/util/calculator/FitnessCalculator.jav
>a +++
> b/src/main/java/net/sourceforge/cilib/util/calculator/FitnessCalculator.jav
>a @@ -34,14 +34,14 @@ public interface FitnessCalculator<T> extends
> Cloneable { /**
> * {@inheritDoc}
> */
> + @Override
> public FitnessCalculator<T> getClone();
>
> /**
> * Get the fitness, given the <code>position</code>.
> * @param entity The <code>Type</code> to base the calculation on.
> - * @param count Whether or not the evaluation is to be counted.
> * @return A <code>Fitness</code> object representing the fitness of
> the <code>position</code>. */
> - public Fitness getFitness(T entity, boolean count);
> + public Fitness getFitness(T entity);
>
> }
> diff --git
> a/src/main/java/net/sourceforge/cilib/util/calculator/PropertyBasedFitnessC
>alculator.java
> b/src/main/java/net/sourceforge/cilib/util/calculator/PropertyBasedFitnessC
>alculator.java index 78783d3..39479ee 100644
> ---
> a/src/main/java/net/sourceforge/cilib/util/calculator/PropertyBasedFitnessC
>alculator.java +++
> b/src/main/java/net/sourceforge/cilib/util/calculator/PropertyBasedFitnessC
>alculator.java @@ -45,8 +45,8 @@ public class PropertyBasedFitnessCalculator
> implements * {@inheritDoc}
> */
> @Override
> - public Fitness getFitness(Entity entity, boolean count) {
> + public Fitness getFitness(Entity entity) {
> Algorithm algorithm = Algorithm.get();
> - return
> algorithm.getOptimisationProblem().getFitness(entity.getProperties(),
> count); + return
> algorithm.getOptimisationProblem().getFitness(entity.getProperties()); }
> }
> diff --git
> a/src/main/java/net/sourceforge/cilib/util/calculator/StructuredTypeFitness
>Calculator.java
> b/src/main/java/net/sourceforge/cilib/util/calculator/StructuredTypeFitness
>Calculator.java index 5fe4d24..5e77f38 100644
> ---
> a/src/main/java/net/sourceforge/cilib/util/calculator/StructuredTypeFitness
>Calculator.java +++
> b/src/main/java/net/sourceforge/cilib/util/calculator/StructuredTypeFitness
>Calculator.java @@ -46,9 +46,9 @@ public class
> StructuredTypeFitnessCalculator<T extends StructuredType<?>> implem *
> {@inheritDoc}
> */
> @Override
> - public Fitness getFitness(T structure, boolean count) {
> + public Fitness getFitness(T structure) {
> Algorithm algorithm = Algorithm.get();
> - return algorithm.getOptimisationProblem().getFitness(structure,
> count); + return
> algorithm.getOptimisationProblem().getFitness(structure); }
>
> }
> diff --git
> a/src/test/java/net/sourceforge/cilib/entity/operators/crossover/BlendCross
>overStrategyTest.java
> b/src/test/java/net/sourceforge/cilib/entity/operators/crossover/BlendCross
>overStrategyTest.java index b66511a..7035d52 100644
> ---
> a/src/test/java/net/sourceforge/cilib/entity/operators/crossover/BlendCross
>overStrategyTest.java +++
> b/src/test/java/net/sourceforge/cilib/entity/operators/crossover/BlendCross
>overStrategyTest.java @@ -84,7 +84,7 @@ public class
> BlendCrossoverStrategyTest {
> }
>
> @Override
> - public Fitness getFitness(Individual entity, boolean count) {
> + public Fitness getFitness(Individual entity) {
> return InferiorFitness.instance();
> }
> }
> diff --git
> a/src/test/java/net/sourceforge/cilib/entity/operators/crossover/OnePointCr
>ossoverStrategyTest.java
> b/src/test/java/net/sourceforge/cilib/entity/operators/crossover/OnePointCr
>ossoverStrategyTest.java index e7805ca..f6a97df 100644
> ---
> a/src/test/java/net/sourceforge/cilib/entity/operators/crossover/OnePointCr
>ossoverStrategyTest.java +++
> b/src/test/java/net/sourceforge/cilib/entity/operators/crossover/OnePointCr
>ossoverStrategyTest.java @@ -84,7 +84,7 @@ public class
> OnePointCrossoverStrategyTest {
> }
>
> @Override
> - public Fitness getFitness(Individual entity, boolean count) {
> + public Fitness getFitness(Individual entity) {
> return InferiorFitness.instance();
> }
> }
> diff --git
> a/src/test/java/net/sourceforge/cilib/entity/operators/crossover/UniformCro
>ssoverStrategyTest.java
> b/src/test/java/net/sourceforge/cilib/entity/operators/crossover/UniformCro
>ssoverStrategyTest.java index daae496..f132db1 100644
> ---
> a/src/test/java/net/sourceforge/cilib/entity/operators/crossover/UniformCro
>ssoverStrategyTest.java +++
> b/src/test/java/net/sourceforge/cilib/entity/operators/crossover/UniformCro
>ssoverStrategyTest.java @@ -84,7 +84,7 @@ public class
> UniformCrossoverStrategyTest {
> }
>
> @Override
> - public Fitness getFitness(Individual entity, boolean count) {
> + public Fitness getFitness(Individual entity) {
> return InferiorFitness.instance();
> }
> }
> diff --git
> a/src/test/java/net/sourceforge/cilib/moo/archive/constrained/ArchiveTest.j
>ava
> b/src/test/java/net/sourceforge/cilib/moo/archive/constrained/ArchiveTest.j
>ava index a6cbc2a..8a1a84a 100644
> ---
> a/src/test/java/net/sourceforge/cilib/moo/archive/constrained/ArchiveTest.j
>ava +++
> b/src/test/java/net/sourceforge/cilib/moo/archive/constrained/ArchiveTest.j
>ava @@ -234,29 +234,29 @@ public class ArchiveTest {
> // and test if the fitness-value is correct.
> Iterator<Vector> vectorIterator = testVectors.iterator();
> Vector testVector = vectorIterator.next();
> - MOFitness fitness = (MOFitness) problem.getFitness(testVector,
> false); + MOFitness fitness = problem.getFitness(testVector);
> assertThat(fitness.getDimension(), is(2));
> assertEquals(1.46361111111, fitness.getFitness(0).getValue(),
> EPSILON); assertEquals(55, fitness.getFitness(1).getValue(), EPSILON); -
> archive.addAll(Arrays.asList(new OptimisationSolution(testVector,
> problem.getFitness(testVector, false)))); -
> assertThat(archive.contains(new OptimisationSolution(testVector,
> problem.getFitness(testVector, false))), is(true)); +
> archive.addAll(Arrays.asList(new OptimisationSolution(testVector,
> problem.getFitness(testVector)))); + assertThat(archive.contains(new
> OptimisationSolution(testVector, problem.getFitness(testVector))),
> is(true));
>
> testVector = vectorIterator.next();
> - fitness = (MOFitness) problem.getFitness(testVector, false);
> + fitness = problem.getFitness(testVector);
> assertThat(fitness.getDimension(), is(2));
> assertEquals(0.491388888889, fitness.getFitness(0).getValue(),
> EPSILON); assertEquals(90, fitness.getFitness(1).getValue(), EPSILON); -
> archive.addAll(Arrays.asList(new OptimisationSolution(testVector,
> problem.getFitness(testVector, false)))); -
> assertThat(archive.contains(new OptimisationSolution(testVector,
> problem.getFitness(testVector, false))), is(true)); +
> archive.addAll(Arrays.asList(new OptimisationSolution(testVector,
> problem.getFitness(testVector)))); + assertThat(archive.contains(new
> OptimisationSolution(testVector, problem.getFitness(testVector))),
> is(true)); assertThat(archive.size(), is(2));
>
> testVector = vectorIterator.next();
> - fitness = (MOFitness) problem.getFitness(testVector, false);
> + fitness = problem.getFitness(testVector);
> assertThat(fitness.getDimension(), is(2));
> assertEquals(0.261797052154, fitness.getFitness(0).getValue(),
> EPSILON); assertEquals(135, fitness.getFitness(1).getValue(), EPSILON); -
> archive.addAll(Arrays.asList(new OptimisationSolution(testVector,
> problem.getFitness(testVector, false)))); -
> assertThat(archive.contains(new OptimisationSolution(testVector,
> problem.getFitness(testVector, false))), is(true)); +
> archive.addAll(Arrays.asList(new OptimisationSolution(testVector,
> problem.getFitness(testVector)))); + assertThat(archive.contains(new
> OptimisationSolution(testVector, problem.getFitness(testVector))),
> is(true)); assertThat(archive.size(), is(3));
>
> // After the archive size has been monitored continuously, insert
> the exact same solutions into the archive again. @@ -264,9 +264,9 @@ public
> class ArchiveTest {
> vectorIterator = testVectors.iterator();
> while (vectorIterator.hasNext()) {
> testVector = vectorIterator.next();
> - fitness = (MOFitness) problem.getFitness(testVector, false);
> + fitness = problem.getFitness(testVector);
> assertThat(fitness.getDimension(), is(2));
> - archive.addAll(Arrays.asList(new
> OptimisationSolution(testVector, problem.getFitness(testVector, false))));
> + archive.addAll(Arrays.asList(new
> OptimisationSolution(testVector, problem.getFitness(testVector)))); }
> // Archive size must stay the same due to set-based behavior of
> archive. assertThat(archive.size(), is(3));
> @@ -284,7 +284,7 @@ public class ArchiveTest {
> DummyOptimisationProblem1 problem1 = new
> DummyOptimisationProblem1(); Collection<Vector> testVectors =
> createDummyVectors();
> for (Vector testVector : testVectors) {
> - archive.addAll(Arrays.asList(new
> OptimisationSolution(testVector, problem1.getFitness(testVector, false))));
> + archive.addAll(Arrays.asList(new
> OptimisationSolution(testVector, problem1.getFitness(testVector)))); }
> // Arhive size is now 3.
> assertThat(archive.size(), is(3));
> @@ -296,13 +296,13 @@ public class ArchiveTest {
> DummyOptimisationProblem2 problem2 = new
> DummyOptimisationProblem2(); Iterator<Vector> vectorIterator =
> testVectors.iterator(); Vector testVector = vectorIterator.next();
> - MOFitness fitness = (MOFitness) problem2.getFitness(testVector,
> false); + MOFitness fitness = problem2.getFitness(testVector);
> assertThat(fitness.getDimension(), is(2));
> assertEquals(2.92722222222, fitness.getFitness(0).getValue(),
> EPSILON); assertEquals(110, fitness.getFitness(1).getValue(), EPSILON);
>
> // Then, check which solutions (corresponding to problem 1)
> dominates the first external solution corresponding to problem 2. -
> Collection<OptimisationSolution> dominantSolutions = archive.dominates(new
> OptimisationSolution(testVector, problem2.getFitness(testVector, false)));
> + Collection<OptimisationSolution> dominantSolutions =
> archive.dominates(new OptimisationSolution(testVector,
> problem2.getFitness(testVector))); assertThat(dominantSolutions.size(),
> is(2));
> Iterator<OptimisationSolution> dominantIterator =
> dominantSolutions.iterator();
>
> @@ -323,22 +323,22 @@ public class ArchiveTest {
> // solution with fitness (2.92722222222, 110) which is correct.
>
> // Finally, check that archive does not accept this solution.
> - archive.addAll(Arrays.asList(new OptimisationSolution(testVector,
> problem2.getFitness(testVector, false)))); +
> archive.addAll(Arrays.asList(new OptimisationSolution(testVector,
> problem2.getFitness(testVector)))); assertThat(archive.size(), is(3));
> - assertThat(archive.contains(new OptimisationSolution(testVector,
> problem2.getFitness(testVector, false))), is(false)); +
> assertThat(archive.contains(new OptimisationSolution(testVector,
> problem2.getFitness(testVector))), is(false));
>
>
>
>
> // For the second vector (2,3,4,5,6) calculate the fitness in
> terms of optimisation problem 2 and check it. testVector =
> vectorIterator.next();
> - fitness = (MOFitness) problem2.getFitness(testVector, false);
> + fitness = problem2.getFitness(testVector);
> assertThat(fitness.getDimension(), is(2));
> assertEquals(0.982777777778, fitness.getFitness(0).getValue(),
> EPSILON); assertEquals(180, fitness.getFitness(1).getValue(), EPSILON);
>
> // Now, check which solutions (corresponding to problem 1)
> dominates the second external solution corresponding to problem 2. -
> dominantSolutions = archive.dominates(new OptimisationSolution(testVector,
> problem2.getFitness(testVector, false))); + dominantSolutions =
> archive.dominates(new OptimisationSolution(testVector,
> problem2.getFitness(testVector))); assertThat(dominantSolutions.size(),
> is(2));
> dominantIterator = dominantSolutions.iterator();
>
> @@ -359,22 +359,22 @@ public class ArchiveTest {
> // solution with fitness (0.982777777778, 180) which is correct.
>
> // Finally, check that archive does not accept this solution.
> - archive.addAll(Arrays.asList(new OptimisationSolution(testVector,
> problem2.getFitness(testVector, false)))); +
> archive.addAll(Arrays.asList(new OptimisationSolution(testVector,
> problem2.getFitness(testVector)))); assertThat(archive.size(), is(3));
> - assertThat(archive.contains(new OptimisationSolution(testVector,
> problem2.getFitness(testVector, false))), is(false)); +
> assertThat(archive.contains(new OptimisationSolution(testVector,
> problem2.getFitness(testVector))), is(false));
>
>
>
>
> // For the third vector (3,4,5,6,7) calculate the fitness in terms
> of optimisation problem 2 and check it. testVector = vectorIterator.next();
> - fitness = (MOFitness) problem2.getFitness(testVector, false);
> + fitness = problem2.getFitness(testVector);
> assertThat(fitness.getDimension(), is(2));
> assertEquals(0.523594104308, fitness.getFitness(0).getValue(),
> EPSILON); assertEquals(270, fitness.getFitness(1).getValue(), EPSILON);
>
> // Now, check which solutions (corresponding to problem 1)
> dominates the second solution corresponding to problem 2. -
> dominantSolutions = archive.dominates(new OptimisationSolution(testVector,
> problem2.getFitness(testVector, false))); + dominantSolutions =
> archive.dominates(new OptimisationSolution(testVector,
> problem2.getFitness(testVector))); assertThat(dominantSolutions.size(),
> is(2));
> dominantIterator = dominantSolutions.iterator();
>
> @@ -395,9 +395,9 @@ public class ArchiveTest {
> // solution with fitness (0.523594104308, 270) which is correct.
>
> // Finally, check that archive does not accept this solution.
> - archive.addAll(Arrays.asList(new OptimisationSolution(testVector,
> problem2.getFitness(testVector, false)))); +
> archive.addAll(Arrays.asList(new OptimisationSolution(testVector,
> problem2.getFitness(testVector)))); assertThat(archive.size(), is(3));
> - assertThat(archive.contains(new OptimisationSolution(testVector,
> problem2.getFitness(testVector, false))), is(false)); +
> assertThat(archive.contains(new OptimisationSolution(testVector,
> problem2.getFitness(testVector))), is(false)); }
>
> /**
> @@ -413,7 +413,7 @@ public class ArchiveTest {
> DummyOptimisationProblem2 problem2 = new
> DummyOptimisationProblem2(); Collection<Vector> testVectors =
> createDummyVectors();
> for (Vector testVector : testVectors) {
> - archive.addAll(Arrays.asList(new
> OptimisationSolution(testVector, problem2.getFitness(testVector, false))));
> + archive.addAll(Arrays.asList(new
> OptimisationSolution(testVector, problem2.getFitness(testVector)))); }
> // Arhive size is now 3.
> assertThat(archive.size(), is(3));
> @@ -425,13 +425,13 @@ public class ArchiveTest {
> DummyOptimisationProblem1 problem1 = new
> DummyOptimisationProblem1(); Iterator<Vector> vectorIterator =
> testVectors.iterator(); Vector testVector = vectorIterator.next();
> - MOFitness fitness = (MOFitness) problem1.getFitness(testVector,
> false); + MOFitness fitness = problem1.getFitness(testVector);
> assertThat(fitness.getDimension(), is(2));
> assertEquals(1.46361111111, fitness.getFitness(0).getValue(),
> EPSILON); assertEquals(55, fitness.getFitness(1).getValue(), EPSILON);
>
> // Then, check which solutions (corresponding to problem 2) is
> dominated by the first external solution corresponding to problem 1. -
> Collection<OptimisationSolution> dominatedSolutions =
> archive.isDominatedBy(new OptimisationSolution(testVector,
> problem1.getFitness(testVector, false))); +
> Collection<OptimisationSolution> dominatedSolutions =
> archive.isDominatedBy(new OptimisationSolution(testVector,
> problem1.getFitness(testVector))); assertThat(dominatedSolutions.size(),
> is(1));
> Iterator<OptimisationSolution> dominatedIterator =
> dominatedSolutions.iterator();
>
> @@ -445,10 +445,10 @@ public class ArchiveTest {
> // Thus, no more solutions in archive is dominated by this
> external solution.
>
> // Now, insert this external solution and it should replace
> abovementioned dominated solution. -
> archive.addAll(Arrays.asList(new OptimisationSolution(testVector,
> problem1.getFitness(testVector, false)))); +
> archive.addAll(Arrays.asList(new OptimisationSolution(testVector,
> problem1.getFitness(testVector)))); assertThat(archive.size(), is(3));
> assertThat(archive.contains(dominatedSolution), is(false));
> - assertThat(archive.contains(new OptimisationSolution(testVector,
> problem1.getFitness(testVector, false))), is(true)); +
> assertThat(archive.contains(new OptimisationSolution(testVector,
> problem1.getFitness(testVector))), is(true));
>
> // -- Arhive contains (0.982777777778, 180); (0.523594104308,
> 270); new --> (1.46361111111, 55) <-- new;
>
> @@ -457,13 +457,13 @@ public class ArchiveTest {
>
> // For the second vector (2,3,4,5,6) calculate the fitness in
> terms of optimisation problem 1 and check it. testVector =
> vectorIterator.next();
> - fitness = (MOFitness) problem1.getFitness(testVector, false);
> + fitness = problem1.getFitness(testVector);
> assertThat(fitness.getDimension(), is(2));
> assertEquals(0.491388888889, fitness.getFitness(0).getValue(),
> EPSILON); assertEquals(90, fitness.getFitness(1).getValue(), EPSILON);
>
> // Then, check which solutions (corresponding to problem 2) is
> dominated by the second external solution corresponding to problem 1. -
> dominatedSolutions = archive.isDominatedBy(new
> OptimisationSolution(testVector, problem1.getFitness(testVector, false)));
> + dominatedSolutions = archive.isDominatedBy(new
> OptimisationSolution(testVector, problem1.getFitness(testVector)));
> assertThat(dominatedSolutions.size(), is(2));
> dominatedIterator = dominatedSolutions.iterator();
>
> @@ -480,11 +480,11 @@ public class ArchiveTest {
> assertEquals(270, ((MOFitness)
> dominatedSolution2.getFitness()).getFitness(1).getValue(), EPSILON);
>
> // Now, insert this external solution and it should replace both
> of the abovementioned dominated solutions. -
> archive.addAll(Arrays.asList(new OptimisationSolution(testVector,
> problem1.getFitness(testVector, false)))); +
> archive.addAll(Arrays.asList(new OptimisationSolution(testVector,
> problem1.getFitness(testVector)))); assertThat(archive.size(), is(2));
> assertThat(archive.contains(dominatedSolution1), is(false));
> assertThat(archive.contains(dominatedSolution2), is(false));
> - assertThat(archive.contains(new OptimisationSolution(testVector,
> problem1.getFitness(testVector, false))), is(true)); +
> assertThat(archive.contains(new OptimisationSolution(testVector,
> problem1.getFitness(testVector))), is(true));
>
> // -- Arhive contains (1.46361111111, 55); new -->
> (0.491388888889, 90) <-- new;
>
> @@ -493,19 +493,19 @@ public class ArchiveTest {
>
> // For the third vector (3,4,5,6,7) calculate the fitness in terms
> of optimisation problem 1 and check it. testVector = vectorIterator.next();
> - fitness = (MOFitness) problem1.getFitness(testVector, false);
> + fitness = problem1.getFitness(testVector);
> assertThat(fitness.getDimension(), is(2));
> assertEquals(0.261797052154, fitness.getFitness(0).getValue(),
> EPSILON); assertEquals(135, fitness.getFitness(1).getValue(), EPSILON);
>
> // Then, check which solutions (corresponding to problem 2) is
> dominated by the second external solution corresponding to problem 1. -
> dominatedSolutions = archive.isDominatedBy(new
> OptimisationSolution(testVector, problem1.getFitness(testVector, false)));
> + dominatedSolutions = archive.isDominatedBy(new
> OptimisationSolution(testVector, problem1.getFitness(testVector)));
> assertThat(dominatedSolutions.size(), is(0)); // No solutions dominate
> external solution.
>
> // Now, insert this external solution and it should be accepted in
> archive and not replace any other solution. -
> archive.addAll(Arrays.asList(new OptimisationSolution(testVector,
> problem1.getFitness(testVector, false)))); +
> archive.addAll(Arrays.asList(new OptimisationSolution(testVector,
> problem1.getFitness(testVector)))); assertThat(archive.size(), is(3));
> - assertThat(archive.contains(new OptimisationSolution(testVector,
> problem1.getFitness(testVector, false))), is(true)); +
> assertThat(archive.contains(new OptimisationSolution(testVector,
> problem1.getFitness(testVector))), is(true));
>
> // -- Archive contains (1.46361111111, 55); (0.491388888889, 90);
> (0.261797052154, 135); }
> diff --git
> a/src/test/java/net/sourceforge/cilib/moo/archive/constrained/ConstrainedAr
>chiveTest.java
> b/src/test/java/net/sourceforge/cilib/moo/archive/constrained/ConstrainedAr
>chiveTest.java index 05b3737..8a8491f 100644
> ---
> a/src/test/java/net/sourceforge/cilib/moo/archive/constrained/ConstrainedAr
>chiveTest.java +++
> b/src/test/java/net/sourceforge/cilib/moo/archive/constrained/ConstrainedAr
>chiveTest.java @@ -190,7 +190,7 @@ public class ConstrainedArchiveTest {
> for (int j = i; j < i + 5; ++j) {
> vector.add(new Real(j));
> }
> - archive.addAll(Arrays.asList(new OptimisationSolution(vector,
> problem.getFitness(vector, false)))); +
> archive.addAll(Arrays.asList(new OptimisationSolution(vector,
> problem.getFitness(vector)))); }
> assertThat(archive.size(), is(100));
> archive.clear();
> @@ -201,7 +201,7 @@ public class ConstrainedArchiveTest {
> for (int j = i; j < i + 5; ++j) {
> vector.add(new Real(j));
> }
> - solutions.add(new OptimisationSolution(vector,
> problem.getFitness(vector, false))); + solutions.add(new
> OptimisationSolution(vector, problem.getFitness(vector))); }
> archive.addAll(solutions);
> assertThat(archive.size(), is(100));
> diff --git
> a/src/test/java/net/sourceforge/cilib/moo/archive/solutionweighing/Solution
>WeighingTest.java
> b/src/test/java/net/sourceforge/cilib/moo/archive/solutionweighing/Solution
>WeighingTest.java index ae30953..9d2ef20 100644
> ---
> a/src/test/java/net/sourceforge/cilib/moo/archive/solutionweighing/Solution
>WeighingTest.java +++
> b/src/test/java/net/sourceforge/cilib/moo/archive/solutionweighing/Solution
>WeighingTest.java @@ -72,7 +72,7 @@ public class SolutionWeighingTest {
> }
>
> @Override
> - public Fitness getFitness(Type solution, boolean count) {
> + public Fitness getFitness(Type solution) {
> Vector position = (Vector) solution;
> return new MinimisationFitness(position.getReal(index));
> }
> @@ -123,27 +123,27 @@ public class SolutionWeighingTest {
> Vector position = new Vector();
> position.add(new Real(1));
> position.add(new Real(1));
> - solutions.add(new OptimisationSolution(position,
> moProblem.getFitness(position, false))); + solutions.add(new
> OptimisationSolution(position, moProblem.getFitness(position)));
>
> position = new Vector();
> position.add(new Real(2));
> position.add(new Real(4));
> - solutions.add(new OptimisationSolution(position,
> moProblem.getFitness(position, false))); + solutions.add(new
> OptimisationSolution(position, moProblem.getFitness(position)));
>
> position = new Vector();
> position.add(new Real(3));
> position.add(new Real(2));
> - solutions.add(new OptimisationSolution(position,
> moProblem.getFitness(position, false))); + solutions.add(new
> OptimisationSolution(position, moProblem.getFitness(position)));
>
> position = new Vector();
> position.add(new Real(4));
> position.add(new Real(6));
> - solutions.add(new OptimisationSolution(position,
> moProblem.getFitness(position, false))); + solutions.add(new
> OptimisationSolution(position, moProblem.getFitness(position)));
>
> position = new Vector();
> position.add(new Real(5));
> position.add(new Real(1));
> - solutions.add(new OptimisationSolution(position,
> moProblem.getFitness(position, false))); + solutions.add(new
> OptimisationSolution(position, moProblem.getFitness(position))); }
>
> @Test
> diff --git a/src/test/java/net/sourceforge/cilib/problem/MOFitnessTest.java
> b/src/test/java/net/sourceforge/cilib/problem/MOFitnessTest.java index
> 407bc25..ae5d5d5 100644
> --- a/src/test/java/net/sourceforge/cilib/problem/MOFitnessTest.java
> +++ b/src/test/java/net/sourceforge/cilib/problem/MOFitnessTest.java
> @@ -56,8 +56,8 @@ public class MOFitnessTest {
> new MinimisationFitness(new Integer(1).doubleValue()),
> new MinimisationFitness(new Integer(1).doubleValue())};
>
> - Fitness f1 = moproblem.getFitness(inferior, false);
> - Fitness f2 = moproblem.getFitness(oneFitness, false);
> + Fitness f1 = moproblem.getFitness(inferior);
> + Fitness f2 = moproblem.getFitness(oneFitness);
>
> assertTrue(f1.compareTo(f2) < 0);
> assertTrue(f2.compareTo(f1) > 0);
> @@ -80,14 +80,10 @@ public class MOFitnessTest {
> }
>
> @Override
> - public Fitness getFitness(Type solution, boolean count) {
> + public Fitness getFitness(Type solution) {
> return (Fitness) solution;
> }
>
> - public Fitness getFitness(Type[] solution, boolean count) {
> - return (Fitness) solution[i];
> - }
> -
> @Override
> public int getFitnessEvaluations() {
> return 0;
|
