Node (aika 0.1 API)

java.lang.Object
- org.aika.network.neuron.lattice.Node

All Implemented Interfaces:

Comparable<Node>

Direct Known Subclasses:

InputNode, LogicNode
```
public abstract class Node
extends Object
implements Comparable<Node>
```
Author:

Lukas Molzberger

Field Summary

Fields
Modifier and Type	Field and Description
`NavigableMap<Activation.Key,Activation>`	`activations`
`TreeMap<InputNode,AndNode>`	`andChildren`
`TreeMap<InputNode,AndNode>`	`andChildrenWithinDocument`
`boolean`	`countingMode`
`static int`	`currentNodeId`
`int`	`frequency`
`boolean`	`frequencyHasChanged`
`int`	`id`
`boolean`	`isBlocked`
`boolean`	`isPredefined`
`boolean`	`isRemoved`
`int`	`isRemovedId`
`static int`	`isRemovedIdCounter`
`int`	`level`
`static int`	`minFrequency`
`int`	`n`
`Neuron`	`neuron`
`TreeSet<OrNode>`	`orChildren`

Constructor Summary

Constructors
Constructor and Description

Node(int level)

Constructors
Constructor and Description
`Node(int level)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`Activation`	`addActivationAndPropagate(Iteration t, LatticeQueue queue, Activation.Key ak, int recurrentCount, Option exclusionOption, TreeSet<Activation> inputActs)`
`Activation`	`addActivationInternal(Iteration t, Activation.Key ak)`
`static void`	`addNeuron(Neuron n, Set<Synapse> inputs)`
`abstract void`	`cleanup()`
`void`	`clearActivations()`
`protected abstract void`	`collectNodeAndRefinements(Set<InputNode> inputs)`
`int`	`compareTo(Node n)`
`boolean`	`computeAndParents(SortedSet<InputNode> inputs, Map<InputNode,Node> parents, Set<Node> visited)`
`static Map<AndNode,Set<Synapse>>`	`computePredefinedAndNodes(Neuron n, Set<Node> outputs, Map<AndNode,Set<Synapse>> previousLevel)`
`static Map<InputNode,Set<Synapse>>`	`computePredefinedInputNodes(Neuron n, Set<Node> outputs, Set<Synapse> inputs)`
`static Map<AndNode,Set<Synapse>>`	`computePredefinedSecondLevelAndNodes(Neuron n, Set<Node> outputs, Map<InputNode,Set<Synapse>> previousLevel)`
`abstract double`	`computeSynapseWeightSum(Neuron n)`
`void`	`countActivation(Activation.Key ak, Option so)`
`abstract void`	`expandToNextLevel(Iteration t, LatticeQueue queue, Activation act, Option conflict, boolean train)`
`Activation`	`getActivation(Activation.Key ak)`
`Activation`	`getActivation(Integer pos)`
`Activation`	`getActivation(Integer pos, Option o)`
`Activation`	`getActivation(Integer pos, Option o, int fired)`
`Iterable<Activation>`	`getActivations()`
`Collection<Activation>`	`getActivations(Integer pos)`
`Set<AndNode>`	`getAndChildPatterns(Set<AndNode> results)`
`Set<Activation>`	`getMatchingActivations(Integer pos, Option o, boolean direction, boolean includeShadowed)`
`abstract double`	`getWeight()`
`boolean`	`isFrequentOrPredefined()`
`boolean`	`isFrequentOrPredefined(int freq)`
`abstract String`	`logicToString()`
`void`	`propagateAddedActivation(Iteration t, LatticeQueue queue, Activation act)`
`void`	`propagateRemovedActivation(Iteration t, LatticeQueue queue, Activation act)`
`void`	`remove()`
`void`	`removeActivationAndPropagate(Iteration t, LatticeQueue queue, Activation.Key ak)`
`Activation`	`removeActivationInternal(Iteration t, Activation.Key ak)`
`void`	`removeFromNextLevel(Iteration t, LatticeQueue queue, Activation.Key ak)`
`abstract void`	`setActivationsEmpty()`
`String`	`toSimpleString()`
`String`	`toString()`
`void`	`train(Iteration t)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

minFrequency
```
public static int minFrequency
```

level
```
public int level
```

currentNodeId
```
public static int currentNodeId
```

id
```
public int id
```

countingMode
```
public boolean countingMode
```

isPredefined
```
public boolean isPredefined
```

isBlocked
```
public boolean isBlocked
```

isRemoved
```
public boolean isRemoved
```

isRemovedId
```
public int isRemovedId
```

isRemovedIdCounter
```
public static int isRemovedIdCounter
```

frequency
```
public int frequency
```

frequencyHasChanged
```
public boolean frequencyHasChanged
```

n
```
public int n
```

activations

public NavigableMap<Activation.Key,Activation> activations

neuron
```
public Neuron neuron
```

andChildrenWithinDocument

public TreeMap<InputNode,AndNode> andChildrenWithinDocument

andChildren

public TreeMap<InputNode,AndNode> andChildren

orChildren
```
public TreeSet<OrNode> orChildren
```

Constructor Detail
- Node
```
public Node(int level)
```

Method Detail

getWeight
```
public abstract double getWeight()
```

cleanup
```
public abstract void cleanup()
```

setActivationsEmpty

public abstract void setActivationsEmpty()

expandToNextLevel

public abstract void expandToNextLevel(Iteration t,
                                       LatticeQueue queue,
                                       Activation act,
                                       Option conflict,
                                       boolean train)

collectNodeAndRefinements

protected abstract void collectNodeAndRefinements(Set<InputNode> inputs)

computeSynapseWeightSum

public abstract double computeSynapseWeightSum(Neuron n)

logicToString

public abstract String logicToString()

train
```
public void train(Iteration t)
```

addActivationAndPropagate

public Activation addActivationAndPropagate(Iteration t,
                                            LatticeQueue queue,
                                            Activation.Key ak,
                                            int recurrentCount,
                                            Option exclusionOption,
                                            TreeSet<Activation> inputActs)

propagateAddedActivation

public void propagateAddedActivation(Iteration t,
                                     LatticeQueue queue,
                                     Activation act)

addActivationInternal

public Activation addActivationInternal(Iteration t,
                                        Activation.Key ak)

removeActivationAndPropagate

public void removeActivationAndPropagate(Iteration t,
                                         LatticeQueue queue,
                                         Activation.Key ak)

propagateRemovedActivation

public void propagateRemovedActivation(Iteration t,
                                       LatticeQueue queue,
                                       Activation act)

removeActivationInternal

public Activation removeActivationInternal(Iteration t,
                                           Activation.Key ak)

countActivation

public void countActivation(Activation.Key ak,
                            Option so)

getActivations

public Collection<Activation> getActivations(Integer pos)

getActivation

public Activation getActivation(Integer pos,
                                Option o)

getActivation

public Activation getActivation(Integer pos,
                                Option o,
                                int fired)

getActivation

public Activation getActivation(Integer pos)

getActivation

public Activation getActivation(Activation.Key ak)

getActivations

public Iterable<Activation> getActivations()

getMatchingActivations

public Set<Activation> getMatchingActivations(Integer pos,
                                              Option o,
                                              boolean direction,
                                              boolean includeShadowed)

clearActivations
```
public void clearActivations()
```

isFrequentOrPredefined

public boolean isFrequentOrPredefined(int freq)

isFrequentOrPredefined

public boolean isFrequentOrPredefined()

getAndChildPatterns

public Set<AndNode> getAndChildPatterns(Set<AndNode> results)

computeAndParents

public boolean computeAndParents(SortedSet<InputNode> inputs,
                                 Map<InputNode,Node> parents,
                                 Set<Node> visited)

addNeuron

public static void addNeuron(Neuron n,
                             Set<Synapse> inputs)

computePredefinedInputNodes

public static Map<InputNode,Set<Synapse>> computePredefinedInputNodes(Neuron n,
                                                                      Set<Node> outputs,
                                                                      Set<Synapse> inputs)

computePredefinedSecondLevelAndNodes

public static Map<AndNode,Set<Synapse>> computePredefinedSecondLevelAndNodes(Neuron n,
                                                                             Set<Node> outputs,
                                                                             Map<InputNode,Set<Synapse>> previousLevel)

computePredefinedAndNodes

public static Map<AndNode,Set<Synapse>> computePredefinedAndNodes(Neuron n,
                                                                  Set<Node> outputs,
                                                                  Map<AndNode,Set<Synapse>> previousLevel)

removeFromNextLevel

public void removeFromNextLevel(Iteration t,
                                LatticeQueue queue,
                                Activation.Key ak)

remove
```
public void remove()
```

toString
```
public String toString()
```
Overrides:

toString in class Object

toSimpleString
```
public String toSimpleString()
```

compareTo
```
public int compareTo(Node n)
```
Specified by:

compareTo in interface Comparable<Node>

Class Node

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

minFrequency

level

currentNodeId

id

countingMode

isPredefined

isBlocked

isRemoved

isRemovedId

isRemovedIdCounter

frequency

frequencyHasChanged

n

activations

neuron

andChildrenWithinDocument

andChildren

orChildren

Constructor Detail

Node

Method Detail

getWeight

cleanup

setActivationsEmpty

expandToNextLevel

collectNodeAndRefinements

computeSynapseWeightSum

logicToString

train

addActivationAndPropagate

propagateAddedActivation

addActivationInternal

removeActivationAndPropagate

propagateRemovedActivation

removeActivationInternal

countActivation

getActivations

getActivation

getActivation

getActivation

getActivation

getActivations

getMatchingActivations

clearActivations

isFrequentOrPredefined

isFrequentOrPredefined

getAndChildPatterns

computeAndParents

addNeuron

computePredefinedInputNodes

computePredefinedSecondLevelAndNodes

computePredefinedAndNodes

removeFromNextLevel

remove

toString

toSimpleString

compareTo