BlocksWithGC

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def BisGradient(commRadius: Double = 0.2, lagMetric: ⇒ Double = nbrLag().toMillis): (BlocksWithGC.this)#Gradient

def C[P, V](potential: P, acc: (V, V) ⇒ V, local: V, Null: V)(implicit arg0: Bounded[P]): V

Collects values down a potential field.

val ClassicGradient: (BlocksWithGC.this)#Gradient

val ClassicHopGradient: (BlocksWithGC.this)#Gradient

def CrfGradient(raisingSpeed: Double = 5, lagMetric: ⇒ Double = nbrLag().toMillis): (BlocksWithGC.this)#Gradient

def FlexGradient(epsilon: Double = 0.5, delta: Double = 1.0, communicationRadius: Double = 1.0): (BlocksWithGC.this)#Gradient

def G[V](source: Boolean, field: V, acc: (V) ⇒ V, metric: () ⇒ Double): V

def Gcurried[V](source: Boolean)(field: V)(acc: (V) ⇒ V)(metric: (StdLib_BlocksWithGC.this)#Metric = nbrRange): V

Curried version of G

def SvdGradient(lagMetric: ⇒ Double = nbrLag().toMillis): (BlocksWithGC.this)#Gradient

def UltGradient(radius: Double = 0.2, factor: Double = 0.1): (BlocksWithGC.this)#Gradient

final def asInstanceOf[T0]: T0

def average(sink: Boolean, value: Double): Double

def bisGradient(commRadius: Double = 0.2, lagMetric: ⇒ Double = nbrLag().toMillis)(source: Boolean, metric: (StdLib_BlocksWithGC.this)#Metric = nbrRange): Double

def broadcast[V](source: Boolean, field: V, metric: (StdLib_BlocksWithGC.this)#Metric = nbrRange): V

Broadcast information outward from a source field.

def captureChange[T](x: T, initially: Boolean = true): Boolean

def channel(source: Boolean, target: Boolean, width: Double): Boolean

A channel from a source to a target with width width.

def classicGradient(source: Boolean, metric: () ⇒ Double = nbrRange): Double

def clone(): AnyRef

def collectCount(alongPotentialField: Double, predicate: Boolean): Long

def collectIntoSet[T](downTo: Double, local: T): Set[T]

Collects a set by merging values

def collectMaps[K, V](downTo: Double, local: Map[K, V], merge: (K, V, V) ⇒ V = (k: K, v1: V, v2: V) => v1): Map[K, V]

Collects a map by merging map entries

def collectMean(alongPotentialField: Double, value: Double): Double

def collectSets[T](downTo: Double, local: Set[T]): Set[T]

Collects a set by merging sets

def collectValuesByDevices[T](downTo: Double, local: T): Map[(StdLib_BlocksWithGC.this)#ID, T]

Collects values as a map by preserving the sources of those values

def constant[T](value: ⇒ T): T

Alias for remember()

def countChanges[T](x: T, initially: Boolean = true): (Long, Boolean)

def crfGradient(raisingSpeed: Double = 5, lagMetric: ⇒ Double = nbrLag().toMillis)(source: Boolean, metric: (StdLib_BlocksWithGC.this)#Metric = nbrRange): Double

def delay[T](value: T): T

It is a simple building block which returns the same values it receives in input delayed by one computation round.

def distanceBetween(source: Boolean, target: Boolean, metric: (StdLib_BlocksWithGC.this)#Metric = nbrRange): Double

Distance between source to target based on metric

def distanceTo(source: Boolean, metric: (StdLib_BlocksWithGC.this)#Metric = nbrRange): Double

A field of distance (i.e., a gradient) from a source, based on a given metric

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

object excludingSelf extends (FieldUtils.this)#FieldOps

def findParent[V](potential: V)(implicit arg0: Bounded[V]): (StdLib_BlocksWithGC.this)#ID

def findParentOpt[V](potential: V)(implicit arg0: Bounded[V]): Option[(StdLib_BlocksWithGC.this)#ID]

def flexGradient(epsilon: Double = 0.5, delta: Double = 1.0, communicationRadius: Double = 1.0)(source: Boolean, metric: (StdLib_BlocksWithGC.this)#Metric = nbrRange): Double

Idea: a device should change its estimate only for significant errors.

final def getClass(): Class[_]

def goesDown(value: Boolean): Boolean

def goesUp(value: Boolean): Boolean

def hashCode(): Int

def hopDistance(source: Boolean): Double

Hop distance

def hopGradient(source: Boolean): Double

object includingSelf extends (FieldUtils.this)#FieldOps

final def isInstanceOf[T0]: Boolean

def keep(expr: ⇒ Boolean): Boolean

Remembers the occurrence of some condition or event

def keep[T](expr: ⇒ Option[T]): Option[T]

Remembers the provided optional value, unless empty

def meanCounter(value: Double, frequency: Long): Double

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def once[T](expr: ⇒ T): Option[T]

Returns a non-empty optional with the provided value just once, then None

def remember[T](value: ⇒ T): T

Remembers the provided value

def roundCounter(): Long

Counts the number of rounds, refreshing each time the computation is re-entered.

def summarize(sink: Boolean, acc: (Double, Double) ⇒ Double, local: Double, Null: Double): Double

def svdGradient(lagMetric: ⇒ Double = nbrLag().toMillis)(source: Boolean, metric: (StdLib_BlocksWithGC.this)#Metric = nbrRange): Double

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

def toString(): String

def ultGradient(radius: Double = 0.2, factor: Double = 0.1)(source: Boolean, metric: (StdLib_BlocksWithGC.this)#Metric = nbrRange): Double

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def G_along[V](g: Double, metric: (StdLib_BlocksWithGC.this)#Metric, field: V, acc: (V) ⇒ V): V

Version of G (Gradient-Cast) that takes a potential field g as input

def Gg[V](gradient: (BlocksWithGC.this)#Gradient, field: V, acc: (V) ⇒ V): V

Version of G (Gradient-Cast) that takes a Gradient algorithm as input.

def finalize(): Unit