Package ec.neat

# Class NEATIndividual

java.lang.Object
ec.Individual
ec.vector.VectorIndividual
ec.vector.GeneVectorIndividual
ec.neat.NEATIndividual

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

public class NEATIndividual extends GeneVectorIndividual
NEATIndividual is GeneVectorIndividual with NEATNetwork as phenotype. It contains the genome of the individual and also the nodes (NEATNode) for phenotype. It's the combination of Organism class and Genome class in original code. Most of the mutation and crossover happen in this class.

Parameters

base.`network` Classname, = ec.neat.NEATNetwork | Class of network in the individual

Parameter bases

base.`network` | network in the individual

Default Base
neat.individual

See Also:
  - Serialized Form

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `double`
  `adjustedFitness`
  Fitness after the adjustment.
  `boolean`
  `champion`
  Marks the subspecies champion, which is the individual who has the highest fitness with the subspecies.
  `boolean`
  `eliminate`
  Marker for destruction of inferior individual.
  `double`
  `expectedOffspring`
  Number of children this individual may have for next generation.
  `int`
  `generation`
  Tells which generation this individual is from.
  `double`
  `highFit`
  debug variable, highest fitness of champion
  `ArrayList<NEATNode>`
  `nodes`
  All the node of this individual.
  `boolean`
  `popChampion`
  Marks the best individual in current generation of the population.
  `boolean`
  `popChampionChild`
  Marks the duplicate child of a champion (for tracking purposes).
  `NEATSubspecies`
  `subspecies`
  The individual's subpecies
  `int`
  `superChampionOffspring`
  Number of reserved offspring for a population leader.
  `int`
  `timeAlive`
  When playing in real-time allows knowing the maturity of an individual

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

  `genome, P_GENEVECTORINDIVIDUAL`

  ### Fields inherited from class ec.Individual

  `evaluated, EVALUATED_PREAMBLE, fitness, P_INDIVIDUAL, species`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `NEATIndividual()`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `addGene(NEATGene[] appendGenes)`
  We append new gene(s) to the current genome
  `Object`
  `clone()`
  Creates a new individual cloned from a prototype, and suitable to begin use in its own evolutionary context.
  `NEATNetwork`
  `createNetwork()`
  `void`
  `createNodeCopyIfMissing(ArrayList<NEATNode> nodeList, NEATNode node)`
  Create the node if the nodeList do not have that node.The nodes in the nodeList is guarantee in ascending order according to node's nodeId.
  `NEATIndividual`
  `crossover(EvolutionState state, int thread, NEATIndividual secondParent)`
  Crossover function.
  `Parameter`
  `defaultBase()`
  Returns the default base for this prototype.
  `void`
  `defaultMutate(EvolutionState state, int thread)`
  Mutation function, determine which mutation is going to proceed with certain probabilities parameters.
  `boolean`
  `equals(Object obj)`
  Returns true if I am genetically "equal" to ind.
  `String`
  `genotypeToString()`
  This method is used to output a individual that is same as the format in start genome file.
  `int`
  `getGeneInnovationNumberSup()`
  Get the upperbound for the innovation number, used in Initializer.
  `int`
  `getNodeIdSup()`
  Get the upperbound for the node id, used in Initializer.
  `boolean`
  `hasGene(ArrayList<Gene> genome, Gene gene)`
  Test if a genome has certain gene.
  `int`
  `hashCode()`
  Returns a hashcode for the individual, such that individuals which are equals(...) each other always return the same hash code.
  `NEATIndividual`
  `mateMultipoint(EvolutionState state, int thread, NEATIndividual secondParent, boolean averageFlag)`
  Doing crossover from two parent at multiple points in the genome.
  `NEATIndividual`
  `mateSinglepoint(EvolutionState state, int thread, NEATIndividual secondParent)`
  Deprecated.
  `void`
  `mutateAddLink(EvolutionState state, int thread)`
  Try to add a new gene (link) into the current genome.
  `void`
  `mutateAddNode(EvolutionState state, int thread)`
  Add a new node into this individual.
  `void`
  `mutateGeneReenable()`
  Reenable a gene if it's disabled.
  `void`
  `mutateLinkWeights(EvolutionState state, int thread, NEATSpecies species, double power, double rate, NEATSpecies.MutationType mutationType)`
  Mutate the weights of the genes
  `void`
  `mutateToggleEnable(EvolutionState state, int thread, int times)`
  Randomly enable or disable a gene.
  `protected void`
  `parseGenotype(EvolutionState state, LineNumberReader reader)`
  This method is used to read a gene in start genome from file.
  `void`
  `parseNodes(EvolutionState state, LineNumberReader reader)`
  Create the nodes from the reader, and calls readNode method on each node.
  `void`
  `reset(EvolutionState state, int thread)`
  Initializes an individual with minimal structure.
  `void`
  `reset(ArrayList<NEATNode> nodeList, ArrayList<Gene> genes)`
  Reset the individual with given nodes and genome
  `void`
  `setGeneration(EvolutionState state)`
  Set the born generation of this individual.
  `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.
  `String`
  `toString()`
  This method convert the individual in to human readable format.

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

  `cloneGenes, defaultCrossover, genomeLength, genotypeToStringForHumans, getGenome, join, readGenotype, setGenome, setGenomeLength, split, writeGenotype`

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

  `reset, size`

  ### Methods inherited from class ec.Individual

  `compareTo, distanceTo, merge, printIndividual, printIndividual, printIndividual, printIndividualForHumans, printIndividualForHumans, readIndividual, readIndividual, writeIndividual`

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

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

- ## Field Details

  - ### adjustedFitness

    public double adjustedFitness
    Fitness after the adjustment.

  - ### subspecies

    public NEATSubspecies subspecies
    The individual's subpecies

  - ### expectedOffspring

    public double expectedOffspring
    Number of children this individual may have for next generation.

  - ### generation

    public int generation
    Tells which generation this individual is from.

  - ### eliminate

    public boolean eliminate
    Marker for destruction of inferior individual.

  - ### champion

    public boolean champion
    Marks the subspecies champion, which is the individual who has the highest fitness with the subspecies.

  - ### superChampionOffspring

    public int superChampionOffspring
    Number of reserved offspring for a population leader. This is used for delta coding.

  - ### popChampion

    public boolean popChampion
    Marks the best individual in current generation of the population.

  - ### popChampionChild

    public boolean popChampionChild
    Marks the duplicate child of a champion (for tracking purposes).

  - ### highFit

    public double highFit
    debug variable, highest fitness of champion

  - ### timeAlive

    public int timeAlive
    When playing in real-time allows knowing the maturity of an individual

  - ### nodes

    public ArrayList<NEATNode> nodes
    All the node of this individual. Nodes are arranged so that the first part of the nodes are SENSOR nodes.

- ## Constructor Details

  - ### NEATIndividual

    public NEATIndividual()

- ## Method Details

  - ### 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 `GeneVectorIndividual`
    See Also:
      - `Prototype.setup(EvolutionState,Parameter)`

  - ### defaultBase

    public Parameter defaultBase()
    Description copied from interface: `Prototype`
    Returns the default base for this prototype. This should generally be implemented by building off of the static base() method on the DefaultsForm object for the prototype's package. This should be callable during setup(...).
    Specified by:
      `defaultBase` in interface `Prototype`
    Overrides:
      `defaultBase` in class `GeneVectorIndividual`

  - ### reset

    public void reset(EvolutionState state, int thread)
    Initializes an individual with minimal structure.
    Overrides:
      `reset` in class `GeneVectorIndividual`

  - ### reset

    public void reset(ArrayList<NEATNode> nodeList, ArrayList<Gene> genes)
    Reset the individual with given nodes and genome

  - ### 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 `GeneVectorIndividual`

  - ### equals

    public boolean equals(Object obj)
    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 `GeneVectorIndividual`

  - ### setGeneration

    public void setGeneration(EvolutionState state)
    Set the born generation of this individual.

  - ### getNodeIdSup

    public int getNodeIdSup()
    Get the upperbound for the node id, used in Initializer.

  - ### getGeneInnovationNumberSup

    public int getGeneInnovationNumberSup()
    Get the upperbound for the innovation number, used in Initializer.

  - ### 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 `GeneVectorIndividual`

  - ### genotypeToString

    public String genotypeToString()
    This method is used to output a individual that is same as the format in start genome file.
    Overrides:
      `genotypeToString` in class `GeneVectorIndividual`

  - ### parseGenotype

    protected void parseGenotype(EvolutionState state, LineNumberReader reader) throws IOException
    This method is used to read a gene in start genome from file. It will then calls the corresponding methods to parse genome and nodes respectively.
    Overrides:
      `parseGenotype` in class `GeneVectorIndividual`
    Throws:
      `IOException`

  - ### parseNodes

    public void parseNodes(EvolutionState state, LineNumberReader reader) throws IOException
    Create the nodes from the reader, and calls readNode method on each node.
    Throws:
      `IOException`

  - ### addGene

    public void addGene(NEATGene[] appendGenes)
    We append new gene(s) to the current genome

  - ### mutateLinkWeights

    public void mutateLinkWeights(EvolutionState state, int thread, NEATSpecies species, double power, double rate, NEATSpecies.MutationType mutationType)
    Mutate the weights of the genes

  - ### mutateAddLink

    public void mutateAddLink(EvolutionState state, int thread)
    Try to add a new gene (link) into the current genome.

  - ### mutateAddNode

    public void mutateAddNode(EvolutionState state, int thread)
    Add a new node into this individual.

  - ### mutateToggleEnable

    public void mutateToggleEnable(EvolutionState state, int thread, int times)
    Randomly enable or disable a gene.

  - ### mutateGeneReenable

    public void mutateGeneReenable()
    Reenable a gene if it's disabled.

  - ### defaultMutate

    public void defaultMutate(EvolutionState state, int thread)
    Mutation function, determine which mutation is going to proceed with certain probabilities parameters.
    Overrides:
      `defaultMutate` in class `GeneVectorIndividual`

  - ### crossover

    public NEATIndividual crossover(EvolutionState state, int thread, NEATIndividual secondParent)
    Crossover function. Unlike defaultCrossover, this does not do destructive crossover. It will create a new individual as the crossover of the new parents.

  - ### mateSinglepoint

    @Deprecated public NEATIndividual mateSinglepoint(EvolutionState state, int thread, NEATIndividual secondParent)
    Deprecated.

  - ### hasGene

    public boolean hasGene(ArrayList<Gene> genome, Gene gene)
    Test if a genome has certain gene.

  - ### createNodeCopyIfMissing

    public void createNodeCopyIfMissing(ArrayList<NEATNode> nodeList, NEATNode node)
    Create the node if the nodeList do not have that node.The nodes in the nodeList is guarantee in ascending order according to node's nodeId.

  - ### mateMultipoint

    public NEATIndividual mateMultipoint(EvolutionState state, int thread, NEATIndividual secondParent, boolean averageFlag)
    Doing crossover from two parent at multiple points in the genome.

  - ### createNetwork

    public NEATNetwork createNetwork()

  - ### toString

    public String toString()
    This method convert the individual in to human readable format. It can be useful in debugging.
    Overrides:
      `toString` in class `Individual`