Package ec.neat

# Class NEATNetwork

java.lang.Object
ec.neat.NEATNetwork

All Implemented Interfaces:
  `Prototype`, `Setup`, `Serializable`, `Cloneable`

public class NEATNetwork extends Object implements Prototype
NEATNetwork is the phenotype of NEATIndividual. It share the same copy of nodes and genes (links) with its corresponding NEATIndividual. This class handles all operations that is critical in evaluation of the individuals.

See Also:
  - Serialized Form

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `NEATIndividual`
  `individual`
  The neat individual we belong to
  `ArrayList<NEATNode>`
  `inputs`
  A list of input nodes for this network.
  `ArrayList<NEATNode>`
  `nodes`
  A list of all nodes for this network.
  `ArrayList<NEATNode>`
  `outputs`
  A list of output nodes for this network.
  `static final String`
  `P_NETWORK`
  `static final double`
  `SIGMOID_SLOPE`
  constant used for the sigmoid function

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `NEATNetwork()`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `activate(EvolutionState state)`
  Activates the net such that all outputs are active.
  `void`
  `addInput(NEATNode node)`
  Add a new input node.
  `void`
  `addOutput(NEATNode node)`
  Add a new output node.
  `void`
  `buildNetwork(NEATIndividual individual)`
  Create the phenotype (network) from the genotype (genome).
  `Object`
  `clone()`
  Creates a new individual cloned from a prototype, and suitable to begin use in its own evolutionary context.
  `Parameter`
  `defaultBase()`
  Returns the default base for this prototype.
  `boolean`
  `equals(Object obj)`
  `void`
  `flush()`
  `double[]`
  `getOutputResults()`
  Produces an array of activation results, one per output node.
  `static boolean[]`
  `hasPath(EvolutionState state, NEATNode toNode, NEATNode fromNode, int threshold)`
  This checks a POTENTIAL link between start from fromNode to toNode to use count and threshold to jump out in the case of an infinite loop.
  `static void`
  `hasPath(EvolutionState state, NEATNode toNode, NEATNode fromNode, HashSet<NEATNode> set, int level, int threshold, boolean[] results)`
  The helper function to check if there is a path from fromNode to toNode.
  `void`
  `loadSensors(double[] vals)`
  Takes an array of sensor values and loads it into SENSOR inputs ONLY.
  `int`
  `maxDepth()`
  Find the maximum number of neurons between an output and an input.
  `boolean`
  `outputOff()`
  Check if not all output are active.
  `void`
  `setup(EvolutionState state, Parameter base)`
  Sets up the object by reading it from the parameters stored in state, built off of the parameter base base.

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

  `finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Field Details

  - ### P_NETWORK

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

  - ### SIGMOID_SLOPE

    public static final double SIGMOID_SLOPE
    constant used for the sigmoid function
    See Also:
      - Constant Field Values

  - ### individual

    public NEATIndividual individual
    The neat individual we belong to

  - ### nodes

    public ArrayList<NEATNode> nodes
    A list of all nodes for this network.

  - ### inputs

    public ArrayList<NEATNode> inputs
    A list of input nodes for this network.

  - ### outputs

    public ArrayList<NEATNode> outputs
    A list of output nodes for this network.

- ## Constructor Details

  - ### NEATNetwork

    public NEATNetwork()

- ## Method Details

  - ### setup

    public void setup(EvolutionState state, Parameter base)
    Description copied from interface: `Prototype`
    Sets up the object by reading it from the parameters stored in state, built off of the parameter base base. If an ancestor implements this method, be sure to call super.setup(state,base); before you do anything else.

    For prototypes, setup(...) is typically called once for the prototype instance; cloned instances do not receive the setup(...) call. setup(...) may be called more than once; the only guarantee is that it will get called at least once on an instance or some "parent" object from which it was ultimately cloned.

    Specified by:
      `setup` in interface `Prototype`
    Specified by:
      `setup` in interface `Setup`

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

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

  - ### equals

    public boolean equals(Object obj)
    Overrides:
      `equals` in class `Object`

  - ### flush

    public void flush()

  - ### activate

    public void activate(EvolutionState state)
    Activates the net such that all outputs are active.

  - ### addInput

    public void addInput(NEATNode node)
    Add a new input node.

  - ### addOutput

    public void addOutput(NEATNode node)
    Add a new output node.

  - ### loadSensors

    public void loadSensors(double[] vals)
    Takes an array of sensor values and loads it into SENSOR inputs ONLY.

  - ### getOutputResults

    public double[] getOutputResults()
    Produces an array of activation results, one per output node.

  - ### hasPath

    public static boolean[] hasPath(EvolutionState state, NEATNode toNode, NEATNode fromNode, int threshold)
    This checks a POTENTIAL link between start from fromNode to toNode to use count and threshold to jump out in the case of an infinite loop.

  - ### hasPath

    public static void hasPath(EvolutionState state, NEATNode toNode, NEATNode fromNode, HashSet<NEATNode> set, int level, int threshold, boolean[] results)
    The helper function to check if there is a path from fromNode to toNode.

  - ### outputOff

    public boolean outputOff()
    Check if not all output are active.

  - ### maxDepth

    public int maxDepth()
    Find the maximum number of neurons between an output and an input.

  - ### buildNetwork

    public void buildNetwork(NEATIndividual individual)
    Create the phenotype (network) from the genotype (genome). One main task of method is to link the incomingGenes for each nodes.