示例#1
0
  /** {@inheritDoc} */
  @Override
  public void initialise(Problem problem) {
    StructuredType harmony = problem.getDomain().getBuiltRepresenation().getClone();
    harmony.randomize(new MersenneTwister());

    setCandidateSolution(harmony);
    this.getProperties().put(EntityType.FITNESS, InferiorFitness.instance());
  }
  /**
   * This is an Synchronous strategy:
   *
   * <ol>
   *   <li>For all particles:
   *       <ol>
   *         <li>Update the particle velocity
   *         <li>Update the particle position
   *       </ol>
   *   <li>For all particles:
   *       <ol>
   *         <li>Calculate the particle fitness
   *         <li>For all particles in the current particle's neighbourhood:
   *             <ol>
   *               <li>Update the neighbourhood best
   *             </ol>
   *       </ol>
   * </ol>
   *
   * @see
   *     net.sourceforge.cilib.PSO.IterationStrategy#performIteration(net.sourceforge.cilib.PSO.PSO)
   * @param pso The {@link PSO} to have an iteration applied.
   */
  @Override
  public void performIteration(PSO pso) {
    Topology<Particle> topology = pso.getTopology();

    for (Particle current : topology) {
      current.updateVelocity();
      current.updatePosition(); // TODO: replace with visitor (will simplify particle interface)

      boundaryConstraint.enforce(current);
    }

    Problem problem = AbstractAlgorithm.getAlgorithmList().get(0).getOptimisationProblem();

    for (Particle current : topology) {
      current.calculateFitness();
      for (Particle other : topology.neighbourhood(current)) {
        Particle p1 = current.getNeighbourhoodBest().getClone();
        Particle p2 = other.getNeighbourhoodBest().getClone();
        OptimisationSolution s1 =
            new OptimisationSolution(
                p1.getCandidateSolution().getClone(),
                problem.getFitness(p1.getCandidateSolution().getClone()));
        OptimisationSolution s2 =
            new OptimisationSolution(
                p2.getCandidateSolution().getClone(),
                problem.getFitness(p2.getCandidateSolution().getClone()));
        MOFitness fitness1 = (MOFitness) s1.getFitness();
        MOFitness fitness2 = (MOFitness) s2.getFitness();
        //                System.out.println("fitness1 = ");
        //                for (int i=0; i < fitness1.getDimension(); i++)
        //                    System.out.println(fitness1.getFitness(i).getValue());
        //
        //                System.out.println("fitness2 = ");
        //                for (int i=0; i < fitness2.getDimension(); i++)
        //                    System.out.println(fitness2.getFitness(i).getValue());
        if (fitness1.compareTo(fitness2) > 0) {
          other.setNeighbourhoodBest(current);
        }
      }
    }
  }
  /**
   * Splits up the given {@link OptimisationProblem} into sub-problems, where each sub problem
   * contains a sequencial (non-uniform sized) portion of the problem vector, and assigns them to
   * all the participating {@link Algorithm}s. This implementation assigns a portion of length
   * equals to dimensionality/number of populations + 1 to dimensionality % number of populations of
   * the participating algorithms.
   *
   * @param populations The list of participating {@linkplain PopulationBasedAlgorithm}s.
   * @param problem The problem that needs to be re-distributed.
   * @param context The context vector maintained by the {@linkplain
   *     CooperativeCoevolutionAlgorithm}.
   */
  public void performDistribution(
      List<PopulationBasedAlgorithm> populations, Problem problem, Vector context) {
    checkArgument(
        populations.size() >= 2,
        "There should at least be two Cooperating populations in a Cooperative Algorithm");

    int dimension = problem.getDomain().getDimension() / populations.size();
    int oddDimensions = problem.getDomain().getDimension() % populations.size();
    int i = 0;
    int offset = 0;

    for (Algorithm population : populations) {
      int actualDimension = dimension;
      if (i < oddDimensions) actualDimension++;

      DimensionAllocation problemAllocation =
          new SequencialDimensionAllocation(offset, actualDimension);
      population.setOptimisationProblem(
          new CooperativeCoevolutionProblemAdapter(problem, problemAllocation, context));
      offset += actualDimension;

      ++i;
    }
  }