SingleParameterized

abstract def args: List[Element[_]]

The arguments on which the element depends.

abstract def density(t: T): Double

The probability density of a value.

abstract def distributionToStatistics(distribution: Stream[(Double, T)]): Seq[Double]

Convert a distribution from this element into sufficient statistics

abstract def generateRandomness(): Randomness

Generate the randomness content.

abstract def generateValue(rand: Randomness): Value

Generate the value of the element deterministically given its randomness and the values of its arguments.

abstract val parameter: Parameter[_]

final def !=(arg0: Any): Boolean

def !==(that: Element[Value])(implicit universe: Universe): Neq[Value]

The element that tests inequality of this element with another element.

final def ##(): Int

final def ==(arg0: Any): Boolean

def ===(that: Value)(implicit universe: Universe): Apply1[T, Boolean]

The element that tests whether the value of this element is equal to a particular value.

def ===(that: Element[Value])(implicit universe: Universe): Eq[Value]

The element that tests equality of this element with another element.

def activate(): Unit

Activate the element in its universe.

var active: Boolean

Flag indicating whether the element is currently active in its universe.

def addCondition(condition: Condition, contingency: Contingency = List()): Unit

Add the given condition to the existing conditions of the element.

def addConstraint(constraint: Constraint, contingency: Contingency = List()): Unit

Add a contingent constraint to the element.

def addLogConstraint(constraint: Constraint, contingency: Contingency = List()): Unit

Add a log contingent constraint to the element.

def addPragma(pragma: Pragma[Value]): Unit

Add a pragma to the element.

def allConditions: List[(Condition, Contingency)]

All the conditions defined on this element.

def allConstraints: List[(Constraint, Contingency)]

The current soft constraints on the element.

final def asInstanceOf[T0]: T0

def clearContext(): Unit

Clears all the temporary elements associated with this element (all elements created in it's context).

def clone(): AnyRef

val collection: ElementCollection

The element collection to which this element belongs

def condition(value: Any): Boolean

Tests whether all the element's contingent conditions are satisfied for the given value.

def conditionSatisfied: Boolean

Determines whether the condition on the element is satisfied by the current value.

def constraint(value: Any): Double

Gets the result of all the element's contingent constraints for the given value.

def constraintValue: Double

Determines the value of the constraint on the element applied to the current value.

def context: List[Element[_]]

The elements on which the existence of this element depends.

def deactivate(): Unit

Deactivate the element in its universe.

def directContextContents: Set[Element[_]]

Returns the set of elements directly created in the context of this element.

def distributionToStatistics(p: Parameter[_], distribution: Stream[(Double, T)]): Seq[Double]

Convert a distribution from this element into sufficient statistics for the specified parameter

def elementsIAmContingentOn: Set[Element[_]]

Returns the elements that this element is contingent on.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flatMap[U](fn: (Value) ⇒ Element[U])(implicit name: Name[U], collection: ElementCollection): Element[U]

final def generate(): Unit

First generate the randomness, then generate the value given the randomness.

final def getClass(): Class[_]

val hashCode: Int

def isCachable(): Boolean

The cacheability of the element.

final def isInstanceOf[T0]: Boolean

def isTemporary: Boolean

Returns true if this element is temporary, that is, was created in the context of another element.

def map[U](fn: (Value) ⇒ U)(implicit name: Name[U], collection: ElementCollection): Element[U]

val name: Name[T]

The name of the element

final def ne(arg0: AnyRef): Boolean

def nextRandomness(rand: Randomness): (Randomness, Double, Double)

Generate the next randomness given the current randomness.

final def notify(): Unit

final def notifyAll(): Unit

def observe(observation: Value): Unit

Condition the element by observing a particular value.

val parameters: Set[Parameter[_]]

The parameter for this element.

def pragmas: List[Pragma[Value]]

The pragmas attached to the element.

var randomness: Randomness

The current randomness content of the element.

def removeConditions(contingency: Contingency = List()): Unit

Remove all conditions associated with the given contingency.

def removeConstraint(constraint: Constraint, contingency: Contingency = List()): Unit

def removeConstraints(contingency: Contingency = List()): Unit

Remove all constraints associated with the given contingency.

def removePragma(pragma: Pragma[Value]): Unit

Remove a pragma from the element.

def score(oldValue: Value, newValue: Value): Double

Compute the constraints on the new value divided by the constraints on the old value.

def set(newValue: Value): Unit

Set the value of this element and propagate the effects to elements that depend on it without changing their randomness.

def setCondition(newCondition: Condition, contingency: Contingency = List()): Unit

Set the condition associated with the contingency.

def setConstraint(newConstraint: Constraint, contingency: Contingency = List()): Unit

Set the constraint associated with the contingency.

def setLogConstraint(newConstraint: Constraint, contingency: Contingency = List()): Unit

Set the log constraint associated with the contingency.

def setRandomness(newRandomness: Randomness): Unit

Set the randomness of this element.

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

def toNameString: String

A string that is the element's name, if it has a non-empty one, otherwise the result of the element's toString.

def toString(): String

val universe: Universe

The universe in which the element is defined.

def unobserve(): Unit

Removes conditions on the element and allows different values of the element to be generated.

def unset(): Unit

Allows different values of the element to be generated.

var value: Value

The current value of the element.

final def wait(): Unit

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

final def wait(arg0: Long): Unit