CPD4

Instance Constructors

new CPD4(name: Name[U], arg1: Element[T1], arg2: Element[T2], arg3: Element[T3], arg4: Element[T4], clauses: Seq[((T1, T2, T3, T4), Element[U])], collection: ElementCollection)

Type Members

type Condition = (U) ⇒ Boolean

The type of conditions on the element.
The type of conditions on the element. A condition is a function from a value to a Boolean.

Definition Classes
Element
type Constraint = (U) ⇒ Double

The type of soft constraints on the element.
The type of soft constraints on the element. A constraint is a function from a value to a Double.

Definition Classes
Element
type ParentType = (T1, T2, T3, T4)

The type of the parent argument.
The type of the parent argument.

Definition Classes
Chain
type Randomness = Null

The type of randomness content of the element.
The type of randomness content of the element.

Definition Classes
Deterministic → Element
type Value = U

The type of values over which the element is defined.
The type of values over which the element is defined.

Definition Classes
Element

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

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

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

Definition Classes
Element
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
def ===(that: Value)(implicit universe: Universe): Apply1[U, Boolean]

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

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

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

Definition Classes
Element
def activate(): Unit

Activate the element in its universe.
Activate the element in its universe.

Definition Classes
Element
var active: Boolean

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

Definition Classes
Element
def addCondition(condition: (U) ⇒ Boolean, contingency: Contingency = List()): Unit

Add the given condition to the existing conditions of the element.
Add the given condition to the existing conditions of the element. By default, the contingency is empty.

Definition Classes
Element
def addConstraint(constraint: (U) ⇒ Double, contingency: Contingency = List()): Unit

Add a contingent constraint to the element.
Add a contingent constraint to the element. By default, the contingency is empty.

Definition Classes
Element
def addLogConstraint(constraint: (U) ⇒ Double, contingency: Contingency = List()): Unit

Add a log contingent constraint to the element.
Add a log contingent constraint to the element. By default, the contingency is empty.

Definition Classes
Element
def addPragma(pragma: Pragma[Value]): Unit

Add a pragma to the element.
Add a pragma to the element.

Definition Classes
Element
def allConditions: List[((U) ⇒ Boolean, Contingency)]

All the conditions defined on this element.
All the conditions defined on this element.

Definition Classes
Element
def allConstraints: List[((U) ⇒ Double, Contingency)]

The current soft constraints on the element.
The current soft constraints on the element.

Definition Classes
Element
def args: List[Element[_]]

The arguments on which the element depends.
The arguments on which the element depends.

Definition Classes
Chain → Element
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clearContext(): Unit

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

Definition Classes
Chain → Element
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def condition(value: Any): Boolean

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

Definition Classes
Element
def conditionSatisfied: Boolean

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

Definition Classes
Element
def constraint(value: Any): Double

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

Definition Classes
Element
def constraintValue: Double

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

Definition Classes
Element
def context: List[Element[_]]

The elements on which the existence of this element depends
The elements on which the existence of this element depends

Definition Classes
Element
def cpd: ((T1, T2, T3, T4)) ⇒ Element[U]

Attributes
protected
Definition Classes
Chain
def deactivate(): Unit

Deactivate the element in its universe.
Deactivate the element in its universe.

Definition Classes
Element
def directContextContents: Set[Element[_]]

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

Definition Classes
Chain → Element
def elementsIAmContingentOn: Set[Element[_]]

Definition Classes
Element
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def flatMap[U](fn: (Value) ⇒ Element[U])(implicit name: Name[U], collection: ElementCollection): Element[U]

Definition Classes
Element
final def generate(): Unit

First generate the randomness, then generate the value given the randomness.
First generate the randomness, then generate the value given the randomness. Store the results in randomness and value.

Definition Classes
Element
def generateRandomness(): Null

Generate the randomness content.
Generate the randomness content.

Definition Classes
Deterministic → Element
def generateValue(): U

Generate a value with no randomness.
Generate a value with no randomness.

Definition Classes
Chain → Deterministic
def generateValue(rand: Randomness): Value

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

Definition Classes
Deterministic → Element
def get(parentValue: (T1, T2, T3, T4)): Element[U]

Get the distribution over the result corresponding to the given parent value.
Get the distribution over the result corresponding to the given parent value. Takes care of all bookkeeping including caching.

Definition Classes
Chain
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
val hashCode: Int

Definition Classes
Element → AnyRef → Any
def isCachable(): Boolean

The cacheability of the element.
The cacheability of the element. Chains create caches of their parent values, and it is useful to know when these values can be effectively cached and reused. In general, continuous distributions are not cacheable

Definition Classes
Element
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isTemporary: Boolean

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

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

Definition Classes
Element
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nextRandomness(rand: Randomness): (Randomness, Double, Double)

Generate the next randomness given the current randomness.
Generate the next randomness given the current randomness. Returns three values: The next randomness, the Metropolis-Hastings proposal probability ratio, which is
P(new -> old) / P(old -> new)
and the model probability ratio, which is
P(new) / P(old)
The default implementation is to use generateRandomness and returns ones for the proposal and model probability ratios.

Definition Classes
Element
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def observe(observation: Value): Unit

Condition the element by observing a particular value.
Condition the element by observing a particular value. Propagates the effect to dependent elements and ensures that no other value for the element can be generated.

Definition Classes
Element
val parent: Element[(T1, T2, T3, T4)]

Definition Classes
Chain
def pragmas: List[Pragma[Value]]

The pragmas attached to the element.
The pragmas attached to the element.

Definition Classes
Element
var randomness: Randomness

The current randomness content of the element.
The current randomness content of the element.

Definition Classes
Element
def removeConditions(contingency: Contingency = List()): Unit

Remove all conditions associated with the given contingency.
Remove all conditions associated with the given contingency. By default, the contingency is empty.

Definition Classes
Element
def removeConstraints(contingency: Contingency = List()): Unit

Remove all constraints associated with the given contingency.
Remove all constraints associated with the given contingency. By default, the contingency is empty.

Definition Classes
Element
def removePragma(pragma: Pragma[Value]): Unit

Remove a pragma from the element.
Remove a pragma from the element.

Definition Classes
Element
def resizeCache(dropValue: (T1, T2, T3, T4)): Map[(T1, T2, T3, T4), Set[Element[_]]]

Attributes
protected
Definition Classes
Chain
var resultElement: Element[U]

The current result element that arises from the current value of the parent.
The current result element that arises from the current value of the parent.

Definition Classes
Chain
def score(oldValue: Value, newValue: Value): Double

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

Definition Classes
Element
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.
Set the value of this element and propagate the effects to elements that depend on it without changing their randomness. Also disallows the value of the element to change until unobserve or unset is called.

Definition Classes
Element
def setCondition(newCondition: (U) ⇒ Boolean, contingency: Contingency = List()): Unit

Set the condition associated with the contingency.
Set the condition associated with the contingency. Removes previous conditions associated with the contingency. By default, the contingency is empty.

Definition Classes
Element
def setConstraint(newConstraint: (U) ⇒ Double, contingency: Contingency = List()): Unit

Set the constraint associated with the contingency.
Set the constraint associated with the contingency. Removes previous constraints associated with the contingency. By default, the contingency is empty.

Definition Classes
Element
def setLogConstraint(newConstraint: (U) ⇒ Double, contingency: Contingency = List()): Unit

Set the log constraint associated with the contingency.
Set the log constraint associated with the contingency. Removes previous constraints associated with the contingency. By default, the contingency is empty.

Definition Classes
Element
def setRandomness(newRandomness: Randomness): Unit

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

Definition Classes
Element
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
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
A string that is the element's name, if it has a non-empty one, otherwise the result of the element's toString

Definition Classes
Element
def toString(): String

Definition Classes
Chain → AnyRef → Any
val universe: Universe

The universe in which the element is defined.
The universe in which the element is defined.

Definition Classes
Element
def unobserve(): Unit

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

Definition Classes
Element
def unset(): Unit

Allows different values of the element to be generated.
Allows different values of the element to be generated.

Definition Classes
Element
var value: Value

The current value of the element.
The current value of the element.

Definition Classes
Element
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

class CPD4[T1, T2, T3, T4, U] extends CachingChain[(T1, T2, T3, T4), U]

Instance Constructors

new CPD4(name: Name[U], arg1: Element[T1], arg2: Element[T2], arg3: Element[T3], arg4: Element[T4], clauses: Seq[((T1, T2, T3, T4), Element[U])], collection: ElementCollection)

Type Members

type Condition = (U) ⇒ Boolean

type Constraint = (U) ⇒ Double

type ParentType = (T1, T2, T3, T4)

type Randomness = Null

type Value = U

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

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

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

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

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

def activate(): Unit

var active: Boolean

def addCondition(condition: (U) ⇒ Boolean, contingency: Contingency = List()): Unit

def addConstraint(constraint: (U) ⇒ Double, contingency: Contingency = List()): Unit

def addLogConstraint(constraint: (U) ⇒ Double, contingency: Contingency = List()): Unit

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

def allConditions: List[((U) ⇒ Boolean, Contingency)]

def allConstraints: List[((U) ⇒ Double, Contingency)]

def args: List[Element[_]]

final def asInstanceOf[T0]: T0

def clearContext(): Unit

def clone(): AnyRef

def condition(value: Any): Boolean

def conditionSatisfied: Boolean

def constraint(value: Any): Double

def constraintValue: Double

def context: List[Element[_]]

def cpd: ((T1, T2, T3, T4)) ⇒ Element[U]

def deactivate(): Unit

def directContextContents: Set[Element[_]]

def elementsIAmContingentOn: Set[Element[_]]

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

def generateRandomness(): Null

def generateValue(): U

def generateValue(rand: Randomness): Value

def get(parentValue: (T1, T2, T3, T4)): Element[U]

final def getClass(): Class[_]

val hashCode: Int

def isCachable(): Boolean

final def isInstanceOf[T0]: Boolean

def isTemporary: Boolean

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

final def ne(arg0: AnyRef): Boolean

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

final def notify(): Unit

final def notifyAll(): Unit

def observe(observation: Value): Unit

val parent: Element[(T1, T2, T3, T4)]

def pragmas: List[Pragma[Value]]

var randomness: Randomness

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

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

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

def resizeCache(dropValue: (T1, T2, T3, T4)): Map[(T1, T2, T3, T4), Set[Element[_]]]

var resultElement: Element[U]

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

def set(newValue: Value): Unit

def setCondition(newCondition: (U) ⇒ Boolean, contingency: Contingency = List()): Unit

def setConstraint(newConstraint: (U) ⇒ Double, contingency: Contingency = List()): Unit

def setLogConstraint(newConstraint: (U) ⇒ Double, contingency: Contingency = List()): Unit

def setRandomness(newRandomness: Randomness): Unit

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

def toNameString: String

def toString(): String

val universe: Universe

def unobserve(): Unit

def unset(): Unit