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
NodeActivation.Key<T>	key
TreeMap<NodeActivation.Key,NodeActivation>	outputs
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)
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)

Methods inherited from class java.lang.Object

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

Field Detail

id

public final int id

key

public final NodeActivation.Key<T extends Node> key

doc

public final Document doc

visitedNeuronTrain

public long visitedNeuronTrain

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)

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)

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)