NEATIndividual

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

All Implemented Interfaces:

Prototype, Setup, java.io.Serializable, java.lang.Cloneable, java.lang.Comparable
```
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 and 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
`java.util.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 and Description

NEATIndividual()

Constructors
Constructor and Description
`NEATIndividual()`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addGene(NEATGene[] appendGenes)` We append new gene(s) to the current genome
`java.lang.Object`	`clone()` Creates a new individual cloned from a prototype, and suitable to begin use in its own evolutionary context.
`NEATNetwork`	`createNetwork()`
`void`	`createNodeCopyIfMissing(java.util.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(java.lang.Object obj)` Returns true if I am genetically "equal" to ind.
`java.lang.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(java.util.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, java.io.LineNumberReader reader)` This method is used to read a gene in start genome from file.
`void`	`parseNodes(EvolutionState state, java.io.LineNumberReader reader)` Create the nodes from the reader, and calls readNode method on each node.
`void`	`reset(java.util.ArrayList<NEATNode> nodeList, java.util.ArrayList<Gene> genes)` Reset the individual with given nodes and genome
`void`	`reset(EvolutionState state, int thread)` Initializes an individual with minimal structure.
`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.
`java.lang.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 Detail
  - 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 java.util.ArrayList<NEATNode> nodes
```
    All the node of this individual. Nodes are arranged so that the first part of the nodes are SENSOR nodes.
- Constructor Detail
  - NEATIndividual
```
public NEATIndividual()
```
- Method Detail
  - 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(java.util.ArrayList<NEATNode> nodeList,
                  java.util.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(java.lang.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 java.lang.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 java.lang.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,
                             java.io.LineNumberReader reader)
                      throws java.io.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:
    
    java.io.IOException
  - parseNodes
```
public void parseNodes(EvolutionState state,
                       java.io.LineNumberReader reader)
                throws java.io.IOException
```
    Create the nodes from the reader, and calls readNode method on each node.
    
    Throws:
    
    java.io.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(java.util.ArrayList<Gene> genome,
                       Gene gene)
```
    Test if a genome has certain gene.
  - createNodeCopyIfMissing
```
public void createNodeCopyIfMissing(java.util.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 java.lang.String toString()
```
    This method convert the individual in to human readable format. It can be useful in debugging.
    
    Overrides:
    
    toString in class Individual

Class NEATIndividual

Field Summary

Fields inherited from class ec.vector.GeneVectorIndividual

Fields inherited from class ec.Individual

Constructor Summary

Method Summary

Methods inherited from class ec.vector.GeneVectorIndividual

Methods inherited from class ec.vector.VectorIndividual

Methods inherited from class ec.Individual

Methods inherited from class java.lang.Object

Field Detail

adjustedFitness

subspecies

expectedOffspring

generation

eliminate

champion

superChampionOffspring

popChampion

popChampionChild

highFit

timeAlive

nodes

Constructor Detail

NEATIndividual

Method Detail

setup

defaultBase

reset

reset

hashCode

equals

setGeneration

getNodeIdSup

getGeneInnovationNumberSup

clone

genotypeToString

parseGenotype

parseNodes

addGene

mutateLinkWeights

mutateAddLink

mutateAddNode

mutateToggleEnable

mutateGeneReenable

defaultMutate

crossover

mateSinglepoint

hasGene

createNodeCopyIfMissing

mateMultipoint

createNetwork

toString