Decision

abstract def makePolicy(policyMap: Map[(T, U), DecisionSample]): DecisionPolicy[T, U]

Returns a DecisionPolicy from a map of parent/decision tuple values to DecisionSamples

final def !=(arg0: AnyRef): Boolean

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: AnyRef): Boolean

final def ==(arg0: Any): Boolean

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.

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: (U) ⇒ Boolean, contingency: Contingency = List()): Unit

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

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

Add a contingent constraint to the element.

def addLogConstraint(constraint: (U) ⇒ Double, 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[((U) ⇒ Boolean, Contingency)]

All the conditions defined on this element.

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

The current soft constraints on the element.

def args: List[Element[_]]

The arguments on which the element depends.

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

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 cpd: (T) ⇒ Element[U]

The decision function.

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 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

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

def generateRandomness(): Null

Generate the randomness content.

def generateValue(): U

Generate a value with no randomness.

def generateValue(rand: Randomness): Value

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

def get(parentValue: T): Element[U]

Get the distribution over the result corresponding to the given parent value.

final def getClass(): Class[_]

def getPolicy(): DecisionPolicy[T, U]

Get the complete policy object for this decision

def getPolicy(p: T): Element[U]

Get the decision for a specific value of the parent

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 makePolicy(alg: DecisionAlgorithm[T, U]): DecisionPolicy[T, U]

Returns a DecisionPolicy from the given decision algorithm

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)

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.

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 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 resizeCache(dropValue: T): Map[T, Set[Element[_]]]

var resultElement: Element[U]

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

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: (U) ⇒ Boolean, contingency: Contingency = List()): Unit

Set the condition associated with the contingency.

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

Set the constraint associated with the contingency.

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

Set the log constraint associated with the contingency.

def setPolicy(new_fcn: (T) ⇒ Element[U]): Unit

Directly set the policy of this decision using a function from a parent value to a decision element

def setPolicy(policyMap: Map[(T, U), DecisionSample]): Unit

Set the policy for this decision using a map from parent/decision tuple values to decision samples

def setPolicy(Alg: DecisionAlgorithm[T, U]): Unit

Set the policy for this decision from an Algorithm run on this decision

def setPolicy(): Unit

Set the policy for this decision using the DecisionPolicy class stored in the Decision

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