Package ec.pso

# Class Particle

java.lang.Object
ec.Individual
ec.vector.VectorIndividual
ec.vector.DoubleVectorIndividual
ec.pso.Particle

All Implemented Interfaces:
  `Prototype`, `Setup`, `Serializable`, `Cloneable`, `Comparable<Individual>`

public class Particle extends DoubleVectorIndividual
Particle is a DoubleVectorIndividual with additional statistical information necessary to perform Particle Swarm Optimization. Specifically, it has a VELOCITY, a NEIGHBORHOOD of indexes of individuals, a NEIGHBORHOOD BEST genome and fitness, and a PERSONAL BEST genome and fitness. These elements, plus the GLOBAL BEST genome and fitness found in PSOBreeder, are used to collectively update the particle's location in space.

Particle updates its location in two steps. First, it gathers current neighborhood and personal best statistics via the update(...) method. Then it updates the particle's velocity and location (genome) according to these statistics in the tweak(...) method. Notice that neither of these methods is the defaultMutate(...) method used in DoubleVectorIndividual: this means that in *theory* you could rig up Particles to also be mutated if you thought that was a good reason.

Many of the parameters passed into the tweak(...) method are based on weights determined by the PSOBreeder.

See Also:
  - Serialized Form

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final String`
  `AUXILLARY_PREAMBLE`
  `int[]`
  `neighborhood`
  `Fitness`
  `neighborhoodBestFitness`
  `double[]`
  `neighborhoodBestGenome`
  `Fitness`
  `personalBestFitness`
  `double[]`
  `personalBestGenome`
  `double[]`
  `velocity`

  ### Fields inherited from class ec.vector.DoubleVectorIndividual

  `genome, MAXIMUM_INTEGER_IN_DOUBLE, P_DOUBLEVECTORINDIVIDUAL`

  ### Fields inherited from class ec.Individual

  `evaluated, EVALUATED_PREAMBLE, fitness, P_INDIVIDUAL, species`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `Particle()`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `Object`
  `clone()`
  Creates a new individual cloned from a prototype, and suitable to begin use in its own evolutionary context.
  `boolean`
  `equals(Object ind)`
  Returns true if I am genetically "equal" to ind.
  `int`
  `hashCode()`
  Returns a hashcode for the individual, such that individuals which are equals(...) each other always return the same hash code.
  `void`
  `join(Object[] pieces)`
  Joins the n pieces and sets the genome to their concatenation.
  `void`
  `printIndividual(EvolutionState state, int log)`
  Should print the individual in a way that can be read by computer, including its fitness, with a verbosity of Output.V_NO_GENERAL.
  `void`
  `printIndividual(EvolutionState state, PrintWriter writer)`
  Should print the individual in a way that can be read by computer, including its fitness.
  `void`
  `readIndividual(EvolutionState state, DataInput dataInput)`
  Reads the binary form of an individual from a DataInput, erasing the previous information stored in this Individual.
  `void`
  `readIndividual(EvolutionState state, LineNumberReader reader)`
  Reads in the individual from a form printed by printIndividual(), erasing the previous information stored in this Individual.
  `void`
  `reset(EvolutionState state, int thread)`
  Initializes the individual by randomly choosing doubles uniformly from mingene to maxgene.
  `void`
  `setGenome(Object gen)`
  Sets the gene array.
  `void`
  `setGenomeLength(int len)`
  Sets the genome length.
  `void`
  `setup(EvolutionState state, Parameter base)`
  This should be used to set up only those things which you share in common with all other individuals in your species; individual-specific items which make you you should be filled in by Species.newIndividual(...), and modified by breeders.
  `void`
  `tweak(EvolutionState state, double[] globalBest, double velocityCoeff, double personalCoeff, double informantCoeff, double globalCoeff, int thread)`
  `void`
  `update(EvolutionState state, int subpop, int myindex, int thread)`
  `void`
  `writeIndividual(EvolutionState state, DataOutput dataOutput)`
  Writes the binary form of an individual out to a DataOutput.

  ### Methods inherited from class ec.vector.DoubleVectorIndividual

  `clamp, defaultBase, defaultCrossover, defaultMutate, distanceTo, genomeLength, genotypeToString, genotypeToStringForHumans, getGenome, isInRange, parseGenotype, polynomialMutate, readGenotype, simulatedBinaryCrossover, split, writeGenotype`

  ### Methods inherited from class ec.vector.VectorIndividual

  `cloneGenes, reset, size`

  ### Methods inherited from class ec.Individual

  `compareTo, merge, printIndividual, printIndividualForHumans, printIndividualForHumans, toString`

  ### Methods inherited from class java.lang.Object

  `finalize, getClass, notify, notifyAll, wait, wait, wait`

- ## Field Details

  - ### AUXILLARY_PREAMBLE

    public static final String AUXILLARY_PREAMBLE
    See Also:
      - Constant Field Values

  - ### velocity

    public double[] velocity

  - ### neighborhood

    public int[] neighborhood

  - ### neighborhoodBestGenome

    public double[] neighborhoodBestGenome

  - ### neighborhoodBestFitness

    public Fitness neighborhoodBestFitness

  - ### personalBestGenome

    public double[] personalBestGenome

  - ### personalBestFitness

    public Fitness personalBestFitness

- ## Constructor Details

  - ### Particle

    public Particle()

- ## Method Details

  - ### hashCode

    public int hashCode()
    Description copied from class: `Individual`
    Returns a hashcode for the individual, such that individuals which are equals(...) each other always return the same hash code.
    Overrides:
      `hashCode` in class `DoubleVectorIndividual`

  - ### equals

    public boolean equals(Object ind)
    Description copied from class: `Individual`
    Returns true if I am genetically "equal" to ind. This should mostly be interpreted as saying that we are of the same class and that we hold the same data. It should NOT be a pointer comparison.
    Overrides:
      `equals` in class `DoubleVectorIndividual`

  - ### setup

    public void setup(EvolutionState state, Parameter base)
    Description copied from class: `Individual`
    This should be used to set up only those things which you share in common with all other individuals in your species; individual-specific items which make you you should be filled in by Species.newIndividual(...), and modified by breeders.
    Specified by:
      `setup` in interface `Prototype`
    Specified by:
      `setup` in interface `Setup`
    Overrides:
      `setup` in class `DoubleVectorIndividual`
    See Also:
      - `Prototype.setup(EvolutionState,Parameter)`

  - ### clone

    public Object clone()
    Description copied from interface: `Prototype`
    Creates a new individual cloned from a prototype, and suitable to begin use in its own evolutionary context.

    Typically this should be a full "deep" clone. However, you may share certain elements with other objects rather than clone hem, depending on the situation:

    - If you hold objects which are shared with other instances, don't clone them.
    - If you hold objects which must be unique, clone them.
    - If you hold objects which were given to you as a gesture of kindness, and aren't owned by you, you probably shouldn't clone them.
    - DON'T attempt to clone: Singletons, Cliques, or Populations, or Subpopulation.
    - Arrays are not cloned automatically; you may need to clone an array if you're not sharing it with other instances. Arrays have the nice feature of being copyable by calling clone() on them.

    Implementations.

    - If no ancestor of yours implements clone(), and you have no need to do clone deeply, and you are abstract, then you should not declare clone().
    - If no ancestor of yours implements clone(), and you have no need to do clone deeply, and you are not abstract, then you should implement it as follows:

      ``

           public Object clone()
               {
               try
                   {
                   return super.clone();
                   }
               catch ((CloneNotSupportedException e)
                   { throw new InternalError(); } // never happens
               }

    - If no ancestor of yours implements clone(), but you need to deep-clone some things, then you should implement it as follows:

      ``

           public Object clone()
               {
               try
                   {
                   MyObject myobj = (MyObject) (super.clone());

                   // put your deep-cloning code here...
                   }
               catch ((CloneNotSupportedException e)
                   { throw new InternalError(); } // never happens
               return myobj;
               }

    - If an ancestor has implemented clone(), and you also need to deep clone some things, then you should implement it as follows:

      ``

           public Object clone()
               {
               MyObject myobj = (MyObject) (super.clone());

               // put your deep-cloning code here...

               return myobj;
               }

    Specified by:
      `clone` in interface `Prototype`
    Overrides:
      `clone` in class `DoubleVectorIndividual`

  - ### update

    public void update(EvolutionState state, int subpop, int myindex, int thread)

  - ### tweak

    public void tweak(EvolutionState state, double[] globalBest, double velocityCoeff, double personalCoeff, double informantCoeff, double globalCoeff, int thread)

  - ### reset

    public void reset(EvolutionState state, int thread)
    Description copied from class: `DoubleVectorIndividual`
    Initializes the individual by randomly choosing doubles uniformly from mingene to maxgene.
    Overrides:
      `reset` in class `DoubleVectorIndividual`

  - ### setGenomeLength

    public void setGenomeLength(int len)
    Description copied from class: `VectorIndividual`
    Sets the genome length. If the length is longer, then it is filled with a default value (likely 0 or false). This may or may not be a valid value -- you will need to set appropriate values here. The default implementation does nothing; but all subclasses in ECJ implement a subset of this.
    Overrides:
      `setGenomeLength` in class `DoubleVectorIndividual`

  - ### setGenome

    public void setGenome(Object gen)
    Description copied from class: `VectorIndividual`
    Sets the gene array. See getGenome(). The default version does nothing.
    Overrides:
      `setGenome` in class `DoubleVectorIndividual`

  - ### join

    public void join(Object[] pieces)
    Description copied from class: `DoubleVectorIndividual`
    Joins the n pieces and sets the genome to their concatenation.
    Overrides:
      `join` in class `DoubleVectorIndividual`

  - ### printIndividual

    public void printIndividual(EvolutionState state, int log)
    Description copied from class: `Individual`
    Should print the individual in a way that can be read by computer, including its fitness, with a verbosity of Output.V_NO_GENERAL.
    Overrides:
      `printIndividual` in class `Individual`

  - ### printIndividual

    public void printIndividual(EvolutionState state, PrintWriter writer)
    Description copied from class: `Individual`
    Should print the individual in a way that can be read by computer, including its fitness. You can get fitness to print itself at the appropriate time by calling fitness.printFitness(state,log,writer); Usually you should try to use printIndividual(state,log,verbosity) instead -- use this method only if you can't print through the Output facility for some reason.

    The default form of this method simply prints out whether or not the individual has been evaluated, its fitness, and then calls Individual.genotypeToString(). Feel free to override this to produce more sophisticated behavior, though it is rare to need to -- instead you could just override genotypeToString().

    Overrides:
      `printIndividual` in class `Individual`

  - ### readIndividual

    public void readIndividual(EvolutionState state, LineNumberReader reader) throws IOException
    Description copied from class: `Individual`
    Reads in the individual from a form printed by printIndividual(), erasing the previous information stored in this Individual. If you are trying to create an Individual from information read in from a stream or DataInput, see the various newIndividual() methods in Species. The default form of this method simply reads in evaluation information, then fitness information, and then calls parseGenotype() (which you should implement). The Species is not changed or attached, so you may need to do that elsewhere. Feel free to override this method to produce more sophisticated behavior, though it is rare to need to -- instead you could just override parseGenotype().
    Overrides:
      `readIndividual` in class `Individual`
    Throws:
      `IOException`

  - ### writeIndividual

    public void writeIndividual(EvolutionState state, DataOutput dataOutput) throws IOException
    Description copied from class: `Individual`
    Writes the binary form of an individual out to a DataOutput. This is not for serialization: the object should only write out the data relevant to the object sufficient to rebuild it from a DataInput. The Species will be reattached later, and you should not write it. The default version of this method writes the evaluated and fitness information, then calls writeGenotype() to write the genotype information. Feel free to override this method to produce more sophisticated behavior, though it is rare to need to -- instead you could just override writeGenotype().
    Overrides:
      `writeIndividual` in class `Individual`
    Throws:
      `IOException`

  - ### readIndividual

    public void readIndividual(EvolutionState state, DataInput dataInput) throws IOException
    Description copied from class: `Individual`
    Reads the binary form of an individual from a DataInput, erasing the previous information stored in this Individual. This is not for serialization: the object should only read in the data written out via printIndividual(state,dataInput). If you are trying to create an Individual from information read in from a stream or DataInput, see the various newIndividual() methods in Species. The default form of this method simply reads in evaluation information, then fitness information, and then calls readGenotype() (which you will need to override -- its default form simply throws an error). The Species is not changed or attached, so you may need to do that elsewhere. Feel free to override this method to produce more sophisticated behavior, though it is rare to need to -- instead you could just override readGenotype().
    Overrides:
      `readIndividual` in class `Individual`
    Throws:
      `IOException`