Recurrent

abstract def activate(neuron: Int, inputs: Traversable[(S, W)]): S

abstract def change(newstate: S, oldstate: S): Double

abstract def inputNeurons: Vector[Int]

abstract def inputsAndWeights(neuron: Int, state: IndexedSeq[S]): Vector[(S, W)]

abstract def outNeighbours(neuron: Int): Vector[Int]

abstract def state: Vector[S]

abstract def updateState(state: Traversable[S], neuronsValues: Traversable[(Int, S)]): Vector[S]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def activate(steps: Int, inputValues: Seq[S]): Vector[S]

Activating the network means computing the output values for all neurons simultaneously.

def activateOnce(state: Vector[S]): Vector[S]

def activateUntilStable(maxsteps: Int, stabilityThreshold: Double, inputValues: Seq[S]): (Int, Double, Vector[S])

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def propagate(steps: Int, inputValues: Seq[S]): Vector[S]

To propagate the inputValues means initialising the input neurons to the input values, then activating the neurons connected to the input, and successively activating the rest of the network.

def propagateOnce(state: IndexedSeq[S], currentNeurons: IndexedSeq[Int]): (Vector[S], Vector[Int])

returns the nextstate resulting from activating the neurons leading out of those in currentNeurons, as those neurons

def propagateUntilStable(maxsteps: Int, stabilityThreshold: Double, inputValues: Seq[S]): (Int, Double, Vector[S])

def propagateUntilStableRec(maxsteps: Int, stabilityThreshold: Double, state: Vector[S], currentNeurons: IndexedSeq[Int], step: Int = 0, avgchange: Double = 0.0): (Int, Double, Vector[S])

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit