org.aika.lattice

Class NodeActivation<T extends Node>

java.lang.Object

org.aika.lattice.NodeActivation<T>

All Implemented Interfaces:

Comparable<NodeActivation>

Direct Known Subclasses:

Activation

public class NodeActivation<T extends Node>
extends Object
implements Comparable<NodeActivation>

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	NodeActivation.Key<T extends Node>

Field Summary

Fields

Modifier and Type	Field and Description
Document	doc
int	id
TreeMap<NodeActivation.Key,NodeActivation>	inputs
boolean	isRemoved
boolean	isTrainingAct
NodeActivation.Key<T>	key
TreeMap<NodeActivation.Key,NodeActivation>	outputs
int	removedId
static int	removedIdCounter
static long	visitedCounter
long	visitedNeuronTrain

Constructor Summary

Constructors

Constructor and Description
NodeActivation(int id, Document doc, NodeActivation.Key<T> key)
NodeActivation(int id, Document doc, T n, Range pos, Integer rid, InterprNode o)

Method Summary

Modifier and Type	Method and Description
static int	compare(NodeActivation a, NodeActivation b)
int	compareTo(NodeActivation act)
<T extends Node> boolean	filter(T n, Integer rid, Range r, Range.Operator begin, Range.Operator end, InterprNode o, InterprNode.Relation or)
static <T extends Node,A extends NodeActivation<T>> A	get(Document doc, T n, Integer rid, Range r, Range.Operator begin, Range.Operator end, InterprNode o, InterprNode.Relation or)
static <T extends Node,A extends NodeActivation<T>> A	get(Document doc, T n, NodeActivation.Key ak)
static <T extends Node,A extends NodeActivation<T>> Stream<A>	getActivationsByRange(Node.ThreadState<T,A> th, T n, Integer rid, Range r, Range.Operator begin, Range.Operator end, InterprNode o, InterprNode.Relation or)
static NodeActivation	getNextSignal(Node n, Document doc, int from, Integer rid, InterprNode o, boolean dir, boolean inv)
void	link(Collection<NodeActivation> inputActs)
static Stream<NodeActivation>	select(Document doc, Integer rid, Range r, Range.Operator begin, Range.Operator end, InterprNode o, InterprNode.Relation or)
static <T extends Node,A extends NodeActivation<T>> Stream<A>	select(Document doc, T n, Integer rid, Range r, Range.Operator begin, Range.Operator end, InterprNode o, InterprNode.Relation or)
static <T extends Node,A extends NodeActivation<T>> Stream<A>	select(Node.ThreadState<T,A> th, T n, Integer rid, Range r, Range.Operator begin, Range.Operator end, InterprNode o, InterprNode.Relation or)
String	toString(Document doc)
void	unlink()
void	unlink(Collection<NodeActivation> inputActs)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

id

public int id

key

public final NodeActivation.Key<T extends Node> key

doc

public Document doc

isRemoved

public boolean isRemoved

removedId

public int removedId

visitedNeuronTrain

public long visitedNeuronTrain

removedIdCounter

public static int removedIdCounter

visitedCounter

public static long visitedCounter

isTrainingAct

public boolean isTrainingAct

inputs

public TreeMap<NodeActivation.Key,NodeActivation> inputs

outputs

public TreeMap<NodeActivation.Key,NodeActivation> outputs

Constructor Detail

NodeActivation

public NodeActivation(int id,
                      Document doc,
                      NodeActivation.Key<T> key)

NodeActivation

public NodeActivation(int id,
                      Document doc,
                      T n,
                      Range pos,
                      Integer rid,
                      InterprNode o)

Method Detail

link

public void link(Collection<NodeActivation> inputActs)

unlink

public void unlink(Collection<NodeActivation> inputActs)

unlink

public void unlink()

get

public static <T extends Node,A extends NodeActivation<T>> A get(Document doc,
                                                                 T n,
                                                                 Integer rid,
                                                                 Range r,
                                                                 Range.Operator begin,
                                                                 Range.Operator end,
                                                                 InterprNode o,
                                                                 InterprNode.Relation or)

get

public static <T extends Node,A extends NodeActivation<T>> A get(Document doc,
                                                                 T n,
                                                                 NodeActivation.Key ak)

getNextSignal

public static NodeActivation getNextSignal(Node n,
                                           Document doc,
                                           int from,
                                           Integer rid,
                                           InterprNode o,
                                           boolean dir,
                                           boolean inv)

select

public static Stream<NodeActivation> select(Document doc,
                                            Integer rid,
                                            Range r,
                                            Range.Operator begin,
                                            Range.Operator end,
                                            InterprNode o,
                                            InterprNode.Relation or)

select

public static <T extends Node,A extends NodeActivation<T>> Stream<A> select(Document doc,
                                                                            T n,
                                                                            Integer rid,
                                                                            Range r,
                                                                            Range.Operator begin,
                                                                            Range.Operator end,
                                                                            InterprNode o,
                                                                            InterprNode.Relation or)

select

public static <T extends Node,A extends NodeActivation<T>> Stream<A> select(Node.ThreadState<T,A> th,
                                                                            T n,
                                                                            Integer rid,
                                                                            Range r,
                                                                            Range.Operator begin,
                                                                            Range.Operator end,
                                                                            InterprNode o,
                                                                            InterprNode.Relation or)

getActivationsByRange

public static <T extends Node,A extends NodeActivation<T>> Stream<A> getActivationsByRange(Node.ThreadState<T,A> th,
                                                                                           T n,
                                                                                           Integer rid,
                                                                                           Range r,
                                                                                           Range.Operator begin,
                                                                                           Range.Operator end,
                                                                                           InterprNode o,
                                                                                           InterprNode.Relation or)

filter

public <T extends Node> boolean filter(T n,
                                       Integer rid,
                                       Range r,
                                       Range.Operator begin,
                                       Range.Operator end,
                                       InterprNode o,
                                       InterprNode.Relation or)

toString

public String toString(Document doc)

compareTo

public int compareTo(NodeActivation act)

Specified by:

compareTo in interface Comparable<NodeActivation>

compare

public static int compare(NodeActivation a,
                          NodeActivation b)